@alook/cli 0.0.16 → 0.0.18

package/dist/index.js

@@ -15853,6 +15853,7 @@ var machineToken = sqliteTable("machine_token", {
 }, (t) => [index("idx_machine_token").on(t.token)]);
 // ../shared/src/db/queries/task.ts
 var DEFAULT_STALE_SECONDS = Number(process.env.ALOOK_STALE_DISPATCH_TIMEOUT_S) || 20;
+var DEFAULT_STALE_RUNNING_SECONDS = Number(process.env.ALOOK_STALE_RUNNING_TIMEOUT_S) || 3600;
 // ../shared/src/utils/email.ts
 var DOMAIN = `@${process.env.ALOOK_DOMAIN || "alook.ai"}`;
 var RESERVED_HANDLES = new Set([
@@ -16084,6 +16085,7 @@ function loadDaemonConfig(profile) {
     opencodeModel: process.env.ALOOK_OPENCODE_MODEL || "",
     pollInterval: parseDuration(process.env.ALOOK_DAEMON_POLL_INTERVAL || "3s"),
     agentTimeout: parseDuration(process.env.ALOOK_AGENT_TIMEOUT || "12h"),
+    messageInactivityTimeout: parseDuration(process.env.ALOOK_MESSAGE_INACTIVITY_TIMEOUT || "5m"),
     maxConcurrentTasks: parseInt(process.env.ALOOK_DAEMON_MAX_CONCURRENT_TASKS || "20"),
     daemonId,
     deviceName: process.env.ALOOK_DAEMON_DEVICE_NAME || h,
@@ -16551,6 +16553,7 @@ function releaseSteeringLock(baseDir, contextKey) {
 
 // daemon/daemon.ts
 import { existsSync, mkdirSync as mkdirSync5, openSync, closeSync, readdirSync as readdirSync2, statSync as statSync3, unlinkSync as unlinkSync4 } from "fs";
+import { readdir, readFile, unlink, stat as fsStat } from "fs/promises";
 import { execSync as execSync3, spawn as spawn2 } from "child_process";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname as dirname3, join as join6 } from "path";
@@ -16591,6 +16594,122 @@ function pruneSessionRunnerLogs() {
     } catch {}
   }
 }
+function isClientError(error48) {
+  if (!(error48 instanceof Error))
+    return false;
+  const match = error48.message.match(/^HTTP (\d+):/);
+  if (!match)
+    return false;
+  const status = Number(match[1]);
+  if (status === 408 || status === 429)
+    return false;
+  return status >= 400 && status < 500;
+}
+function isValidMarker(data) {
+  if (!data || typeof data !== "object")
+    return false;
+  const d = data;
+  if (typeof d.taskId !== "string")
+    return false;
+  if (typeof d.token !== "string")
+    return false;
+  if (typeof d.serverURL !== "string")
+    return false;
+  if (typeof d.createdAt !== "string" || isNaN(new Date(d.createdAt).getTime()))
+    return false;
+  if (!d.payload || typeof d.payload !== "object")
+    return false;
+  const payload = d.payload;
+  if (d.type === "complete") {
+    return typeof payload.output === "string";
+  }
+  if (d.type === "fail") {
+    return typeof payload.error === "string";
+  }
+  return false;
+}
+var MARKER_STALE_MS = 24 * 60 * 60 * 1000;
+var TMP_STALE_MS = 60 * 60 * 1000;
+async function reconcilePendingCompletions(workspacesRoot) {
+  const dir = join6(workspacesRoot, ".pending_completions");
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    if (!name.endsWith(".tmp"))
+      continue;
+    try {
+      const s = await fsStat(join6(dir, name));
+      if (Date.now() - s.mtimeMs > TMP_STALE_MS) {
+        await unlink(join6(dir, name));
+      }
+    } catch {}
+  }
+  const jsonFiles = entries.filter((f) => f.endsWith(".json"));
+  for (const name of jsonFiles) {
+    const filePath = join6(dir, name);
+    try {
+      let raw;
+      try {
+        raw = await readFile(filePath, "utf-8");
+      } catch {
+        continue;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        log.warn(`reconcile: malformed marker ${name}, deleting`);
+        try {
+          await unlink(filePath);
+        } catch {}
+        continue;
+      }
+      if (!isValidMarker(parsed)) {
+        log.warn(`reconcile: invalid marker structure ${name}, deleting`);
+        try {
+          await unlink(filePath);
+        } catch {}
+        continue;
+      }
+      const marker = parsed;
+      const age = Date.now() - new Date(marker.createdAt).getTime();
+      if (age > MARKER_STALE_MS) {
+        log.warn(`reconcile: stale marker ${name} (${Math.round(age / 3600000)}h old), deleting`);
+        try {
+          await unlink(filePath);
+        } catch {}
+        continue;
+      }
+      const client = new DaemonClient(marker.serverURL);
+      try {
+        if (marker.type === "complete") {
+          await client.completeTask(marker.token, marker.taskId, marker.payload);
+        } else {
+          await client.failTask(marker.token, marker.taskId, marker.payload.error);
+        }
+        try {
+          await unlink(filePath);
+        } catch (delErr) {
+          log.warn(`reconcile: delivered marker ${name} but failed to delete: ${delErr}`);
+        }
+      } catch (deliverErr) {
+        if (isClientError(deliverErr)) {
+          try {
+            await unlink(filePath);
+          } catch {}
+        } else {
+          log.debug(`reconcile: delivery failed for ${name}, will retry next cycle`);
+        }
+      }
+    } catch (e) {
+      log.debug(`reconcile: error processing ${name}`, e);
+    }
+  }
+}
 async function startDaemon(profile, serverUrl) {
   pruneSessionRunnerLogs();
   if (!acquireDaemonPid(profile)) {
@@ -16771,6 +16890,11 @@ async function startDaemon(profile, serverUrl) {
     for (const id of evictedIds) {
       evictWorkspace(id);
     }
+    try {
+      await reconcilePendingCompletions(config2.workspacesRoot);
+    } catch (e) {
+      log.debug("reconciliation error", e);
+    }
     if (workspaceStates.length === 0) {
       log.info("All workspaces evicted — shutting down");
       shutdown();
@@ -16968,7 +17092,8 @@ async function handleTask(client, config2, runtimeIndex, task, token, activeTask
     serverURL: config2.serverURL,
     token,
     workspacesRoot: config2.workspacesRoot,
-    agentTimeout: config2.agentTimeout
+    agentTimeout: config2.agentTimeout,
+    messageInactivityTimeout: config2.messageInactivityTimeout
   };
   const child = spawnSessionRunner(input);
   child.on("close", () => activeTasks.delete(task.id));

package/dist/session-runner.js

@@ -14,7 +14,7 @@ var __export = (target, all) => {
 };
 
 // daemon/session-runner.ts
-import { mkdir, writeFile, rm } from "fs/promises";
+import { mkdir, writeFile, rm, rename } from "fs/promises";
 import path from "path";
 
 // ../shared/src/constants.ts
@@ -15570,6 +15570,7 @@ var machineToken = sqliteTable("machine_token", {
 }, (t) => [index("idx_machine_token").on(t.token)]);
 // ../shared/src/db/queries/task.ts
 var DEFAULT_STALE_SECONDS = Number(process.env.ALOOK_STALE_DISPATCH_TIMEOUT_S) || 20;
+var DEFAULT_STALE_RUNNING_SECONDS = Number(process.env.ALOOK_STALE_RUNNING_TIMEOUT_S) || 3600;
 // ../shared/src/utils/email.ts
 var DOMAIN = `@${process.env.ALOOK_DOMAIN || "alook.ai"}`;
 var RESERVED_HANDLES = new Set([
@@ -15963,7 +15964,7 @@ class CodexBackend {
     this.cliPath = cliPath;
   }
   execute(prompt, options) {
-    const proc = spawn2(this.cliPath, ["app-server", "--listen", "stdio://"], {
+    const proc = spawn2(this.cliPath, ["app-server", "--listen", "stdio://", "--config", "sandbox_workspace_write.network_access=true"], {
       cwd: options.cwd,
       stdio: ["pipe", "pipe", "pipe"],
       env: { ...process.env, ...options.env }
@@ -15989,6 +15990,7 @@ class CodexBackend {
     let notificationProtocol = "unknown";
     let turnStarted = false;
     let turnDoneTriggered = false;
+    let turnCompletedSuccessfully = false;
     let lastCompletedTurnId = "";
     let turnError = "";
     const pendingRequests = new Map;
@@ -16098,6 +16100,7 @@ class CodexBackend {
             lastCompletedTurnId = turnId;
           const status = turn?.status || params.status || "";
           if (status === "completed" || status === "finished") {
+            turnCompletedSuccessfully = true;
             triggerTurnDone(false);
           } else if (status === "cancelled" || status === "aborted" || status === "interrupted") {
             triggerTurnDone(true);
@@ -16348,10 +16351,10 @@ class CodexBackend {
         closeAllPending("process closed");
         if (timedOut) {
           resultStatus = "timeout";
-        } else if (code !== 0 && resultStatus === "completed") {
+        } else if (code !== 0 && resultStatus === "completed" && !turnCompletedSuccessfully) {
           resultStatus = "failed";
         }
-        const stderr = stderrChunks.join("");
+        const stderr = stderrChunks.join("").replace(/\x1b\[[0-9;]*m/g, "");
         if (stderr && !lastError) {
           lastError = stderr;
         }
@@ -17214,6 +17217,26 @@ function buildPrompt(task, attachments) {
 
 // daemon/session-runner.ts
 var ATTACHMENTS_BASE = "/tmp/alook-attachments";
+async function writeMarkerFile(workspacesRoot, marker) {
+  const dir = path.join(workspacesRoot, ".pending_completions");
+  await mkdir(dir, { recursive: true, mode: 448 });
+  const tmpPath = path.join(dir, `${marker.taskId}.tmp`);
+  const finalPath = path.join(dir, `${marker.taskId}.json`);
+  await writeFile(tmpPath, JSON.stringify(marker), { mode: 384 });
+  await rename(tmpPath, finalPath);
+}
+async function reportToServer(fn, markerData, workspacesRoot) {
+  try {
+    await fn();
+  } catch (e) {
+    log.warn(`server report failed for task ${markerData.taskId}, writing marker: ${e}`);
+    try {
+      await writeMarkerFile(workspacesRoot, markerData);
+    } catch (writeErr) {
+      log.error(`marker write also failed for task ${markerData.taskId}: ${writeErr}`);
+    }
+  }
+}
 function sanitizeFilename(name) {
   return path.basename(name).replace(/[/\\]/g, "_").replace(/\.\./g, "_").slice(0, 255) || "file";
 }
@@ -17241,7 +17264,7 @@ async function downloadAttachments(client, token, workspaceId, taskId, attachmen
   return attachments;
 }
 async function runSession(input) {
-  const { task, provider, cliPath, model, serverURL, token, workspacesRoot, agentTimeout } = input;
+  const { task, provider, cliPath, model, serverURL, token, workspacesRoot, agentTimeout, messageInactivityTimeout } = input;
   log.info(`starting (task=${task.id}, type=${task.type}, agent=${task.agentId}, provider=${provider}, model=${model || "default"})`);
   const client = new DaemonClient(serverURL);
   const backend = createBackend(provider, cliPath);
@@ -17329,27 +17352,47 @@ async function runSession(input) {
         entry.status = "cancelled";
         entry.errmsg = "cancelled by user";
       });
-      try {
-        await client.failTask(token, task.id, "cancelled by user");
-      } catch {}
+      await reportToServer(() => client.failTask(token, task.id, "cancelled by user"), { taskId: task.id, type: "fail", payload: { error: "cancelled by user" }, token, serverURL, createdAt: new Date().toISOString() }, workspacesRoot);
     } else {
       updateEntry(timelineDir, task.id, (entry) => {
         entry.pid = null;
         entry.status = "killed";
         entry.errmsg = "killed by signal";
       });
-      try {
-        await client.failTask(token, task.id, "killed by signal");
-      } catch {}
+      await reportToServer(() => client.failTask(token, task.id, "killed by signal"), { taskId: task.id, type: "fail", payload: { error: "killed by signal" }, token, serverURL, createdAt: new Date().toISOString() }, workspacesRoot);
     }
     process.exit(1);
   };
   process.on("SIGTERM", onKill);
   process.on("SIGINT", onKill);
+  const INACTIVITY_TIMEOUT_MS = messageInactivityTimeout ?? 5 * 60 * 1000;
+  let inactivityTimedOut = false;
   try {
-    for await (const msg of session2.messages) {
-      if (killed)
+    const iter = session2.messages[Symbol.asyncIterator]();
+    while (!killed) {
+      const next = iter.next();
+      const raceResult = await (INACTIVITY_TIMEOUT_MS > 0 ? Promise.race([
+        next,
+        new Promise((resolve) => {
+          const timer = setTimeout(() => resolve("timeout"), INACTIVITY_TIMEOUT_MS);
+          next.then(() => clearTimeout(timer), () => clearTimeout(timer));
+        })
+      ]) : next);
+      if (raceResult === "timeout") {
+        inactivityTimedOut = true;
+        log.warn(`message inactivity timeout (${INACTIVITY_TIMEOUT_MS / 1000}s) — killing agent`);
+        if (session2.pid) {
+          try {
+            process.kill(session2.pid, "SIGTERM");
+          } catch {}
+        }
+        iter.return?.(undefined);
         break;
+      }
+      const iterResult = raceResult;
+      if (iterResult.done)
+        break;
+      const msg = iterResult.value;
       seq++;
       pendingMessages.push({
         seq,
@@ -17388,6 +17431,10 @@ async function runSession(input) {
   process.removeListener("SIGINT", onKill);
   if (killed)
     return;
+  if (inactivityTimedOut) {
+    result.status = "failed";
+    result.error = `message inactivity timeout (no messages for ${INACTIVITY_TIMEOUT_MS / 1000}s)`;
+  }
   await cleanupAttachments(task.id);
   if (result.status === "completed") {
     updateEntry(timelineDir, task.id, (entry) => {
@@ -17399,7 +17446,7 @@ async function runSession(input) {
     updateEntry(timelineDir, task.id, (entry) => {
       entry.pid = null;
       entry.status = "failed";
-      entry.errmsg = result.error || "unknown error";
+      entry.errmsg = result.error || "agent exited unexpectedly";
     });
   }
   if (result.status === "completed") {
@@ -17408,11 +17455,12 @@ async function runSession(input) {
     };
     if (result.sessionId)
       body.session_id = result.sessionId;
-    await client.completeTask(token, task.id, body);
+    await reportToServer(() => client.completeTask(token, task.id, body), { taskId: task.id, type: "complete", payload: body, token, serverURL, createdAt: new Date().toISOString() }, workspacesRoot);
     const dur = (result.durationMs / 1000).toFixed(1);
     log.info(`completed (duration=${dur}s, messages=${seq}, tools=${toolCount})`);
   } else {
-    await client.failTask(token, task.id, result.error || "unknown error");
+    const errorMsg = result.error || "agent exited unexpectedly";
+    await reportToServer(() => client.failTask(token, task.id, errorMsg), { taskId: task.id, type: "fail", payload: { error: errorMsg }, token, serverURL, createdAt: new Date().toISOString() }, workspacesRoot);
     const dur = (result.durationMs / 1000).toFixed(1);
     log.info(`failed (duration=${dur}s, messages=${seq}, tools=${toolCount}) — ${result.error}`);
   }
@@ -17437,9 +17485,8 @@ async function main() {
   } catch (e) {
     log.error(`session-runner: unhandled error for task ${input.task.id}`, e);
     await cleanupAttachments(input.task.id);
-    try {
-      await client.failTask(input.token, input.task.id, `session-runner crash: ${e}`);
-    } catch {}
+    const errorMsg = `session-runner crash: ${e}`;
+    await reportToServer(() => client.failTask(input.token, input.task.id, errorMsg), { taskId: input.task.id, type: "fail", payload: { error: errorMsg }, token: input.token, serverURL: input.serverURL, createdAt: new Date().toISOString() }, input.workspacesRoot);
     process.exit(1);
   }
 }
@@ -17448,5 +17495,7 @@ if (isDirectExecution) {
   main();
 }
 export {
-  runSession
+  writeMarkerFile,
+  runSession,
+  reportToServer
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alook/cli",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "description": "Alook CLI — register and run always-on AI coding agents.",
   "license": "Apache-2.0",
   "homepage": "https://github.com/alookai/alook#readme",