@11agents/cli 0.1.14 → 0.1.16

package/README.md

@@ -107,10 +107,11 @@ On startup, and every 30 minutes after that, the daemon syncs project metadata a
 - Cloud database snapshot: `~/.11agents/<project>/database/snapshot.json`
 - Task scratch directory: `~/.11agents/<project>/tmp/<taskId>/`
 - Task execution logs: `~/.11agents/<project>/runs/<taskId>/`
+- Current claimed task marker: `~/.11agents/claim_id`
 
-Codex runs from `~/.11agents/<project>/` by default. Treat that directory as read-only project context. Task code may write temporary files only under `./tmp/<taskId>/`; the daemon removes that task scratch directory after the task finishes. Agent environment variables from the control plane are injected into the Codex child process and are not written to disk.
+Codex runs from `~/.11agents/<project>/` by default. Treat that directory as read-only project context. Task code may write temporary files only under `./tmp/<taskId>/`; the daemon removes that task scratch directory after the task finishes. Agent environment variables from the control plane are injected into the Codex child process and are not written to disk. Each run directory stores `prompt.md`, raw Codex JSONL in `stdout.log`, readable Codex dialogue in `transcript.log`, `stderr.log`, `last_message.md`, `completion.json`, and `meta.json`.
 
-The built-in Codex worker starts task executions with `codex --yolo exec` and prefixes the task prompt with `/goal ` by default so remote runtime tasks can run without approval prompts or sandbox restrictions. To opt a daemon back into a Codex sandbox, start it with `--codex-sandbox read-only`, `--codex-sandbox workspace-write`, or `--codex-sandbox danger-full-access`.
+The built-in Codex worker starts task executions with `codex --yolo exec --json --output-last-message <run>/last_message.md` and prefixes the task prompt with `/goal ` by default so remote runtime tasks can run without approval prompts or sandbox restrictions. To opt a daemon back into a Codex sandbox, start it with `--codex-sandbox read-only`, `--codex-sandbox workspace-write`, or `--codex-sandbox danger-full-access`.
 
 The built-in task runner currently supports Codex tasks. A custom handler may export:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@11agents/cli",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "11agents local runtime and telemetry CLI",
   "type": "module",
   "bin": {

package/src/commands/logs.js

@@ -58,6 +58,7 @@ export async function formatTaskLog({ taskId, project = '', homeDir = homedir(),
 
   const stdout = tailText(await readText(path.join(runDir, 'stdout.log'), ''), tail)
   const stderr = tailText(await readText(path.join(runDir, 'stderr.log'), ''), tail)
+  const transcript = tailText(await readText(path.join(runDir, 'transcript.log'), ''), tail)
   const completion = await readText(path.join(runDir, 'completion.json'), '')
   return [
     `task: ${meta.task_id || taskId}`,
@@ -67,6 +68,9 @@ export async function formatTaskLog({ taskId, project = '', homeDir = homedir(),
     `exit_code: ${meta.exit_code ?? ''}`,
     `run_dir: ${runDir}`,
     '',
+    'transcript:',
+    transcript,
+    '',
     'stdout:',
     stdout,
     '',

package/src/commands/runtime.js

@@ -74,6 +74,7 @@ function runtimeDeps(overrides = {}) {
     log: overrides.log || (value => console.log(value)),
     homeDir: overrides.homeDir || os.homedir(),
     runCodex: overrides.runCodex || runCodex,
+    runClaude: overrides.runClaude || runClaude,
     runProcess: overrides.runProcess || runProcess,
     requestJson: overrides.requestJson || requestJson,
     sleep: overrides.sleep || sleep,
@@ -82,6 +83,29 @@ function runtimeDeps(overrides = {}) {
   }
 }
 
+function currentClaimPath(homeDir) {
+  return path.join(homeDir, '.11agents', 'claim_id')
+}
+
+async function writeCurrentClaim(deps, task, machineKey) {
+  const payload = {
+    task_id: String(task.id || ''),
+    runtime_id: String(task.runtime_id || task.runtime?.id || ''),
+    machine_key: String(task.runtime?.machine_key || machineKey || ''),
+  }
+  await mkdir(path.dirname(currentClaimPath(deps.homeDir)), { recursive: true })
+  await writeFile(currentClaimPath(deps.homeDir), JSON.stringify(payload))
+  return payload
+}
+
+async function readCurrentClaim(deps) {
+  return readJsonFile(currentClaimPath(deps.homeDir), null)
+}
+
+async function clearCurrentClaim(deps) {
+  await rm(currentClaimPath(deps.homeDir), { force: true })
+}
+
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error)
 }
@@ -263,6 +287,98 @@ function normalizeTaskCompletion(task, completion) {
   return body
 }
 
+function failedClaimCompletionBody(claim, comment) {
+  return {
+    task_id: String(claim?.task_id || ''),
+    runtime_id: String(claim?.runtime_id || ''),
+    machine_key: String(claim?.machine_key || ''),
+    comment,
+    memory_delta: '',
+    status: 'failed',
+  }
+}
+
+function codexTranscriptFromJsonl(text) {
+  const lines = []
+  for (const line of String(text || '').split('\n')) {
+    const trimmed = line.trim()
+    if (!trimmed) continue
+    try {
+      const event = JSON.parse(trimmed)
+      if (event?.type === 'item.completed') {
+        const item = event.item || {}
+        if (item.type === 'agent_message' && item.text) {
+          lines.push(`assistant: ${String(item.text).trim()}`)
+        } else if (item.type && item.text) {
+          lines.push(`${item.type}: ${String(item.text).trim()}`)
+        }
+      } else if (event?.type === 'turn.completed' && event.usage) {
+        lines.push(`usage: ${JSON.stringify(event.usage)}`)
+      }
+    } catch {
+      lines.push(trimmed)
+    }
+  }
+  return lines.join('\n')
+}
+
+function codexAssistantTextFromJsonl(text) {
+  const messages = []
+  for (const line of String(text || '').split('\n')) {
+    const trimmed = line.trim()
+    if (!trimmed) continue
+    try {
+      const event = JSON.parse(trimmed)
+      const item = event?.type === 'item.completed' ? event.item || {} : {}
+      if (item.type === 'agent_message' && item.text) messages.push(String(item.text).trim())
+    } catch {}
+  }
+  return messages.join('\n\n')
+}
+
+async function failPersistedCurrentClaim(flags, deps, comment) {
+  const claim = await readCurrentClaim(deps)
+  if (!claim?.task_id || !claim?.runtime_id) return false
+  await deps.requestJson('/api/runtime/tasks/complete', {
+    method: 'POST',
+    body: failedClaimCompletionBody(claim, comment),
+    config: configFromFlags(flags),
+  })
+  await clearCurrentClaim(deps)
+  return true
+}
+
+function installCurrentClaimExitHandlers(flags, deps) {
+  let shuttingDown = false
+  const failAndExit = async (signal, exitCode) => {
+    if (shuttingDown) return
+    shuttingDown = true
+    try {
+      await failPersistedCurrentClaim(
+        flags,
+        deps,
+        `Runtime task failed locally: daemon received ${signal} before the claimed task completed.`
+      )
+    } catch (error) {
+      deps.log(JSON.stringify({
+        warning: 'failed to mark current claimed task failed during daemon shutdown',
+        signal,
+        error: errorMessage(error),
+      }, null, 2))
+    } finally {
+      process.exit(exitCode)
+    }
+  }
+  const onSigterm = () => { void failAndExit('SIGTERM', 143) }
+  const onSigint = () => { void failAndExit('SIGINT', 130) }
+  process.once('SIGTERM', onSigterm)
+  process.once('SIGINT', onSigint)
+  return () => {
+    process.off('SIGTERM', onSigterm)
+    process.off('SIGINT', onSigint)
+  }
+}
+
 function extractJsonObject(text) {
   const source = String(text || '').trim()
   if (!source) return null
@@ -774,12 +890,17 @@ async function prepareRuntimeTask(task, flags, deps, config) {
 
   const database = await syncDatabaseIfNeeded({ task, workdir, config, flags, deps })
   const skills = await materializeSkillsIfChanged({ task, workdir, flags, deps })
+
+  // Resolve and inject the project token so MCP subprocesses (e.g. `11agents mcp start`)
+  // spawned by the runtime agent can authenticate without needing credentials on disk.
+  const projectToken = await projectSyncToken(projectTokenCandidatesForTask(task, flags), flags, deps)
   const env = {
     ...process.env,
     ...agentEnvironment(task),
     ELEVENAGENTS_PROJECT_DIR: workdir,
     ELEVENAGENTS_TASK_TMP: tmpDir,
     ELEVENAGENTS_TASK_ID: String(task.id || ''),
+    ...(projectToken ? { GTM_SWARM_TOKEN: projectToken } : {}),
   }
 
   return {
@@ -863,34 +984,24 @@ async function runCodex({ task, prompt, flags = {}, deps }) {
   const codexBin = flag(flags, 'codex-bin', 'codex')
   const workdir = flag(flags, 'codex-workdir', task.execution_context?.workdir || process.cwd())
   const sandbox = flag(flags, 'codex-sandbox')
-  const args = sandbox
-    ? [
-        '--ask-for-approval',
-        'never',
-        'exec',
-        '--skip-git-repo-check',
-        '--sandbox',
-        sandbox,
-        '-C',
-        workdir,
-        '-',
-      ]
-    : [
-        '--yolo',
-        'exec',
-        '--skip-git-repo-check',
-        '-C',
-        workdir,
-        '-',
-      ]
+  const runDir = task.execution_context?.run_dir
+  const lastMessagePath = runDir ? path.join(runDir, 'last_message.md') : ''
+  const jsonLogArgs = lastMessagePath ? ['--json', '--output-last-message', lastMessagePath] : ['--json']
   const model = flag(flags, 'codex-model')
   const profile = flag(flags, 'codex-profile')
-  const execIndex = args.indexOf('exec')
-  if (model) args.splice(execIndex + 1, 0, '--model', model)
-  if (profile) args.splice(execIndex + 1, 0, '--profile', profile)
 
+  function buildCodexArgs(withSandbox) {
+    const built = withSandbox
+      ? ['--ask-for-approval', 'never', 'exec', ...jsonLogArgs, '--skip-git-repo-check', '--sandbox', withSandbox, '-C', workdir, '-']
+      : ['--yolo', 'exec', ...jsonLogArgs, '--skip-git-repo-check', '-C', workdir, '-']
+    const execIdx = built.indexOf('exec')
+    if (model) built.splice(execIdx + 1, 0, '--model', model)
+    if (profile) built.splice(execIdx + 1, 0, '--profile', profile)
+    return built
+  }
+
+  const args = buildCodexArgs(sandbox)
   const commandLine = [codexBin, ...args].map(value => JSON.stringify(String(value))).join(' ')
-  const runDir = task.execution_context?.run_dir
   await writeRunFile(runDir, 'prompt.md', `/goal ${prompt}`)
   await updateRunMeta(runDir, {
     provider: 'codex',
@@ -900,10 +1011,29 @@ async function runCodex({ task, prompt, flags = {}, deps }) {
     workdir,
   })
   deps.log(JSON.stringify({ running: 'codex exec', command: commandLine, workdir }, null, 2))
-  const result = await deps.runProcess(codexBin, args, { input: `/goal ${prompt}`, cwd: workdir, env: task.execution_context?.env || process.env })
-  const output = String(result.stdout || '').trim()
+  const taskEnv = task.execution_context?.env || process.env
+  let result = await deps.runProcess(codexBin, args, { input: `/goal ${prompt}`, cwd: workdir, env: taskEnv })
+
+  // When --codex-sandbox is set but bwrap is unavailable in the container (missing CAP_NET_ADMIN),
+  // fall back to --yolo exec which runs commands directly without bwrap.
+  if (result.code !== 0 && sandbox) {
+    const errOutput = String(result.stderr || '') + String(result.stdout || '')
+    if (errOutput.includes('bwrap:') && (errOutput.includes('Operation not permitted') || errOutput.includes('RTM_NEWADDR'))) {
+      const fallbackArgs = buildCodexArgs(null)
+      const fallbackLine = [codexBin, ...fallbackArgs].map(v => JSON.stringify(String(v))).join(' ')
+      deps.log(JSON.stringify({ warning: 'bwrap unavailable in this environment, retrying without sandbox', fallback_command: fallbackLine }))
+      await updateRunMeta(runDir, { bwrap_fallback: true, fallback_command_line: fallbackLine })
+      result = await deps.runProcess(codexBin, fallbackArgs, { input: `/goal ${prompt}`, cwd: workdir, env: taskEnv })
+    }
+  }
+  const rawStdout = String(result.stdout || '')
+  const transcript = codexTranscriptFromJsonl(rawStdout)
+  const assistantText = codexAssistantTextFromJsonl(rawStdout)
+  const lastMessage = lastMessagePath ? String(await readFile(lastMessagePath, 'utf8').catch(() => '')).trim() : ''
+  const output = (lastMessage || assistantText || rawStdout || transcript).trim()
   const error = String(result.stderr || '').trim()
-  await writeRunFile(runDir, 'stdout.log', String(result.stdout || ''))
+  await writeRunFile(runDir, 'stdout.log', rawStdout)
+  await writeRunFile(runDir, 'transcript.log', transcript)
   await writeRunFile(runDir, 'stderr.log', String(result.stderr || ''))
   await updateRunMeta(runDir, { exit_code: result.code })
   if (result.code !== 0) {
@@ -953,10 +1083,96 @@ async function runCodex({ task, prompt, flags = {}, deps }) {
   }
 }
 
+async function runClaude({ task, prompt, flags = {}, deps }) {
+  const claudeBin = flag(flags, 'claude-bin', 'claude')
+  const workdir = flag(flags, 'claude-workdir') || flag(flags, 'codex-workdir') || task.execution_context?.workdir || process.cwd()
+  const model = flag(flags, 'claude-model')
+  const runDir = task.execution_context?.run_dir
+
+  // --dangerously-skip-permissions bypasses bwrap sandboxing and auto-approves MCP tool calls,
+  // which are both required for headless remote runtimes running inside containers.
+  const args = ['--dangerously-skip-permissions', '--print']
+  if (model) args.push('--model', model)
+
+  const commandLine = [claudeBin, ...args].map(a => JSON.stringify(String(a))).join(' ')
+  await writeRunFile(runDir, 'prompt.md', prompt)
+  await updateRunMeta(runDir, {
+    provider: 'claude',
+    command: claudeBin,
+    args,
+    command_line: commandLine,
+    workdir,
+  })
+
+  deps.log(JSON.stringify({ running: 'claude --print', command: commandLine, workdir }, null, 2))
+
+  const result = await deps.runProcess(claudeBin, args, {
+    input: prompt,
+    cwd: workdir,
+    env: task.execution_context?.env || process.env,
+  })
+
+  const rawStdout = String(result.stdout || '')
+  const output = rawStdout.trim()
+  const error = String(result.stderr || '').trim()
+
+  await writeRunFile(runDir, 'stdout.log', rawStdout)
+  await writeRunFile(runDir, 'stderr.log', String(result.stderr || ''))
+  await updateRunMeta(runDir, { exit_code: result.code })
+
+  if (result.code !== 0) {
+    return {
+      comment: `${error || output || `claude exited with status ${result.code}`}\n\nClaude command: ${commandLine}`,
+      status: 'failed',
+    }
+  }
+
+  if (knowledgeDeepOrganizeSpec(task)) {
+    const structured = extractJsonObject(output)
+    if (structured?.knowledge_snapshot || structured?.knowledgeSnapshot) {
+      return {
+        ...structured,
+        comment: String(structured.comment || structured.summary || output || `Claude completed task ${task.id}.`),
+        memory_delta: String(structured.memory_delta || structured.memoryDelta || `Claude completed task ${task.id}.`),
+        status: structured.status ? String(structured.status) : 'in_review',
+      }
+    }
+    const recoveredSnapshot = buildRecoveredDeepKnowledgeSnapshot(task, [
+      structured?.comment || structured?.summary || '',
+      structured?.memory_delta || structured?.memoryDelta || '',
+      output,
+    ].filter(Boolean).join('\n\n'))
+    if (recoveredSnapshot) {
+      return {
+        comment: [
+          String(structured?.comment || structured?.summary || output || `Claude completed task ${task.id}.`).trim(),
+          'Recovered a knowledge_snapshot from the worker output because local tooling or MCP push was unavailable.',
+        ].filter(Boolean).join('\n\n'),
+        memory_delta: [
+          String(structured?.memory_delta || structured?.memoryDelta || '').trim(),
+          'Recovered deep knowledge organization snapshot from worker output.',
+        ].filter(Boolean).join('\n'),
+        status: 'in_review',
+        knowledge_snapshot: recoveredSnapshot,
+      }
+    }
+  }
+
+  return {
+    comment: output || `Claude completed task ${task.id}.`,
+    memory_delta: `Claude completed task ${task.id}.`,
+    status: 'in_review',
+  }
+}
+
 function defaultTaskHandler(flags, deps) {
   return {
     async handleRuntimeTask(task) {
       const provider = task.runtime?.provider || ''
+      if (provider === 'claude') {
+        const prompt = buildCodexPrompt(task)
+        return deps.runClaude({ task, prompt, flags, deps })
+      }
       if (provider !== 'codex') {
         return {
           comment: `unsupported runtime provider: ${provider || 'unknown'}`,
@@ -1003,6 +1219,7 @@ async function claimAndRunRuntimeTasks(registration, flags, deps, handlerModule,
     }
 
     deps.log(JSON.stringify({ claimed: runtimeTask.id, runtime_id: runtime.id }, null, 2))
+    await writeCurrentClaim(deps, runtimeTask, machineKey)
     let completion = null
     let executionContext = null
     if (runtimeTask.workspace?.slug) {
@@ -1112,6 +1329,7 @@ async function claimAndRunRuntimeTasks(registration, flags, deps, handlerModule,
         config,
       })
     ), deps, retryState)
+    await clearCurrentClaim(deps)
     deps.log(JSON.stringify(result, null, 2))
     handled += 1
   }
@@ -1143,33 +1361,57 @@ export async function startRuntimeDaemon(flags = {}, deps = {}) {
 
   const handlerModule = await loadTaskHandler(handlerPath, resolvedDeps) || defaultTaskHandler(flags, resolvedDeps)
   const retryState = createRetryState()
-  let registration = await runWithDaemonRetry('register runtime', () => registerRuntime(flags, resolvedDeps), resolvedDeps, retryState)
-  await syncRuntimeProjectMetadataBestEffort(flags, resolvedDeps)
-  await claimAndRunRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs)
-  if (once) return
-
-  let lastScan = Date.now()
-  let lastHeartbeat = Date.now()
-  let lastTaskPoll = Date.now()
-  let lastProjectRefresh = Date.now()
-  while (true) {
-    await resolvedDeps.sleep(Math.min(heartbeatIntervalMs, taskIntervalMs, projectRefreshIntervalMs))
-    const now = Date.now()
-    if (now - lastScan >= scanIntervalMs) {
-      registration = await runWithDaemonRetry('register runtime', () => registerRuntime(flags, resolvedDeps), resolvedDeps, retryState)
-      lastScan = now
-      lastHeartbeat = now
-    } else if (now - lastHeartbeat >= heartbeatIntervalMs) {
-      await runWithDaemonRetry('heartbeat runtime', () => heartbeatRuntime(flags, resolvedDeps), resolvedDeps, retryState)
-      lastHeartbeat = now
-    }
-    if (now - lastTaskPoll >= taskIntervalMs) {
-      await claimAndRunRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs)
-      lastTaskPoll = now
+  const uninstallExitHandlers = installCurrentClaimExitHandlers(flags, resolvedDeps)
+  try {
+    let registration = await runWithDaemonRetry('register runtime', () => registerRuntime(flags, resolvedDeps), resolvedDeps, retryState)
+    await runWithDaemonRetry('recover current claimed task', () => failPersistedCurrentClaim(
+      flags,
+      resolvedDeps,
+      'Runtime task failed locally: daemon restarted with a persisted claimed task that had not completed.'
+    ), resolvedDeps, retryState)
+    await syncRuntimeProjectMetadataBestEffort(flags, resolvedDeps)
+    await claimAndRunRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs)
+    if (once) return
+
+    let lastScan = Date.now()
+    let lastHeartbeat = Date.now()
+    let lastTaskPoll = Date.now()
+    let lastProjectRefresh = Date.now()
+    while (true) {
+      await resolvedDeps.sleep(Math.min(heartbeatIntervalMs, taskIntervalMs, projectRefreshIntervalMs))
+      const now = Date.now()
+      if (now - lastScan >= scanIntervalMs) {
+        registration = await runWithDaemonRetry('register runtime', () => registerRuntime(flags, resolvedDeps), resolvedDeps, retryState)
+        lastScan = now
+        lastHeartbeat = now
+      } else if (now - lastHeartbeat >= heartbeatIntervalMs) {
+        await runWithDaemonRetry('heartbeat runtime', () => heartbeatRuntime(flags, resolvedDeps), resolvedDeps, retryState)
+        lastHeartbeat = now
+      }
+      if (now - lastTaskPoll >= taskIntervalMs) {
+        await claimAndRunRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs)
+        lastTaskPoll = now
+      }
+      if (now - lastProjectRefresh >= projectRefreshIntervalMs) {
+        await syncRuntimeProjectMetadataBestEffort(flags, resolvedDeps)
+        lastProjectRefresh = now
+      }
     }
-    if (now - lastProjectRefresh >= projectRefreshIntervalMs) {
-      await syncRuntimeProjectMetadataBestEffort(flags, resolvedDeps)
-      lastProjectRefresh = now
+  } catch (error) {
+    try {
+      await failPersistedCurrentClaim(
+        flags,
+        resolvedDeps,
+        `Runtime task failed locally: daemon exited with error before the claimed task completed: ${errorMessage(error)}`
+      )
+    } catch (cleanupError) {
+      resolvedDeps.log(JSON.stringify({
+        warning: 'failed to mark current claimed task failed during daemon error exit',
+        error: errorMessage(cleanupError),
+      }, null, 2))
     }
+    throw error
+  } finally {
+    if (once) uninstallExitHandlers()
   }
 }

package/src/mcp.js

@@ -17,6 +17,22 @@ const TOOLS = [
       },
     },
   },
+  {
+    name: 'database_sync',
+    description: 'Pull or push the cloud project database snapshot with a project token.',
+    inputSchema: {
+      type: 'object',
+      required: ['project', 'mode'],
+      properties: {
+        project: { type: 'string' },
+        mode: { type: 'string', enum: ['pull', 'push'] },
+        token: { type: 'string' },
+        server: { type: 'string' },
+        snapshot: { type: 'object' },
+        metadata: { type: 'object' },
+      },
+    },
+  },
 ]
 
 function textResult(value) {
@@ -64,6 +80,22 @@ export async function handleMcpRequest(request, deps = {}) {
     })
     return textResult(result)
   }
+  if (name === 'database_sync') {
+    const token = await resolveProjectToken(args.project, {
+      homeDir: deps.homeDir,
+      token: args.token,
+    })
+    const server = args.server || 'https://app.11agents.ai'
+    const result = await (deps.requestJson || requestJson)(
+      `/api/projects/${encodeURIComponent(args.project)}/database/sync`,
+      {
+        method: 'POST',
+        body: { mode: args.mode || 'pull', snapshot: args.snapshot, metadata: args.metadata },
+        config: { token, server },
+      }
+    )
+    return textResult(result)
+  }
   throw new Error(`unknown MCP tool: ${name}`)
 }