@11agents/cli 0.1.23 → 0.1.25

package/src/commands/runtime.js

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process'
 import { createHash } from 'node:crypto'
-import { appendFileSync, readFileSync } from 'node:fs'
+import { createWriteStream, readFileSync } from 'node:fs'
 import { appendFile, mkdir, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises'
 import os from 'node:os'
 import { dirname, resolve } from 'node:path'
@@ -180,6 +180,15 @@ async function runWithRuntimeHeartbeat(operation, registration, flags, deps, hea
   }
 }
 
+function createChunkLogger(filePath) {
+  if (!filePath) return null
+  const stream = createWriteStream(filePath, { flags: 'a' })
+  return {
+    write: chunk => { stream.write(chunk) },
+    close: () => new Promise(resolve => stream.end(resolve)),
+  }
+}
+
 async function runWithDaemonRetry(label, operation, deps, retryState) {
   while (true) {
     try {
@@ -722,9 +731,10 @@ function projectDirForTask(task, flags = {}, deps) {
   return buildRuntimeProjectDir(projectSlugForTask(task, flags), { homeDir: deps.homeDir })
 }
 
-async function projectSyncToken(project, flags = {}, deps = {}) {
+async function projectSyncToken(project, flags = {}, deps = {}, workspaceToken = '') {
   return resolveProjectToken(project, {
     homeDir: deps.homeDir,
+    token: workspaceToken || '',
     fallbackToken: flags.token,
   })
 }
@@ -935,7 +945,7 @@ async function syncDatabaseIfNeeded({ task, workdir, config, flags, deps }) {
   if (!spec.syncRequired && localRevision === spec.cloudRevision) return { synced: false, cloud_revision: localRevision }
 
   const project = projectSlugForTask(task)
-  const token = await projectSyncToken(projectTokenCandidatesForTask(task, flags), flags, deps)
+  const token = await projectSyncToken(projectTokenCandidatesForTask(task, flags), flags, deps, task.workspace?.swarm_token)
   const syncConfig = { ...config, token }
   const result = await deps.requestJson(`/api/projects/${project}/database/sync`, {
     method: 'POST',
@@ -994,7 +1004,7 @@ async function prepareRuntimeTask(task, flags, deps, config) {
 
   // Resolve and inject the project token so hosted MCP calls spawned by the
   // runtime agent can authenticate without needing credentials on disk.
-  const projectToken = await projectSyncToken(projectTokenCandidatesForTask(task, flags), flags, deps)
+  const projectToken = await projectSyncToken(projectTokenCandidatesForTask(task, flags), flags, deps, task.workspace?.swarm_token)
   const env = {
     ...process.env,
     ...agentEnvironment(task),
@@ -1134,8 +1144,13 @@ async function runCodex({ task, prompt, flags = {}, deps }) {
   const taskEnv = task.execution_context?.env || process.env
   const stdoutLogPath = runDir ? path.join(runDir, 'stdout.log') : ''
   if (stdoutLogPath) await writeRunFile(runDir, 'stdout.log', '')
-  const onStdoutChunk = stdoutLogPath ? (chunk) => { try { appendFileSync(stdoutLogPath, chunk) } catch {} } : undefined
-  let result = await deps.runProcess(codexBin, args, { input: `/goal ${prompt}`, cwd: workdir, env: taskEnv, onStdoutChunk })
+  let stdoutLogger = createChunkLogger(stdoutLogPath)
+  let result
+  try {
+    result = await deps.runProcess(codexBin, args, { input: `/goal ${prompt}`, cwd: workdir, env: taskEnv, onStdoutChunk: stdoutLogger?.write })
+  } finally {
+    await stdoutLogger?.close()
+  }
 
   // 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.
@@ -1147,7 +1162,12 @@ async function runCodex({ task, prompt, flags = {}, deps }) {
       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 })
       if (stdoutLogPath) await writeRunFile(runDir, 'stdout.log', '')
-      result = await deps.runProcess(codexBin, fallbackArgs, { input: `/goal ${prompt}`, cwd: workdir, env: taskEnv, onStdoutChunk })
+      stdoutLogger = createChunkLogger(stdoutLogPath)
+      try {
+        result = await deps.runProcess(codexBin, fallbackArgs, { input: `/goal ${prompt}`, cwd: workdir, env: taskEnv, onStdoutChunk: stdoutLogger?.write })
+      } finally {
+        await stdoutLogger?.close()
+      }
     }
   }
   const rawStdout = String(result.stdout || '')
@@ -1232,13 +1252,18 @@ async function runClaude({ task, prompt, flags = {}, deps }) {
 
   const stdoutLogPath = runDir ? path.join(runDir, 'stdout.log') : ''
   if (stdoutLogPath) await writeRunFile(runDir, 'stdout.log', '')
-  const onStdoutChunk = stdoutLogPath ? (chunk) => { try { appendFileSync(stdoutLogPath, chunk) } catch {} } : undefined
-  const result = await deps.runProcess(claudeBin, args, {
-    input: prompt,
-    cwd: workdir,
-    env: task.execution_context?.env || process.env,
-    onStdoutChunk,
-  })
+  const stdoutLogger = createChunkLogger(stdoutLogPath)
+  let result
+  try {
+    result = await deps.runProcess(claudeBin, args, {
+      input: prompt,
+      cwd: workdir,
+      env: task.execution_context?.env || process.env,
+      onStdoutChunk: stdoutLogger?.write,
+    })
+  } finally {
+    await stdoutLogger?.close()
+  }
 
   const rawStdout = String(result.stdout || '')
   const output = rawStdout.trim()
@@ -1339,24 +1364,32 @@ async function runOneRuntimeTaskSlot(runtime, config, machineKey, registration,
     },
   }
 
-  deps.log(JSON.stringify({ claimed: runtimeTask.id, runtime_id: runtime.id }, null, 2))
+  deps.log(JSON.stringify({
+    claimed: runtimeTask.id,
+    task_id: runtimeTask.id,
+    task_title: String(runtimeTask.issue?.title || runtimeTask.title || ''),
+    project_slug: String(runtimeTask.workspace?.slug || runtimeTask.workspace_slug || ''),
+    runtime_id: runtime.id,
+  }, null, 2))
   await writeCurrentClaim(deps, runtimeTask, machineKey)
   let completion = null
   let executionContext = null
   if (runtimeTask.workspace?.slug) {
-    const token = await projectSyncToken(projectTokenCandidatesForTask(runtimeTask, flags), flags, deps)
+    const token = await projectSyncToken(projectTokenCandidatesForTask(runtimeTask, flags), flags, deps, runtimeTask.workspace?.swarm_token)
     const syncConfig = { ...config, token }
     try {
       await runWithTaskRetry('sync knowledge base', () => (
-        deps.syncKnowledge({
-          project: runtimeTask.workspace.slug,
-          mode: 'pull',
-          server: flags.server,
-          token,
-        }, {
-          requestJson: (apiPath, options = {}) => deps.requestJson(apiPath, { ...options, config: syncConfig }),
-          log: () => {},
-        })
+        runWithRuntimeHeartbeat(() => (
+          deps.syncKnowledge({
+            project: runtimeTask.workspace.slug,
+            mode: 'pull',
+            server: flags.server,
+            token,
+          }, {
+            requestJson: (apiPath, options = {}) => deps.requestJson(apiPath, { ...options, config: syncConfig }),
+            log: () => {},
+          })
+        ), registration, flags, deps, heartbeatIntervalMs)
       ), deps)
     } catch (error) {
       completion = {
@@ -1405,7 +1438,7 @@ async function runOneRuntimeTaskSlot(runtime, config, machineKey, registration,
   if (executionContext && runtimeTask.workspace?.slug) {
     const isDeepOrganize = Boolean(knowledgeDeepOrganizeSpec(runtimeTask))
     const syncBack = isDeepOrganize ? deps.mcpKnowledgeSync : deps.syncKnowledge
-    const token = await projectSyncToken(projectTokenCandidatesForTask(runtimeTask, flags), flags, deps)
+    const token = await projectSyncToken(projectTokenCandidatesForTask(runtimeTask, flags), flags, deps, runtimeTask.workspace?.swarm_token)
     const syncConfig = { ...config, token }
     const pushKnowledge = () => syncBack({
       project: runtimeTask.workspace.slug,
@@ -1418,7 +1451,7 @@ async function runOneRuntimeTaskSlot(runtime, config, machineKey, registration,
     })
     if (isDeepOrganize) {
       try {
-        await pushKnowledge()
+        await runWithRuntimeHeartbeat(pushKnowledge, registration, flags, deps, heartbeatIntervalMs)
       } catch (error) {
         const message = `Knowledge sync push failed before task completion: ${errorMessage(error)}. If a knowledge_snapshot is included in completion, the platform will write it directly.`
         completion = {
@@ -1429,7 +1462,9 @@ async function runOneRuntimeTaskSlot(runtime, config, machineKey, registration,
       }
     } else {
       try {
-        await runWithTaskRetry('sync knowledge base back to cloud', pushKnowledge, deps)
+        await runWithTaskRetry('sync knowledge base back to cloud', () => (
+          runWithRuntimeHeartbeat(pushKnowledge, registration, flags, deps, heartbeatIntervalMs)
+        ), deps)
       } catch (error) {
         const message = `Knowledge sync push failed before task completion: ${errorMessage(error)}`
         completion = {