@11agents/cli 0.1.12 → 0.1.14

package/README.md

@@ -84,6 +84,13 @@ Run the daemon in the background:
 
 Background mode writes its pid to `~/.11agents/daemon.pid` and logs to `~/.11agents/daemon.log`.
 
+Inspect daemon and task execution logs:
+
+```bash
+11agents logs daemon --tail 200
+11agents logs task <taskId> --project <slug>
+```
+
 Useful daemon options:
 
 ```bash
@@ -99,10 +106,11 @@ On startup, and every 30 minutes after that, the daemon syncs project metadata a
 - Agent-local skills: `~/.11agents/<project>/agents/<agent>/skills/`
 - Cloud database snapshot: `~/.11agents/<project>/database/snapshot.json`
 - Task scratch directory: `~/.11agents/<project>/tmp/<taskId>/`
+- Task execution logs: `~/.11agents/<project>/runs/<taskId>/`
 
 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.
 
-The built-in Codex worker starts task executions with `codex --ask-for-approval never --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` 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/bin/11agents.js

@@ -3,6 +3,7 @@ import { readFile } from 'node:fs/promises'
 import { fileURLToPath } from 'node:url'
 import { parseArgs } from '../src/args.js'
 import { knowledgeStatus, syncKnowledge } from '../src/commands/knowledge.js'
+import { showDaemonLog, showTaskLog } from '../src/commands/logs.js'
 import { runNode } from '../src/commands/node.js'
 import { pushArtifact, pushBatch, pushObservation } from '../src/commands/push.js'
 import { registerRuntime, scanRuntime, startRuntimeDaemon } from '../src/commands/runtime.js'
@@ -24,6 +25,8 @@ Usage:
   11agents daemon status
   11agents daemon stop
   11agents daemon start --handler ./worker.js  # optional custom worker override
+  11agents logs daemon [--tail 200]
+  11agents logs task <task-id> [--project <slug>] [--tail 120]
   11agents mcp start
   11agents validate <file>
   11agents push batch <file>
@@ -116,6 +119,17 @@ async function main() {
     return
   }
 
+  if (command === 'logs' && subcommand === 'daemon') {
+    await showDaemonLog(flags)
+    return
+  }
+
+  if (command === 'logs' && subcommand === 'task') {
+    if (!target) throw new Error('logs task requires a task id')
+    await showTaskLog(target, flags)
+    return
+  }
+
   if (command === 'mcp' && (!subcommand || subcommand === 'start')) {
     await startMcpServer()
     return

package/package.json

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

package/src/commands/logs.js

@@ -0,0 +1,96 @@
+import { readdir, readFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import path from 'node:path'
+import { backgroundPaths } from '../daemon-process.js'
+import { flag } from '../args.js'
+
+function tailText(text, lines) {
+  const count = Math.max(1, Number(lines) || 200)
+  const parts = String(text || '').replace(/\n$/, '').split('\n')
+  return parts.slice(-count).join('\n')
+}
+
+async function readText(filePath, fallback = '') {
+  try {
+    return await readFile(filePath, 'utf8')
+  } catch (error) {
+    if (error?.code === 'ENOENT') return fallback
+    throw error
+  }
+}
+
+async function readJson(filePath, fallback = {}) {
+  try {
+    return JSON.parse(await readFile(filePath, 'utf8'))
+  } catch (error) {
+    if (error?.code === 'ENOENT') return fallback
+    return fallback
+  }
+}
+
+export async function readDaemonLog({ homeDir = homedir(), tail = 200 } = {}) {
+  const text = await readText(backgroundPaths(homeDir).logPath, '')
+  return tailText(text, tail)
+}
+
+async function findTaskRunDir({ taskId, project = '', homeDir = homedir() }) {
+  if (!taskId) throw new Error('task id is required')
+  const baseDir = path.join(homeDir, '.11agents')
+  if (project) return path.join(baseDir, project, 'runs', taskId)
+
+  const entries = await readdir(baseDir, { withFileTypes: true }).catch(error => {
+    if (error?.code === 'ENOENT') return []
+    throw error
+  })
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    const runDir = path.join(baseDir, entry.name, 'runs', taskId)
+    const meta = await readJson(path.join(runDir, 'meta.json'), null)
+    if (meta) return runDir
+  }
+  return path.join(baseDir, 'project', 'runs', taskId)
+}
+
+export async function formatTaskLog({ taskId, project = '', homeDir = homedir(), tail = 120 } = {}) {
+  const runDir = await findTaskRunDir({ taskId, project, homeDir })
+  const meta = await readJson(path.join(runDir, 'meta.json'), null)
+  if (!meta) throw new Error(`task log not found: ${taskId}`)
+
+  const stdout = tailText(await readText(path.join(runDir, 'stdout.log'), ''), tail)
+  const stderr = tailText(await readText(path.join(runDir, 'stderr.log'), ''), tail)
+  const completion = await readText(path.join(runDir, 'completion.json'), '')
+  return [
+    `task: ${meta.task_id || taskId}`,
+    `provider: ${meta.provider || ''}`,
+    `workdir: ${meta.workdir || ''}`,
+    `command: ${meta.command_line || ''}`,
+    `exit_code: ${meta.exit_code ?? ''}`,
+    `run_dir: ${runDir}`,
+    '',
+    'stdout:',
+    stdout,
+    '',
+    'stderr:',
+    stderr,
+    '',
+    'completion:',
+    completion.trim(),
+  ].join('\n').trimEnd()
+}
+
+export async function showDaemonLog(flags = {}, deps = {}) {
+  const log = await readDaemonLog({ homeDir: deps.homeDir, tail: flag(flags, 'tail', '200') })
+  ;(deps.log || console.log)(log)
+  return log
+}
+
+export async function showTaskLog(taskId, flags = {}, deps = {}) {
+  const text = await formatTaskLog({
+    taskId,
+    project: flag(flags, 'project'),
+    homeDir: deps.homeDir,
+    tail: flag(flags, 'tail', '120'),
+  })
+  ;(deps.log || console.log)(text)
+  return text
+}

package/src/commands/runtime.js

@@ -96,6 +96,41 @@ function createRetryState() {
   return { failures: 0 }
 }
 
+async function heartbeatRegisteredRuntime(registration, flags, deps) {
+  const config = configFromFlags(flags)
+  const machineKey = registration?.machine?.machine_key || machineOverride(flags) || ''
+  if (!machineKey) return null
+  return deps.requestJson('/api/runtime/machines/heartbeat', {
+    method: 'POST',
+    body: {
+      machine_key: machineKey,
+      runtime_providers: (registration?.runtimes || []).map(runtime => runtime.provider).filter(Boolean),
+      health: {
+        heartbeat_at: new Date().toISOString(),
+      },
+    },
+    config,
+  })
+}
+
+async function runWithRuntimeHeartbeat(operation, registration, flags, deps, heartbeatIntervalMs) {
+  const intervalMs = Math.max(10, Math.min(Number(heartbeatIntervalMs) || 15000, 60000))
+  const timer = setInterval(() => {
+    heartbeatRegisteredRuntime(registration, flags, deps).catch(error => {
+      deps.log(JSON.stringify({
+        warning: 'runtime heartbeat during task failed',
+        error: errorMessage(error),
+      }, null, 2))
+    })
+  }, intervalMs)
+  timer.unref?.()
+  try {
+    return await operation()
+  } finally {
+    clearInterval(timer)
+  }
+}
+
 async function runWithDaemonRetry(label, operation, deps, retryState) {
   while (true) {
     try {
@@ -658,6 +693,19 @@ async function appendTaskMemoryDelta({ task, completion, workdir }) {
   return { written: true, path: indexPath }
 }
 
+async function writeRunFile(runDir, fileName, content) {
+  if (!runDir) return
+  await mkdir(runDir, { recursive: true })
+  await writeFile(path.join(runDir, fileName), content)
+}
+
+async function updateRunMeta(runDir, patch) {
+  if (!runDir) return
+  const metaPath = path.join(runDir, 'meta.json')
+  const current = await readJsonFile(metaPath, {})
+  await writeRunFile(runDir, 'meta.json', JSON.stringify({ ...current, ...patch }, null, 2))
+}
+
 function databaseSyncSpec(task) {
   const spec = task.database || task.cloud_database || task.workspace?.database || null
   if (!spec || typeof spec !== 'object') return null
@@ -720,7 +768,9 @@ function agentEnvironment(task) {
 async function prepareRuntimeTask(task, flags, deps, config) {
   const workdir = flag(flags, 'codex-workdir') || projectDirForTask(task, flags, deps)
   const tmpDir = path.join(workdir, 'tmp', sanitizeTaskId(task.id))
+  const runDir = path.join(workdir, 'runs', sanitizeTaskId(task.id))
   await mkdir(tmpDir, { recursive: true })
+  await mkdir(runDir, { recursive: true })
 
   const database = await syncDatabaseIfNeeded({ task, workdir, config, flags, deps })
   const skills = await materializeSkillsIfChanged({ task, workdir, flags, deps })
@@ -735,6 +785,7 @@ async function prepareRuntimeTask(task, flags, deps, config) {
   return {
     workdir,
     tmp_dir: tmpDir,
+    run_dir: runDir,
     project_slug: projectSlugForTask(task, flags),
     readonly: true,
     env,
@@ -839,10 +890,22 @@ async function runCodex({ task, prompt, flags = {}, deps }) {
   if (profile) args.splice(execIndex + 1, 0, '--profile', profile)
 
   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',
+    command: codexBin,
+    args,
+    command_line: commandLine,
+    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 error = String(result.stderr || '').trim()
+  await writeRunFile(runDir, 'stdout.log', String(result.stdout || ''))
+  await writeRunFile(runDir, 'stderr.log', String(result.stderr || ''))
+  await updateRunMeta(runDir, { exit_code: result.code })
   if (result.code !== 0) {
     const body = error || output || `codex exited with status ${result.code}`
     const trustHint = body.includes('--skip-git-repo-check')
@@ -906,7 +969,7 @@ function defaultTaskHandler(flags, deps) {
   }
 }
 
-async function claimAndRunRuntimeTasks(registration, flags, deps, handlerModule, retryState = createRetryState()) {
+async function claimAndRunRuntimeTasks(registration, flags, deps, handlerModule, retryState = createRetryState(), heartbeatIntervalMs = 15000) {
   if (!handlerModule) return 0
   const config = configFromFlags(flags)
   const machineKey = registration?.machine?.machine_key || machineOverride(flags) || ''
@@ -967,8 +1030,23 @@ async function claimAndRunRuntimeTasks(registration, flags, deps, handlerModule,
     if (!completion) {
       executionContext = await prepareRuntimeTask(runtimeTask, flags, deps, config)
       runtimeTask.execution_context = executionContext
+      await updateRunMeta(executionContext.run_dir, {
+        task_id: String(runtimeTask.id || ''),
+        runtime_id: String(runtimeTask.runtime_id || ''),
+        provider: runtimeTask.runtime?.provider || runtime.provider || '',
+        project_slug: executionContext.project_slug,
+        agent: agentNameForTask(runtimeTask),
+        issue_title: runtimeTask.issue?.title || '',
+        started_at: new Date().toISOString(),
+      })
       try {
-        completion = await handlerModule.handleRuntimeTask(runtimeTask)
+        completion = await runWithRuntimeHeartbeat(
+          () => handlerModule.handleRuntimeTask(runtimeTask),
+          registration,
+          flags,
+          deps,
+          heartbeatIntervalMs
+        )
       } catch (error) {
         completion = {
           comment: error instanceof Error ? error.message : String(error),
@@ -978,6 +1056,10 @@ async function claimAndRunRuntimeTasks(registration, flags, deps, handlerModule,
         await rm(executionContext.tmp_dir, { recursive: true, force: true })
       }
     }
+    if (executionContext) {
+      await writeRunFile(executionContext.run_dir, 'completion.json', JSON.stringify(normalizeTaskCompletion(runtimeTask, completion), null, 2))
+      await updateRunMeta(executionContext.run_dir, { ended_at: new Date().toISOString() })
+    }
     if (executionContext) {
       await appendTaskMemoryDelta({ task: runtimeTask, completion, workdir: executionContext.workdir })
     }
@@ -1063,7 +1145,7 @@ export async function startRuntimeDaemon(flags = {}, deps = {}) {
   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)
+  await claimAndRunRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs)
   if (once) return
 
   let lastScan = Date.now()
@@ -1082,7 +1164,7 @@ export async function startRuntimeDaemon(flags = {}, deps = {}) {
       lastHeartbeat = now
     }
     if (now - lastTaskPoll >= taskIntervalMs) {
-      await claimAndRunRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState)
+      await claimAndRunRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs)
       lastTaskPoll = now
     }
     if (now - lastProjectRefresh >= projectRefreshIntervalMs) {