feat(mothership): run_function + streamed file-write handlers registered

Companion to mothership 0c5ec22b. run_function routes to the restored
function-execute handler (write-capable sandbox); the streamed file-writing
pair returns — workspaceFileServerTool survived the revamp unregistered,
editContentServerTool recovered from the pre-revamp tree — and the intact
preview machinery keys off their frames again. files grep joins the agent
augmentations (v2 read-text based, degraded-file aware).

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

Author: Sg312

apps/sim/lib/mothership/tool-executor/register-handlers.ts

@@ -7,6 +7,7 @@ import {
 } from '@/lib/mothership/generated/tool-catalog-v1'
 import { createServerToolHandler } from '@/lib/mothership/tools/registry/server-tool-adapter'
 import { getRegisteredServerToolNames } from '@/lib/mothership/tools/server/router'
+import { executeFunctionExecute } from '../tools/handlers/function-execute'
 import { executeRunCode } from '../tools/handlers/run-code'
 import { executeSimCli } from '../tools/handlers/sim-cli'
 import {
@@ -54,6 +55,9 @@ function buildHandlerMap(): Record<string, ToolHandler> {
     // (E2B/VM, mounts, secret materialization) lives on this side, same as the
     // workflow Function block. Compute-only: the handler rejects write vectors.
     run_code: h(executeRunCode),
+    // The write-capable variant: same sandbox, plus outputs.files workspace
+    // export and outputTable overwrite.
+    run_function: h(executeFunctionExecute),
     // The worker's CLI surface, executed in-process via the CLI's own command
     // tree (sim/embed) against this deployment's internal API base.
     sim_cli: h(executeSimCli),

apps/sim/lib/mothership/tools/handlers/agent-cli/agent-cli.test.ts

@@ -120,6 +120,44 @@ describe('workflow views', () => {
   })
 })
 
+describe('files grep', () => {
+  const FILES_LIST = {
+    data: [
+      { id: 'f1', name: 'report.md', folderPath: 'docs' },
+      { id: 'f2', name: 'logo.png', folderPath: '' },
+    ],
+    nextCursor: null,
+  }
+  const readText = (text: string, degraded = false) => ({
+    data: { text, degraded },
+  })
+
+  it('greps file contents with line numbers, skipping non-text files', async () => {
+    const match = matchAgentCliCommand(['files', 'grep', 'quarterly'])
+    const result = await executeAgentCliCommand(
+      match!,
+      runtimeWith({
+        '/api/v2/files': FILES_LIST,
+        '/api/v2/files/f1/text': readText('# Report\nQuarterly revenue was up.\n'),
+        '/api/v2/files/f2/text': readText('', true),
+      })
+    )
+    expect(result.exitCode).toBe(0)
+    expect(result.stdout).toContain('docs/report.md:2: Quarterly revenue was up.')
+    expect(result.stdout).not.toContain('logo.png')
+  })
+
+  it('filters by folder prefix', async () => {
+    const match = matchAgentCliCommand(['files', 'grep', 'Quarterly', 'other'])
+    const result = await executeAgentCliCommand(
+      match!,
+      runtimeWith({ '/api/v2/files': FILES_LIST })
+    )
+    expect(result.exitCode).toBe(0)
+    expect(result.stdout).toContain('No matches')
+  })
+})
+
 describe('workflow grep', () => {
   it('reports matches as path: value lines', async () => {
     const match = matchAgentCliCommand(['workflow', 'grep', 'wf-1', 'Summarize'])

apps/sim/lib/mothership/tools/handlers/agent-cli/commands/files-grep.ts

@@ -0,0 +1,109 @@
+import type { ListFilesResponse, ReadFileTextResponse } from 'sim/embed'
+import {
+  type AgentCliCommand,
+  type AgentCliRuntime,
+  agentCliFail,
+  agentCliOk,
+} from '@/lib/mothership/tools/handlers/agent-cli/types'
+
+/**
+ * Content grep across workspace files (the Go copilot's VFS-wide grep, files
+ * half). Text extraction rides the v2 read-text endpoint, which already
+ * handles binary/degraded files honestly, so this stays a pure projection.
+ */
+
+const MAX_MATCHES = 200
+const MAX_FILES = 300
+const MAX_BYTES_PER_FILE = 262_144
+const READ_CONCURRENCY = 5
+const CONTEXT_CHARS = 120
+
+function compilePattern(raw: string): (value: string) => boolean {
+  try {
+    const regex = new RegExp(raw, 'i')
+    return (value) => regex.test(value)
+  } catch {
+    const needle = raw.toLowerCase()
+    return (value) => value.toLowerCase().includes(needle)
+  }
+}
+
+function matchingLines(
+  text: string,
+  matches: (value: string) => boolean,
+  label: string,
+  out: string[]
+): void {
+  const lines = text.split('\n')
+  for (let lineNo = 0; lineNo < lines.length && out.length < MAX_MATCHES; lineNo++) {
+    const line = lines[lineNo]
+    if (!matches(line)) continue
+    const snippet = line.length > CONTEXT_CHARS ? `${line.slice(0, CONTEXT_CHARS)}…` : line
+    out.push(`${label}:${lineNo + 1}: ${snippet.trim()}`)
+  }
+}
+
+async function listAllFiles(runtime: AgentCliRuntime): Promise<ListFilesResponse['data']> {
+  const rows: ListFilesResponse['data'] = []
+  let cursor: string | null = null
+  do {
+    const page: ListFilesResponse = await runtime.client.request<ListFilesResponse>(
+      '/api/v2/files',
+      {
+        query: { workspaceId: runtime.workspaceId, ...(cursor ? { cursor } : {}) },
+      }
+    )
+    rows.push(...page.data)
+    cursor = page.nextCursor
+  } while (cursor && rows.length < MAX_FILES)
+  return rows.slice(0, MAX_FILES)
+}
+
+export const filesGrepCommand: AgentCliCommand = {
+  path: ['files', 'grep'],
+  summary: 'Search the content of every workspace file for a pattern',
+  usage: 'files grep <pattern> [folder-path-prefix]',
+  async execute(rest, runtime) {
+    const [pattern, folderPrefix] = [rest[0], rest[1]]
+    if (!pattern) return agentCliFail('Usage: sim files grep <pattern> [folder-path-prefix]')
+    const matches = compilePattern(pattern)
+    const files = (await listAllFiles(runtime)).filter(
+      (file) => !folderPrefix || file.folderPath.startsWith(folderPrefix)
+    )
+    const out: string[] = []
+    let unreadable = 0
+    for (let i = 0; i < files.length && out.length < MAX_MATCHES; i += READ_CONCURRENCY) {
+      const batch = files.slice(i, i + READ_CONCURRENCY)
+      const texts = await Promise.all(
+        batch.map(async (file) => {
+          try {
+            const response = await runtime.client.request<ReadFileTextResponse>(
+              `/api/v2/files/${encodeURIComponent(file.id)}/text`,
+              { query: { workspaceId: runtime.workspaceId, maxBytes: String(MAX_BYTES_PER_FILE) } }
+            )
+            return { file, text: response.data.degraded ? null : response.data.text }
+          } catch {
+            // Binary or unreadable files must not sink the whole search.
+            return { file, text: null }
+          }
+        })
+      )
+      for (const { file, text } of texts) {
+        const label = file.folderPath ? `${file.folderPath}/${file.name}` : file.name
+        if (matches(file.name) && out.length < MAX_MATCHES) out.push(`${label}: name matches`)
+        if (text === null) {
+          unreadable++
+          continue
+        }
+        matchingLines(text, matches, label, out)
+      }
+    }
+    if (out.length === 0) {
+      return agentCliOk(
+        unreadable > 0 ? `No matches (${unreadable} non-text files skipped).` : 'No matches.'
+      )
+    }
+    const capped = out.length >= MAX_MATCHES ? [...out, `[capped at ${MAX_MATCHES} matches]`] : out
+    return agentCliOk(capped.join('\n'))
+  },
+}

apps/sim/lib/mothership/tools/handlers/agent-cli/index.ts

@@ -1,3 +1,4 @@
+import { filesGrepCommand } from '@/lib/mothership/tools/handlers/agent-cli/commands/files-grep'
 import {
   workflowGrepCommand,
   workflowsGrepCommand,
@@ -20,6 +21,7 @@ import {
  * automatically.
  */
 const AGENT_CLI_COMMANDS: readonly AgentCliCommand[] = [
+  filesGrepCommand,
   workflowBlocksCommand,
   workflowEdgesCommand,
   workflowGrepCommand,