mothership agent-cli: fixes from the exploration run

- docs search: the engine builds the secret-trace registry
  (prepareCopilotEnvironmentContext) — without it the docs tool refused every
  query as 'could not be processed safely'.
- universal grep: workspaceId on the list and detail requests that require it
  (the export route takes none); the A2 tests had mocked the client.
- run-cli: strip ANSI escapes from CLI stdout/stderr (chalk keys off the
  hosting server's TTY).
- pipeline: the jq/outline non-JSON error names | grep instead of a flag the
  caller already passed; the to-sandbox notice names /home/user/<name>.
- sim-cli embed path only (public CLI unchanged): positional file arguments
  (tables import, files upload, knowledge documents upload) read from the
  host's pre-read @path map and refuse anything else; files get --output-file
  writes through EmbedContext.writeFile (the chat sandbox) instead of the
  server's disk, which is where it had been landing. embedded-files.test.ts.

Claude-Session: https://claude.ai/code/session_01HFVhPDtRZuCgupPco633w8

Author: Sg312

apps/sim/lib/mothership/agent-cli/engines/docs-search.test.ts

@@ -8,6 +8,12 @@ const { execute } = vi.hoisted(() => ({
     .fn()
     .mockResolvedValue({ results: [{ path: 'docs/integrations/slack.mdx' }], query: 'q' }),
 }))
+vi.mock('@/lib/mothership/environment-context', () => ({
+  prepareCopilotEnvironmentContext: vi.fn(async () => ({
+    resolvedSecretTraceRegistry: { registry: 'stub' },
+  })),
+}))
+
 vi.mock('@/lib/mothership/tools/server/docs/search-docs', () => ({
   searchDocsServerTool: { execute },
 }))
@@ -30,7 +36,7 @@ describe('docs search engine', () => {
     expect(result.exitCode).toBe(0)
     expect(execute).toHaveBeenCalledWith(
       { query: 'slack streaming', topK: 3, path: 'docs/integrations' },
-      { userId: 'user-1', workspaceId: 'ws-1' }
+      { userId: 'user-1', workspaceId: 'ws-1', resolvedSecretTraceRegistry: { registry: 'stub' } }
     )
     expect(JSON.parse(result.stdout).results[0].path).toBe('docs/integrations/slack.mdx')
   })

apps/sim/lib/mothership/agent-cli/engines/docs-search.ts

@@ -4,6 +4,7 @@ import {
   agentCliFail,
   agentCliOk,
 } from '@/lib/mothership/agent-cli/types'
+import { prepareCopilotEnvironmentContext } from '@/lib/mothership/environment-context'
 import { searchDocsServerTool } from '@/lib/mothership/tools/server/docs/search-docs'
 
 const DEFAULT_TOP = 6
@@ -29,9 +30,13 @@ export const docsSearchCommand: AgentCliEngine = {
     const top = topFrom(flags)
     if (typeof top === 'string') return agentCliFail(top)
     const path = typeof flags.path === 'string' ? flags.path : undefined
+    const { resolvedSecretTraceRegistry } = await prepareCopilotEnvironmentContext(
+      runtime.userId,
+      runtime.workspaceId
+    )
     const output = await searchDocsServerTool.execute(
       { query, topK: top, ...(path ? { path } : {}) },
-      { userId: runtime.userId, workspaceId: runtime.workspaceId }
+      { userId: runtime.userId, workspaceId: runtime.workspaceId, resolvedSecretTraceRegistry }
     )
     return agentCliOk(JSON.stringify(output, null, 2))
   },

apps/sim/lib/mothership/agent-cli/engines/universal-grep.ts

@@ -59,7 +59,7 @@ async function listAll(runtime: AgentCliRuntime, path: string): Promise<Record<s
   let cursor: string | undefined
   for (let pages = 0; pages < 50; pages++) {
     const page = await runtime.client.request<Page>(path, {
-      query: { limit: '100', ...(cursor ? { cursor } : {}) },
+      query: { workspaceId: runtime.workspaceId, limit: '100', ...(cursor ? { cursor } : {}) },
     })
     out.push(...page.data)
     if (!page.nextCursor) break
@@ -96,6 +96,8 @@ const MATERIALIZERS: Record<Scope, (runtime: AgentCliRuntime) => Promise<Materia
     const list = await listAll(runtime, '/api/v2/workflows')
     return mapConcurrent(list, FETCH_CONCURRENCY, async (w) => {
       const id = str(w.id) ?? ''
+      // The export route scopes by workflow id alone (`query: noInputSchema`); a
+      // workspaceId here is an "Unrecognized key" — the other detail routes require it.
       const exported = await runtime.client.request<{ data: { state: unknown } }>(
         `/api/v2/workflows/${id}/export`
       )
@@ -109,7 +111,9 @@ const MATERIALIZERS: Record<Scope, (runtime: AgentCliRuntime) => Promise<Materia
     const list = await listAll(runtime, '/api/v2/blocks')
     const materialized = await mapConcurrent(list, FETCH_CONCURRENCY, async (b) => {
       const id = str(b.id) ?? ''
-      const detail = await runtime.client.request<{ data: unknown }>(`/api/v2/blocks/${id}`)
+      const detail = await runtime.client.request<{ data: unknown }>(`/api/v2/blocks/${id}`, {
+        query: { workspaceId: runtime.workspaceId },
+      })
       return render('blocks', id, id, detail.data)
     })
     catalogCache.set(key, materialized)
@@ -123,23 +127,29 @@ const MATERIALIZERS: Record<Scope, (runtime: AgentCliRuntime) => Promise<Materia
     const list = await listAll(runtime, '/api/v2/tables')
     return mapConcurrent(list, FETCH_CONCURRENCY, async (t) => {
       const id = str(t.id) ?? ''
-      const detail = await runtime.client.request<{ data: unknown }>(`/api/v2/tables/${id}`)
+      const detail = await runtime.client.request<{ data: unknown }>(`/api/v2/tables/${id}`, {
+        query: { workspaceId: runtime.workspaceId },
+      })
       return render('tables', id, str(t.name) ?? id, detail.data)
     })
   },
   skills: async (runtime) => {
     const list = await listAll(runtime, '/api/v2/skills')
     return mapConcurrent(list, FETCH_CONCURRENCY, async (s) => {
       const id = str(s.id) ?? ''
-      const detail = await runtime.client.request<{ data: unknown }>(`/api/v2/skills/${id}`)
+      const detail = await runtime.client.request<{ data: unknown }>(`/api/v2/skills/${id}`, {
+        query: { workspaceId: runtime.workspaceId },
+      })
       return render('skills', id, str(s.name) ?? id, detail.data)
     })
   },
   'custom-tools': async (runtime) => {
     const list = await listAll(runtime, '/api/v2/custom-tools')
     return mapConcurrent(list, FETCH_CONCURRENCY, async (t) => {
       const id = str(t.id) ?? ''
-      const detail = await runtime.client.request<{ data: unknown }>(`/api/v2/custom-tools/${id}`)
+      const detail = await runtime.client.request<{ data: unknown }>(`/api/v2/custom-tools/${id}`, {
+        query: { workspaceId: runtime.workspaceId },
+      })
       return render('custom-tools', id, str(t.title) ?? str(t.name) ?? id, detail.data)
     })
   },

apps/sim/lib/mothership/agent-cli/pipeline.test.ts

@@ -113,7 +113,7 @@ describe('jq and outline over JSON stdout', () => {
 
   it('fails the invocation with the reason when stdout is not JSON or the program is bad', async () => {
     expect(await applyPipeline('plain text', [{ kind: 'jq', expression: '.' }])).toContain(
-      'stdout is not JSON'
+      'output is text, not JSON'
     )
     expect(await applyPipeline(json, [{ kind: 'jq', expression: '.data |' }])).toContain('jq:')
   })

apps/sim/lib/mothership/agent-cli/pipeline.ts

@@ -63,7 +63,7 @@ function parseJsonStdout(stdout: string, stage: string): JsonValue {
     return parsed
   } catch {
     throw new PipeStageError(
-      `${stage}: stdout is not JSON. Run the command with --output json before piping into ${stage}.`
+      `${stage}: this command's output is text, not JSON, so ${stage} cannot apply. Filter it with | grep instead, or use outputs get <id> --grep on a stored result.`
     )
   }
 }

apps/sim/lib/mothership/agent-cli/run-cli.ts

@@ -1,5 +1,8 @@
 import { type EmbeddedCliIdentity, runEmbeddedCli } from 'sim/embed'
-import { readSessionSandboxFile } from '@/lib/execution/remote-sandbox/session-files'
+import {
+  readSessionSandboxFile,
+  writeSessionSandboxFile,
+} from '@/lib/execution/remote-sandbox/session-files'
 import type { AgentCliRawResult } from '@/lib/mothership/generated/agent-cli'
 
 /**
@@ -27,5 +30,27 @@ export async function runCli(
       if (read.outcome === 'read') fileArguments[path] = read.content
     }
   }
-  return runEmbeddedCli(argv, identity, { fileArguments })
+  // Downloads land on the same machine `@path` reads from; without a sandbox session
+  // the CLI refuses rather than writing to the server's disk.
+  const writeFile = sessionKey
+    ? async (path: string, content: Uint8Array) =>
+        (await writeSessionSandboxFile(sessionKey, path, Buffer.from(content).toString('utf8')))
+          .outcome === 'written'
+    : undefined
+  const result = await runEmbeddedCli(argv, identity, {
+    fileArguments,
+    ...(writeFile ? { writeFile } : {}),
+  })
+  return { ...result, stdout: stripAnsi(result.stdout), stderr: stripAnsi(result.stderr) }
+}
+
+const ANSI_SEQUENCE = /\[[0-9;?]*[ -/]*[@-~]/g
+
+/**
+ * The CLI colours its notes with chalk, which keys off the HOSTING server's TTY — so an
+ * embedded run on a dev server hands the model `…` around every
+ * truncation notice. The model reads text, never a terminal: strip escapes on the way out.
+ */
+function stripAnsi(text: string): string {
+  return text.replace(ANSI_SEQUENCE, '')
 }

apps/sim/lib/mothership/agent-cli/sink.ts

@@ -1,4 +1,7 @@
-import { writeSessionSandboxFile } from '@/lib/execution/remote-sandbox/session-files'
+import {
+  resolveSessionPath,
+  writeSessionSandboxFile,
+} from '@/lib/execution/remote-sandbox/session-files'
 import type { AgentCliRawResult, AgentCliSink } from '@/lib/mothership/generated/agent-cli'
 
 /**
@@ -22,7 +25,7 @@ export async function applySink(
   if (written.outcome === 'written') {
     return {
       ...result,
-      stdout: `[stdout written to ${sink.path} on your machine: ${result.stdout.length} chars. Read or process it with run_code, or pass it back as @${sink.path}.]`,
+      stdout: `[stdout written to ${resolveSessionPath(sink.path)} on your machine: ${result.stdout.length} chars. Read or process it with run_code, or pass it back as @${sink.path}.]`,
     }
   }
   if (written.outcome === 'no-session') {

packages/sim-cli/src/commands/protocol/files-get.ts

@@ -6,6 +6,7 @@ import { Readable, type Writable } from 'node:stream'
 import { pipeline } from 'node:stream/promises'
 import type { Command } from 'commander'
 import { clientFrom } from '../../context'
+import { embedStore } from '../../embed-context'
 import { V2_OPERATIONS } from '../../generated/v2-api'
 import { isRequestTimeout, RAISE_TIMEOUT_HINT, resolvePath, SimApiError } from '../../http/client'
 import { printProtocolResult } from './result'
@@ -202,6 +203,26 @@ export async function saveToFile(
   target: string,
   force: boolean
 ): Promise<void> {
+  const embedded = embedStore.getStore()
+  if (embedded) {
+    // In-process on the hosting server: the only legitimate destination is the
+    // caller's own machine, and the host decides how to reach it.
+    if (!embedded.writeFile) {
+      throw new SimApiError(
+        `--output-file cannot save ${target} here: this surface has no machine to write to. Read the file instead, or pipe a text command with | to-sandbox <name>.`,
+        0
+      )
+    }
+    const bytes = new Uint8Array(await new Response(body).arrayBuffer())
+    const written = await embedded.writeFile(target, bytes)
+    if (!written) {
+      throw new SimApiError(
+        `Could not write ${target} on your machine — the workbench is not running yet; run any run_code call first, then retry.`,
+        0
+      )
+    }
+    return
+  }
   return saveStagedFile(body, target, force)
 }
 

packages/sim-cli/src/embed-context.ts

@@ -31,6 +31,12 @@ export interface EmbedContext {
    * clear another's failure.
    */
   softExitCode?: number
+  /**
+   * Where a download lands when embedded: the host writes to the caller's own machine
+   * (the chat's sandbox), never to the server's disk. Resolves true when written, false
+   * when the caller has no machine to write to right now.
+   */
+  writeFile?: (path: string, content: Uint8Array) => Promise<boolean>
 }
 
 /** The embedded-vs-standalone seam for soft-fail codes: context when embedded, global otherwise. */

packages/sim-cli/src/embed.ts

@@ -69,14 +69,15 @@ export function createEmbeddedClient(identity: EmbeddedCliIdentity): SimClient {
 export async function runEmbeddedCli(
   argv: string[],
   identity: EmbeddedCliIdentity,
-  options?: { fileArguments?: Record<string, string> }
+  options?: { fileArguments?: Record<string, string>; writeFile?: EmbedContext['writeFile'] }
 ): Promise<EmbeddedCliResult> {
   installEmbedSinks()
   const ctx: EmbedContext = {
     identity,
     stdout: [],
     stderr: [],
     ...(options?.fileArguments ? { fileArguments: options.fileArguments } : {}),
+    ...(options?.writeFile ? { writeFile: options.writeFile } : {}),
   }
   return embedStore.run(ctx, async () => {
     let exitCode = 0