Merge origin/master: web permission sandbox, default pi-ai providers

examples/headless-agent/tests/fixtures/guard/source-guard/cordis.yml

@@ -0,0 +1,38 @@
+# Test-only composition: the model attempts one `write` into a staging-shaped
+# git fixture, so the guard's denial is observed through the real Loader and app.
+- id: source-guard-mock-llm
+  name: './mock-llm.ts'
+
+# Managed child-process groups for the bash executor (spawn/kill/output plumbing).
+- id: subprocess
+  name: '@deepseek-ai/dsh-subprocess-local'
+
+- id: bash
+  name: '@deepseek-ai/dsh-bash-local'
+
+- id: fs
+  name: '@deepseek-ai/dsh-fs-local'
+
+# Read-before-edit policy: without it the write would resolve `createIfAbsent`
+# and the transcript would not show the guard as the sole reason for refusal.
+- id: fs-policy
+  name: '@deepseek-ai/dsh-fs-policy'
+
+- id: tool-fs
+  name: '@deepseek-ai/dsh-tool-fs'
+
+# Mounts the guard with `protectedCheckout` resolved against the process cwd, so
+# it arms for the staging fixture the smoke builds there rather than for the
+# checkout running the test (the config default is this module's own location).
+- id: source-guard-fixture
+  name: './mount-guard.ts'
+
+- id: cli-agent
+  name: '@deepseek-ai/dsh-cli-demo'
+  config:
+    provider: source-guard-mock
+    model: source-guard-mock
+    persona: 'Test the source guard.'
+    persistenceRoot: './.sessions'
+    persistenceCompression: none
+    workspaceContext: false

examples/headless-agent/tests/fixtures/guard/source-guard/mock-llm.ts

@@ -0,0 +1,43 @@
+import { resolve } from 'node:path'
+import type { Context } from 'cordis'
+import { CallId, LlmAdapter, type GenerateOptions, type StreamChunk } from '@deepseek-ai/dsh-llm'
+
+/** The staged file the smoke builds in the process cwd; the guard must refuse to write it. */
+const TARGET = resolve('staging/guarded.ts')
+
+/**
+ * Two-step adapter for the source-guard Loader fixture: the first step calls
+ * `write` on the staged file, the second closes the turn once a tool result has
+ * come back, so the transcript records what the model received.
+ */
+class SourceGuardMockAdapter extends LlmAdapter {
+  async * stream(options: GenerateOptions): AsyncIterable<StreamChunk> {
+    const alreadyCalled = options.messages.some(message => message.content.some(
+      block => block.type === 'tool-result',
+    ))
+    if (alreadyCalled) {
+      const text = 'denied as expected'
+      yield { type: 'block-start', index: 0, blockType: 'text' }
+      yield { type: 'text-delta', index: 0, text }
+      yield { type: 'block-end', index: 0, block: { type: 'text', text } }
+      yield { type: 'usage', usage: { inputTokens: 1, outputTokens: 1 } }
+      yield { type: 'finish', reason: { kind: 'stop' } }
+      return
+    }
+    const callId = CallId('source-guard-write')
+    const args = JSON.stringify({ file_path: TARGET, content: 'edited\n' })
+    yield { type: 'block-start', index: 0, blockType: 'tool-call' }
+    yield { type: 'tool-call-delta', index: 0, id: callId, name: 'write', argumentsDelta: args }
+    yield { type: 'block-end', index: 0, block: { type: 'tool-call', id: callId, name: 'write', arguments: args } }
+    yield { type: 'usage', usage: { inputTokens: 1, outputTokens: 1 } }
+    yield { type: 'finish', reason: { kind: 'tool-calls' } }
+  }
+}
+
+export const name = 'source-guard-mock-llm'
+export const inject = ['llm']
+
+/** Register the test-only `source-guard-mock` adapter. */
+export function apply(ctx: Context): void {
+  ctx.llm.registerAdapter(['source-guard-mock'], new SourceGuardMockAdapter())
+}

examples/headless-agent/tests/fixtures/guard/source-guard/mount-guard.ts

@@ -0,0 +1,14 @@
+import { resolve } from 'node:path'
+import type { Context } from 'cordis'
+import * as SourceGuard from '@deepseek-ai/dsh-source-guard'
+
+export const name = 'source-guard-fixture'
+
+/**
+ * Mount the real guard against the staging fixture in the process cwd. The
+ * checkout under protection is a runtime fact of the isolated smoke directory,
+ * which no static config value can name.
+ */
+export async function apply(ctx: Context): Promise<void> {
+  await ctx.plugin(SourceGuard, { protectedCheckout: resolve('staging/guard-anchor.ts') })
+}