@the-open-engine/zeroshot 6.31.3 → 6.32.1

package/task-lib/commands/status.js

@@ -1,58 +1,115 @@
 import chalk from 'chalk';
+import { resolveEffectiveTaskStatus } from '../effective-status.js';
 import { getTask } from '../store.js';
-import { isOwnedProcessTreeRunning } from '../runner.js';
 
-export function showStatus(taskId) {
-  const task = getTask(taskId);
+function nullable(value) {
+  if (value === undefined || value === null || value === '') return null;
+  return value;
+}
+
+function preferredPrompt(task) {
+  const fullPrompt = nullable(task.fullPrompt);
+  if (fullPrompt !== null) return fullPrompt;
+  return nullable(task.prompt);
+}
+
+function cleanupState(commandCleanup) {
+  if (commandCleanup) return 'pending';
+  return 'complete';
+}
+
+function projectStatus(task, effectiveStatus) {
+  return {
+    id: task.id,
+    status: effectiveStatus.status,
+    statusReason: effectiveStatus.reason,
+    statusDetail: effectiveStatus.detail,
+    createdAt: task.createdAt,
+    updatedAt: task.updatedAt,
+    cwd: task.cwd,
+    pid: nullable(task.pid),
+    exitCode: nullable(task.exitCode),
+    sessionId: nullable(task.sessionId),
+    requestedResumeSessionId: nullable(task.requestedResumeSessionId),
+    cleanup: cleanupState(task.commandCleanup),
+    logFile: nullable(task.logFile),
+    prompt: preferredPrompt(task),
+    error: nullable(task.error),
+    provider: nullable(task.provider),
+    model: nullable(task.model),
+    attachable: task.attachable === true,
+  };
+}
 
+export function getStatusData(taskId, deps = {}) {
+  const readTask = deps.getTask || getTask;
+  const resolveStatus = deps.resolveEffectiveTaskStatus || resolveEffectiveTaskStatus;
+  const task = readTask(taskId);
   if (!task) {
-    console.log(chalk.red(`Task not found: ${taskId}`));
-    process.exit(1);
+    throw new Error(`Task not found: ${taskId}`);
   }
+  return projectStatus(task, resolveStatus(task));
+}
 
-  // Verify running status
-  let status = task.status;
-  if (status === 'running') {
-    try {
-      const running = isOwnedProcessTreeRunning(task.pid, {
-        processGroupId: task.processGroupId,
-        terminationStrategy: task.terminationStrategy || 'process',
-      });
-      if (!running) {
-        status = 'stale (process died)';
-      }
-    } catch (error) {
-      status = `stale (invalid process ownership: ${error.message})`;
-    }
+function loadStatusOrExit(taskId, deps) {
+  try {
+    return getStatusData(taskId, deps);
+  } catch (error) {
+    console.log(chalk.red(error.message));
+    process.exit(1);
+    return null;
   }
+}
 
-  const statusColor =
+function colorForStatus(status) {
+  return (
     {
       running: chalk.green,
       completed: chalk.green,
       failed: chalk.red,
-    }[task.status] || chalk.yellow;
-
-  console.log(chalk.bold(`\nTask: ${task.id}\n`));
-  console.log(`${chalk.dim('Status:')}     ${statusColor(status)}`);
-  console.log(`${chalk.dim('Created:')}    ${task.createdAt}`);
-  console.log(`${chalk.dim('Updated:')}    ${task.updatedAt}`);
-  console.log(`${chalk.dim('CWD:')}        ${task.cwd}`);
-  console.log(`${chalk.dim('PID:')}        ${task.pid || 'N/A'}`);
-  console.log(`${chalk.dim('Exit Code:')}  ${task.exitCode ?? 'N/A'}`);
-  console.log(`${chalk.dim('Session:')}    ${task.sessionId || 'N/A'}`);
-  console.log(`${chalk.dim('Cleanup:')}    ${task.commandCleanup ? 'pending' : 'complete'}`);
-  if (task.requestedResumeSessionId) {
-    console.log(`${chalk.dim('Requested:')}  ${task.requestedResumeSessionId}`);
-  }
-  console.log(`${chalk.dim('Log File:')}   ${task.logFile}`);
+    }[status] || chalk.yellow
+  );
+}
 
-  console.log(`\n${chalk.dim('Prompt:')}`);
-  console.log(task.fullPrompt || task.prompt);
+function statusLabel(status) {
+  if (status.statusDetail) return `${status.status} (${status.statusDetail})`;
+  return status.status;
+}
 
-  if (task.error) {
-    console.log(`\n${chalk.red('Error:')} ${task.error}`);
-  }
+function displayOptional(value) {
+  if (value === null) return 'N/A';
+  return value;
+}
+
+function printRequestedSession(status) {
+  if (!status.requestedResumeSessionId) return;
+  console.log(`${chalk.dim('Requested:')}  ${status.requestedResumeSessionId}`);
+}
+
+function printError(status) {
+  if (!status.error) return;
+  console.log(`\n${chalk.red('Error:')} ${status.error}`);
+}
 
+export function showStatus(taskId, deps = {}) {
+  const status = loadStatusOrExit(taskId, deps);
+  if (!status) return;
+
+  const statusColor = colorForStatus(status.status);
+  console.log(chalk.bold(`\nTask: ${status.id}\n`));
+  console.log(`${chalk.dim('Status:')}     ${statusColor(statusLabel(status))}`);
+  console.log(`${chalk.dim('Created:')}    ${status.createdAt}`);
+  console.log(`${chalk.dim('Updated:')}    ${status.updatedAt}`);
+  console.log(`${chalk.dim('CWD:')}        ${status.cwd}`);
+  console.log(`${chalk.dim('PID:')}        ${displayOptional(status.pid)}`);
+  console.log(`${chalk.dim('Exit Code:')}  ${displayOptional(status.exitCode)}`);
+  console.log(`${chalk.dim('Session:')}    ${displayOptional(status.sessionId)}`);
+  console.log(`${chalk.dim('Cleanup:')}    ${status.cleanup}`);
+  printRequestedSession(status);
+  console.log(`${chalk.dim('Log File:')}   ${displayOptional(status.logFile)}`);
+
+  console.log(`\n${chalk.dim('Prompt:')}`);
+  console.log(displayOptional(status.prompt));
+  printError(status);
   console.log();
 }

package/task-lib/effective-status.js

@@ -0,0 +1,52 @@
+import { isOwnedProcessTreeRunning } from './runner.js';
+
+const DEFAULT_STARTUP_GRACE_MS = 30_000;
+
+const STALE_REASON_LABELS = {
+  invalid_process_ownership: 'invalid process ownership',
+  process_died: 'process died',
+  startup_timeout: 'provider startup timed out',
+};
+
+function runningStatus() {
+  return { status: 'running', reason: null, detail: null, label: 'running' };
+}
+
+function staleStatus(reason) {
+  const detail = STALE_REASON_LABELS[reason];
+  return { status: 'stale', reason, detail, label: `stale (${detail})` };
+}
+
+function resolveStartupStatus(task, deps) {
+  const createdAt = Date.parse(task.createdAt);
+  const now = deps.now?.() ?? Date.now();
+  const graceMs = deps.startupGraceMs ?? DEFAULT_STARTUP_GRACE_MS;
+  return Number.isFinite(createdAt) && now >= createdAt && now - createdAt <= graceMs
+    ? runningStatus()
+    : staleStatus('startup_timeout');
+}
+
+export function resolveEffectiveTaskStatus(task, deps = {}) {
+  if (task.status !== 'running') {
+    return { status: task.status, reason: null, detail: null, label: task.status };
+  }
+  // The durable row is written before the detached watcher can publish its owned provider PID.
+  // Treat that startup window as live, but bound it so an abandoned watcher cannot look active
+  // indefinitely.
+  if (task.pid === null) return resolveStartupStatus(task, deps);
+
+  const isRunning = deps.isOwnedProcessTreeRunning || isOwnedProcessTreeRunning;
+  try {
+    if (
+      isRunning(task.pid, {
+        processGroupId: task.processGroupId,
+        terminationStrategy: task.terminationStrategy || 'process',
+      })
+    ) {
+      return runningStatus();
+    }
+    return staleStatus('process_died');
+  } catch {
+    return staleStatus('invalid_process_ownership');
+  }
+}