@11agents/cli 0.1.15 → 0.1.16

package/package.json

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

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,
@@ -889,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 {
@@ -981,34 +987,20 @@ async function runCodex({ task, prompt, flags = {}, deps }) {
   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 args = sandbox
-    ? [
-        '--ask-for-approval',
-        'never',
-        'exec',
-        ...jsonLogArgs,
-        '--skip-git-repo-check',
-        '--sandbox',
-        sandbox,
-        '-C',
-        workdir,
-        '-',
-      ]
-    : [
-        '--yolo',
-        'exec',
-        ...jsonLogArgs,
-        '--skip-git-repo-check',
-        '-C',
-        workdir,
-        '-',
-      ]
   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(' ')
   await writeRunFile(runDir, 'prompt.md', `/goal ${prompt}`)
   await updateRunMeta(runDir, {
@@ -1019,7 +1011,21 @@ 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 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)
@@ -1077,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'}`,

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}`)
 }