@gh-symphony/cli 0.0.17 → 0.0.19

package/dist/chunk-C7G7RJ4G.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+import {
+  loadGlobalConfig,
+  loadProjectConfig
+} from "./chunk-ROGRTUFI.js";
+
+// src/project-selection.ts
+import * as p from "@clack/prompts";
+function isInteractiveTerminal() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+function explicitProjectRequiredMessage() {
+  return "Multiple projects are configured. Re-run with --project-id in non-interactive environments.\n";
+}
+async function inspectManagedProjectSelection(input) {
+  if (input.requestedProjectId) {
+    const projectConfig = await loadProjectConfig(
+      input.configDir,
+      input.requestedProjectId
+    );
+    if (!projectConfig) {
+      return {
+        kind: "requested_project_missing",
+        projectId: input.requestedProjectId,
+        message: `Project "${input.requestedProjectId}" is not configured. Run 'gh-symphony project add' or choose an existing project.`
+      };
+    }
+    return {
+      kind: "resolved",
+      projectId: input.requestedProjectId,
+      projectConfig
+    };
+  }
+  const global = await loadGlobalConfig(input.configDir);
+  if (!global) {
+    return {
+      kind: "missing_global_config",
+      message: "No CLI configuration found. Run 'gh-symphony project add' first."
+    };
+  }
+  const projectIds = global.projects ?? [];
+  if (projectIds.length === 0) {
+    return {
+      kind: "no_projects",
+      message: "No managed projects are configured. Run 'gh-symphony project add' first."
+    };
+  }
+  if (projectIds.length > 1 && !isInteractiveTerminal()) {
+    return {
+      kind: "multiple_projects_require_selection",
+      message: explicitProjectRequiredMessage().trimEnd()
+    };
+  }
+  if (global.activeProject) {
+    const projectConfig = await loadProjectConfig(
+      input.configDir,
+      global.activeProject
+    );
+    if (!projectConfig) {
+      return {
+        kind: "active_project_missing",
+        projectId: global.activeProject,
+        message: `Active project "${global.activeProject}" is configured in config.json but its project config is missing. Re-run 'gh-symphony project add' or 'gh-symphony project switch'.`
+      };
+    }
+    return {
+      kind: "resolved",
+      projectId: global.activeProject,
+      projectConfig
+    };
+  }
+  if (projectIds.length === 1) {
+    const projectId = projectIds[0];
+    const projectConfig = await loadProjectConfig(input.configDir, projectId);
+    if (!projectConfig) {
+      return {
+        kind: "configured_project_missing",
+        projectId,
+        message: `Configured project "${projectId}" is missing its project config file. Re-run 'gh-symphony project add'.`
+      };
+    }
+    return {
+      kind: "resolved",
+      projectId,
+      projectConfig
+    };
+  }
+  return {
+    kind: "multiple_projects_require_selection",
+    message: "Multiple projects are configured and no active project is set. Run 'gh-symphony project switch' or re-run with --project-id."
+  };
+}
+async function resolveManagedProjectConfig(input) {
+  if (input.requestedProjectId) {
+    return loadProjectConfig(input.configDir, input.requestedProjectId);
+  }
+  const global = await loadGlobalConfig(input.configDir);
+  const projectIds = global?.projects ?? [];
+  if (projectIds.length === 0) {
+    return null;
+  }
+  if (projectIds.length === 1) {
+    return loadProjectConfig(input.configDir, projectIds[0]);
+  }
+  if (!isInteractiveTerminal()) {
+    process.stderr.write(explicitProjectRequiredMessage());
+    process.exitCode = 1;
+    return null;
+  }
+  const projects = await Promise.all(
+    projectIds.map(async (projectId) => ({
+      projectId,
+      config: await loadProjectConfig(input.configDir, projectId)
+    }))
+  );
+  const selected = await p.select({
+    message: "Select a project:",
+    options: projects.map(({ projectId, config }) => ({
+      value: projectId,
+      label: config?.displayName ?? config?.slug ?? projectId,
+      hint: projectId === global?.activeProject ? "current" : config && config.displayName && config.displayName !== projectId ? projectId : void 0
+    })),
+    maxItems: 10
+  });
+  if (p.isCancel(selected)) {
+    p.cancel("Cancelled.");
+    process.exitCode = 130;
+    return null;
+  }
+  return loadProjectConfig(input.configDir, selected);
+}
+function handleMissingManagedProjectConfig() {
+  if (process.exitCode) {
+    return;
+  }
+  process.stderr.write(
+    "No project configured. Run 'gh-symphony project add' first.\n"
+  );
+  process.exitCode = 1;
+}
+
+export {
+  inspectManagedProjectSelection,
+  resolveManagedProjectConfig,
+  handleMissingManagedProjectConfig
+};

package/dist/{chunk-MHIWAIVD.js → chunk-GKENCODJ.js}

@@ -1,23 +1,11 @@
 #!/usr/bin/env node
-import {
-  getGhToken
-} from "./chunk-JO3AXHQI.js";
-import {
-  bold,
-  cyan,
-  dim,
-  green,
-  red,
-  setNoColor,
-  yellow
-} from "./chunk-MVRF7BES.js";
 import {
   OrchestratorService,
   acquireProjectLock,
   createStore,
   releaseProjectLock,
   resolveOrchestratorLogLevel
-} from "./chunk-EFMFGOWM.js";
+} from "./chunk-6CI3UUMH.js";
 import {
   deriveIssueWorkspaceKeyFromIdentifier,
   isFileMissing,
@@ -26,14 +14,26 @@ import {
   parseRecentEvents,
   readJsonFile,
   safeReadDir
-} from "./chunk-TF3QNWNC.js";
+} from "./chunk-M3IFVLQS.js";
+import {
+  getGhToken
+} from "./chunk-TILHWBP6.js";
+import {
+  bold,
+  cyan,
+  dim,
+  green,
+  red,
+  setNoColor,
+  yellow
+} from "./chunk-MVRF7BES.js";
 import {
   resolveRuntimeRoot
 } from "./chunk-5NV3LSAJ.js";
 import {
   handleMissingManagedProjectConfig,
   resolveManagedProjectConfig
-} from "./chunk-TH5QPO3Y.js";
+} from "./chunk-C7G7RJ4G.js";
 import {
   daemonPidPath,
   httpStatusPath,
@@ -91,7 +91,8 @@ var DashboardFsReader = class {
     if (issues) {
       return issues.map((issue) => ({
         ...issue,
-        completedOnce: issue.completedOnce ?? false
+        completedOnce: issue.completedOnce ?? false,
+        failureRetryCount: issue.failureRetryCount ?? 0
       }));
     }
     const legacyLeases = await readJsonFile(join(this.projectDir(), "leases.json")) ?? [];
@@ -100,6 +101,7 @@ var DashboardFsReader = class {
       identifier: lease.issueIdentifier,
       workspaceKey: deriveIssueWorkspaceKeyFromIdentifier(lease.issueIdentifier),
       completedOnce: false,
+      failureRetryCount: 0,
       state: lease.status === "active" ? "claimed" : "released",
       currentRunId: lease.status === "active" ? lease.runId : null,
       retryEntry: null,
@@ -114,6 +116,24 @@ var DashboardFsReader = class {
     const runs = await mapWithConcurrency(runIds, RUN_RECORD_LOAD_CONCURRENCY, (runId) => this.loadRun(runId));
     return runs.filter((run) => Boolean(run));
   }
+  async loadRunsForIssue(issueId, issueIdentifier) {
+    const runIds = await safeReadDir(join(this.projectDir(), "runs"));
+    const runs = await mapWithConcurrency(runIds, RUN_RECORD_LOAD_CONCURRENCY, async (runId) => {
+      try {
+        const run = await this.loadRun(runId);
+        if (!run) {
+          return null;
+        }
+        return run.issueId === issueId || run.issueIdentifier === issueIdentifier ? run : null;
+      } catch (error) {
+        if (isFileMissing(error)) {
+          return null;
+        }
+        return null;
+      }
+    });
+    return runs.filter((run) => Boolean(run));
+  }
   async loadRecentRunEvents(runId, limit = DEFAULT_RECENT_EVENT_LIMIT) {
     if (limit <= 0) {
       return [];
@@ -170,64 +190,81 @@ async function statusForIssue(reader, issueIdentifier) {
     return null;
   }
   const currentRunCandidate = issueRecord.currentRunId ? await reader.loadRun(issueRecord.currentRunId) : null;
-  const currentRun = isMatchingIssueRun(currentRunCandidate, reader.projectId, issueRecord.issueId, issueIdentifier) ? currentRunCandidate : await findLatestRunForIssue(reader, issueRecord.issueId, issueIdentifier);
-  const recentEvents = currentRun === null ? [] : await reader.loadRecentRunEvents(currentRun.runId);
+  const currentRun = isMatchingIssueRun(currentRunCandidate, reader.projectId, issueRecord.issueId, issueIdentifier) ? currentRunCandidate : null;
+  const issueRuns = currentRun === null ? await reader.loadRunsForIssue(issueRecord.issueId, issueIdentifier) : currentRun.tokenUsage ? await reader.loadRunsForIssue(issueRecord.issueId, issueIdentifier) : null;
+  const resolvedRun = currentRun ?? findLatestRunForIssue(issueRuns ?? []);
+  const recentEvents = resolvedRun === null ? [] : await reader.loadRecentRunEvents(resolvedRun.runId);
+  const cumulativeTokens = aggregateIssueTokenUsage(issueRuns ?? []);
   const latestEventMessage = recentEvents[recentEvents.length - 1]?.message ?? null;
-  const currentAttempt = currentRun?.attempt ?? issueRecord.retryEntry?.attempt ?? 0;
+  const currentAttempt = resolvedRun?.attempt ?? issueRecord.retryEntry?.attempt ?? 0;
   return {
     issue_identifier: issueRecord.identifier,
     issue_id: issueRecord.issueId,
-    status: currentRun?.status ?? mapIssueOrchestrationStateToStatus(issueRecord.state),
+    status: resolvedRun?.status ?? mapIssueOrchestrationStateToStatus(issueRecord.state),
     workspace: {
-      path: currentRun?.workingDirectory ?? null
+      path: resolvedRun?.workingDirectory ?? null
     },
     attempts: {
       restart_count: Math.max(0, currentAttempt - 1),
       current_retry_attempt: currentAttempt
     },
-    running: currentRun === null ? null : {
-      session_id: currentRun.runtimeSession?.sessionId ?? null,
-      turn_count: currentRun.turnCount ?? null,
-      state: currentRun.issueState ?? null,
-      started_at: currentRun.startedAt ?? null,
-      last_event: currentRun.lastEvent ?? null,
+    running: resolvedRun === null ? null : {
+      session_id: resolvedRun.runtimeSession?.sessionId ?? null,
+      turn_count: resolvedRun.turnCount ?? null,
+      state: resolvedRun.issueState ?? null,
+      started_at: resolvedRun.startedAt ?? null,
+      last_event: resolvedRun.lastEvent ?? null,
       last_message: latestEventMessage,
-      last_event_at: currentRun.lastEventAt ?? null,
-      tokens: currentRun.tokenUsage ? {
-        input_tokens: currentRun.tokenUsage.inputTokens,
-        output_tokens: currentRun.tokenUsage.outputTokens,
-        total_tokens: currentRun.tokenUsage.totalTokens
+      last_event_at: resolvedRun.lastEventAt ?? null,
+      tokens: resolvedRun.tokenUsage ? {
+        input_tokens: resolvedRun.tokenUsage.inputTokens,
+        output_tokens: resolvedRun.tokenUsage.outputTokens,
+        total_tokens: resolvedRun.tokenUsage.totalTokens,
+        cumulative_input_tokens: cumulativeTokens.inputTokens,
+        cumulative_output_tokens: cumulativeTokens.outputTokens,
+        cumulative_total_tokens: cumulativeTokens.totalTokens
       } : null
     },
-    retry: currentRun?.nextRetryAt ?? issueRecord.retryEntry?.dueAt ? {
-      due_at: currentRun?.nextRetryAt ?? issueRecord.retryEntry?.dueAt ?? "",
-      kind: currentRun?.retryKind ?? null,
-      error: currentRun?.lastError ?? issueRecord.retryEntry?.error ?? null
+    retry: resolvedRun?.nextRetryAt ?? issueRecord.retryEntry?.dueAt ? {
+      due_at: resolvedRun?.nextRetryAt ?? issueRecord.retryEntry?.dueAt ?? "",
+      kind: resolvedRun?.retryKind ?? null,
+      error: resolvedRun?.lastError ?? issueRecord.retryEntry?.error ?? null
     } : null,
     logs: {
-      codex_session_logs: currentRun === null ? [] : [
+      codex_session_logs: resolvedRun === null ? [] : [
         {
           label: "worker",
-          path: join(reader.runDir(currentRun.runId), "worker.log"),
+          path: join(reader.runDir(resolvedRun.runId), "worker.log"),
           url: null
         }
       ]
     },
     recent_events: recentEvents,
-    last_error: currentRun?.lastError ?? issueRecord.retryEntry?.error ?? null,
+    last_error: resolvedRun?.lastError ?? issueRecord.retryEntry?.error ?? null,
     tracked: {
       issue_orchestration_state: issueRecord.state,
       current_run_id: issueRecord.currentRunId,
       workspace_key: issueRecord.workspaceKey,
       completed_once: issueRecord.completedOnce,
-      run_phase: currentRun?.runPhase ?? null,
-      execution_phase: currentRun?.executionPhase ?? null
+      run_phase: resolvedRun?.runPhase ?? null,
+      execution_phase: resolvedRun?.executionPhase ?? null
     }
   };
 }
-async function findLatestRunForIssue(reader, issueId, issueIdentifier) {
-  const matchingRuns = (await reader.loadAllRuns()).filter((run) => run.issueId === issueId || run.issueIdentifier === issueIdentifier).sort((left, right) => new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime());
-  return matchingRuns[0] ?? null;
+function aggregateIssueTokenUsage(runs) {
+  return runs.reduce((total, run) => ({
+    inputTokens: total.inputTokens + (run.tokenUsage?.inputTokens ?? 0),
+    outputTokens: total.outputTokens + (run.tokenUsage?.outputTokens ?? 0),
+    totalTokens: total.totalTokens + (run.tokenUsage?.totalTokens ?? 0)
+  }), {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0
+  });
+}
+function findLatestRunForIssue(matchingRuns) {
+  const sortedRuns = [...matchingRuns].sort((left, right) => new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime());
+  return sortedRuns[0] ?? null;
 }
 function assertValidDashboardProjectId(projectId) {
   if (projectId.length === 0 || projectId === "." || projectId === ".." || projectId.includes("/") || projectId.includes("\\")) {
@@ -350,7 +387,8 @@ var DEFAULT_HTTP_PORT = 4680;
 var HTTP_HOST = "0.0.0.0";
 function parseStartArgs(args) {
   const parsed = {
-    daemon: false
+    daemon: false,
+    once: false
   };
   for (let i = 0; i < args.length; i += 1) {
     const arg = args[i];
@@ -358,6 +396,10 @@ function parseStartArgs(args) {
       parsed.daemon = true;
       continue;
     }
+    if (arg === "--once") {
+      parsed.once = true;
+      continue;
+    }
     if (arg === "--http") {
       const value = args[i + 1];
       if (!value || value.startsWith("-")) {
@@ -612,11 +654,16 @@ var handler = async (args, options) => {
     process.stderr.write(`${parsed.error}
 `);
     process.stderr.write(
-      "Usage: gh-symphony start --project-id <project-id> [--daemon] [--http [port]]\n"
+      "Usage: gh-symphony start --project-id <project-id> [--daemon] [--once] [--http [port]]\n"
     );
     process.exitCode = 2;
     return;
   }
+  if (parsed.daemon && parsed.once) {
+    process.stderr.write("Options '--daemon' and '--once' cannot be used together\n");
+    process.exitCode = 2;
+    return;
+  }
   const projectConfig = await resolveManagedProjectConfig({
     configDir: options.configDir,
     requestedProjectId: parsed.projectId
@@ -724,14 +771,20 @@ var handler = async (args, options) => {
         `HTTP dashboard listening on ${httpServer.url}`
       );
     }
-    logLine(dim("\xB7"), dim("Press Ctrl+C to stop"));
+    logLine(
+      dim("\xB7"),
+      dim(parsed.once ? "Running one orchestration tick" : "Press Ctrl+C to stop")
+    );
     let shuttingDown = false;
     let shutdownPromise = null;
+    let keepHttpAliveResolve = null;
     const shutdown = async () => {
       if (shuttingDown) {
         return shutdownPromise;
       }
       shuttingDown = true;
+      keepHttpAliveResolve?.();
+      keepHttpAliveResolve = null;
       const heldLock = projectLock;
       projectLock = null;
       shutdownPromise = shutdownForegroundOrchestrator({
@@ -743,16 +796,31 @@ var handler = async (args, options) => {
       });
       return shutdownPromise;
     };
-    process.on("SIGINT", () => {
+    const handleSigint = () => {
       void shutdown();
-    });
-    process.on("SIGTERM", () => {
+    };
+    const handleSigterm = () => {
       void shutdown();
-    });
+    };
+    process.on("SIGINT", handleSigint);
+    process.on("SIGTERM", handleSigterm);
     try {
       while (!shuttingDown) {
         try {
-          await service.run();
+          await service.run({ once: parsed.once });
+          if (parsed.once) {
+            if (httpServer) {
+              logLine(
+                cyan("\u25A1"),
+                "One-shot tick completed; HTTP dashboard remains available until Ctrl+C"
+              );
+              await new Promise((resolve2) => {
+                keepHttpAliveResolve = resolve2;
+              });
+            } else {
+              await shutdown();
+            }
+          }
           break;
         } catch (error) {
           if (shuttingDown) {
@@ -761,12 +829,32 @@ var handler = async (args, options) => {
           logLine(
             red("\u2717"),
             red(
-              `Run loop error: ${error instanceof Error ? error.message : "Unknown error"}`
+              `${parsed.once ? "One-shot run failed" : "Run loop error"}: ${error instanceof Error ? error.message : "Unknown error"}`
             )
           );
+          if (parsed.once) {
+            process.exitCode = 1;
+            await closeHttpServer(httpServer?.server).catch((closeError) => {
+              logLine(
+                yellow("\u26A0"),
+                `Failed to stop HTTP server: ${closeError instanceof Error ? closeError.message : "Unknown error"}`
+              );
+            });
+            await removeHttpBindingState(options.configDir, projectId).catch(
+              (removeError) => {
+                logLine(
+                  yellow("\u26A0"),
+                  `Failed to remove HTTP state: ${removeError instanceof Error ? removeError.message : "Unknown error"}`
+                );
+              }
+            );
+            return;
+          }
         }
       }
     } finally {
+      process.off("SIGINT", handleSigint);
+      process.off("SIGTERM", handleSigterm);
       if (shutdownPromise) {
         await shutdownPromise;
       }