@11agents/cli 0.1.22 → 0.1.24

package/package.json

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

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 {
@@ -1134,8 +1143,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 +1161,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 +1251,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,7 +1363,13 @@ 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
@@ -1348,15 +1378,17 @@ async function runOneRuntimeTaskSlot(runtime, config, machineKey, registration,
     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 = {
@@ -1418,7 +1450,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 +1461,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 = {
@@ -1473,6 +1507,15 @@ async function claimAndRunRuntimeTasks(registration, flags, deps, handlerModule,
   return results.filter(r => r.status === 'fulfilled' && r.value === true).length
 }
 
+async function drainRuntimeTasks(registration, flags, deps, handlerModule, retryState = createRetryState(), heartbeatIntervalMs = 15000, maxConcurrent = 1) {
+  let completed = 0
+  while (true) {
+    const claimed = await claimAndRunRuntimeTasks(registration, flags, deps, handlerModule, retryState, heartbeatIntervalMs, maxConcurrent)
+    completed += claimed
+    if (claimed === 0) return completed
+  }
+}
+
 export async function startRuntimeDaemon(flags = {}, deps = {}) {
   const resolvedDeps = runtimeDeps(deps)
   const heartbeatIntervalMs = Number(flag(flags, 'heartbeat-interval', '15')) * 1000
@@ -1507,8 +1550,11 @@ export async function startRuntimeDaemon(flags = {}, deps = {}) {
       '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, maxConcurrent)
-    if (once) return
+    if (once) {
+      await claimAndRunRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs, maxConcurrent)
+      return
+    }
+    await drainRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs, maxConcurrent)
 
     let lastScan = Date.now()
     let lastHeartbeat = Date.now()
@@ -1526,7 +1572,7 @@ export async function startRuntimeDaemon(flags = {}, deps = {}) {
         lastHeartbeat = now
       }
       if (now - lastTaskPoll >= taskIntervalMs) {
-        await claimAndRunRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs, maxConcurrent)
+        await drainRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs, maxConcurrent)
         lastTaskPoll = now
       }
       if (now - lastProjectRefresh >= projectRefreshIntervalMs) {