@gh-symphony/cli 0.0.18 → 0.0.20

package/README.md

@@ -8,10 +8,15 @@ The following tools must be installed before using the CLI:
 
 - **[Node.js](https://nodejs.org/)** (v24+) with npm
 - **[Git](https://git-scm.com/)**
-- **[GitHub CLI (`gh`)](https://cli.github.com/)** — authenticated with required scopes:
-  ```bash
-  gh auth login --scopes repo,read:org,project
-  ```
+- One GitHub auth source with required scopes (`repo`, `read:org`, `project`):
+  - **[GitHub CLI (`gh`)](https://cli.github.com/)**:
+    ```bash
+    gh auth login --scopes repo,read:org,project
+    ```
+  - Or `GITHUB_GRAPHQL_TOKEN` for CI or minimal shells:
+    ```bash
+    export GITHUB_GRAPHQL_TOKEN=ghp_your_classic_token
+    ```
 
 ## 1. Install Package
 
@@ -29,7 +34,9 @@ Validate the machine and repo prerequisites before first use:
 
 ```bash
 gh-symphony doctor
+gh-symphony doctor --fix
 gh-symphony doctor --json
+GITHUB_GRAPHQL_TOKEN=ghp_your_classic_token gh-symphony doctor --json
 ```
 
 Enable shell completion:
@@ -51,19 +58,34 @@ autoload -Uz compinit && compinit
 Navigate to the repository you want to orchestrate, then run:
 
 ```bash
-gh-symphony init
+gh-symphony workflow init
+gh-symphony workflow init --dry-run
+gh-symphony workflow validate
+gh-symphony workflow preview
 ```
 
 The interactive wizard will:
 
-1. Authenticate via `gh` CLI
+1. Authenticate via `GITHUB_GRAPHQL_TOKEN` or fall back to `gh` CLI
 2. Let you select a **GitHub Project** to bind
 3. Map project status columns to workflow phases (active / wait / terminal)
 4. Generate `WORKFLOW.md` and supporting files in the repository
 
+Token-only interactive setup is supported:
+
+```bash
+export GITHUB_GRAPHQL_TOKEN=ghp_your_classic_token
+gh-symphony workflow init
+```
+
+Use `--dry-run` to preview the generated write plan first. The preview reports
+whether `WORKFLOW.md`, `.gh-symphony/context.yaml`,
+`.gh-symphony/reference-workflow.md`, and runtime skill files would be created,
+updated, or left unchanged, and then exits without modifying the repository.
+
 ### Customizing Agent Behavior
 
-`gh-symphony init` generates skill files under `.codex/skills/` (or `.claude/skills/` for Claude Code). These skills define how the AI agent handles commits, pushes, pulls, and project status transitions.
+`gh-symphony workflow init` generates skill files under `.codex/skills/` (or `.claude/skills/` for Claude Code). These skills define how the AI agent handles commits, pushes, pulls, and project status transitions.
 
 You can further customize the agent's behavior by editing `WORKFLOW.md` — this is the policy layer that controls what the agent does at each workflow phase.
 
@@ -111,26 +133,54 @@ gh-symphony project add
 
 The interactive wizard will:
 
-1. Authenticate via `gh` CLI
+1. Authenticate via `GITHUB_GRAPHQL_TOKEN` or fall back to `gh` CLI
 2. Let you select a **GitHub Project**
 3. Optionally limit processing to issues assigned to the authenticated user
 4. Optionally customize advanced settings for repository filtering and workspace root directory
 5. Write project configuration to `~/.gh-symphony/`
 
+Token-only non-interactive setup:
+
+```bash
+GITHUB_GRAPHQL_TOKEN=ghp_your_classic_token \
+  gh-symphony workflow init --non-interactive --project PVT_xxx --output WORKFLOW.md
+
+GITHUB_GRAPHQL_TOKEN=ghp_your_classic_token \
+  gh-symphony project add --non-interactive --project PVT_xxx --workspace-dir ~/.gh-symphony/workspaces
+```
+
+Token-only project registration is also supported:
+
+```bash
+export GITHUB_GRAPHQL_TOKEN=ghp_your_classic_token
+gh-symphony project add
+```
+
 ### Project Management
 
 ```bash
-gh-symphony doctor                   # Validate auth, config, WORKFLOW.md, and runtime command
+gh-symphony doctor                   # Validate local prerequisites, auth, config, WORKFLOW.md, and runtime command
+gh-symphony doctor --fix             # Apply safe fixes and guide/launch follow-up recovery commands
 gh-symphony project list             # List all configured projects
 gh-symphony project remove <id>      # Remove a project
+gh-symphony repo sync                # Add newly linked repositories from the GitHub Project
+gh-symphony repo sync --dry-run      # Preview linked repository drift
+gh-symphony repo sync --prune        # Remove local repositories no longer linked
 ```
 
+Use `gh-symphony repo sync` when the GitHub Project board has gained or lost
+linked repositories since the project was first added locally. Default sync is
+additive; `--prune` switches to strict alignment, and `--json` prints the added,
+removed, unchanged, and final repository sets.
+
 ## 4. Run the Orchestrator
 
 ### Foreground
 
 ```bash
 gh-symphony start
+gh-symphony start --once            # Run startup cleanup + one orchestration tick, then exit
+gh-symphony project start --once    # Same one-shot flow for an explicit project
 ```
 
 ### Background (daemon)
@@ -140,6 +190,8 @@ gh-symphony start --daemon          # Start in background
 gh-symphony stop                    # Stop the daemon
 ```
 
+Use `start --once` for the first real managed-project run or a CI smoke check. It reuses the configured GitHub Project binding and `WORKFLOW.md` and performs exactly one poll/reconcile/dispatch cycle instead of entering the long-running orchestration loop. `--daemon --once` is rejected because the modes conflict. If you add `--http`, the dashboard/API remains available after that one-shot tick completes, and the process stays up until you interrupt it with `Ctrl+C`.
+
 ### Monitor
 
 ```bash
@@ -164,32 +216,50 @@ gh-symphony recover --dry-run       # Preview what would be recovered
 
 ## Diagnostics
 
-`gh-symphony doctor` validates the most common first-run prerequisites in one pass:
+`gh-symphony doctor` validates the most common first-run prerequisites in one pass. `gh-symphony doctor --fix` extends that flow with safe remediation and guided follow-up:
+
+- creates missing config/runtime/workspace directories
+- launches `gh auth login` or `gh auth refresh` when a TTY is available, otherwise prints the exact command to run
+- launches `gh-symphony init` when `WORKFLOW.md` is missing or invalid
+- launches `gh-symphony project add` when managed project setup or GitHub Project binding must be repaired
+- prints concrete runtime install guidance when the configured command is missing on `PATH`
 
-- `gh` installation, auth, and required scopes
+The diagnostic checks cover:
+
+- the active GitHub auth source (`GITHUB_GRAPHQL_TOKEN` first, otherwise `gh`) and required scopes
+- Node.js runtime version against the documented minimum (`v24+`) and the current `process.version`
+- Git installation availability on `PATH`, including `git --version` when available
+- GitHub authentication via `GITHUB_GRAPHQL_TOKEN` or `gh`, including required scopes
 - managed project selection plus GitHub Project binding resolution
 - config/runtime/workspace path writability
 - repository `WORKFLOW.md` presence and parse validity
 - runtime command availability on `PATH`
 
-Use JSON output for scripts and CI smoke checks:
+Use JSON output for scripts and CI smoke checks. `--fix --json` includes a remediation section where each step is reported as `applied`, `skipped`, or `manual`.
 
 ```bash
 gh-symphony doctor --json
+gh-symphony doctor --fix --json
+gh-symphony start --once
 ```
 
+JSON output includes the resolved auth source as `env` or `gh`.
+
 ## Command Reference
 
 ```
 Setup:
-  init                Interactive repository setup wizard
-  doctor              Run first-run diagnostics
+  workflow init       Interactive repository setup wizard
+  workflow validate   Parse and strictly validate WORKFLOW.md
+  workflow preview    Render the final worker prompt from a sample issue
+  doctor              Run diagnostics and optional first-run remediation
   config show         Show current configuration
   config set          Set a configuration value
   config edit         Open config in $EDITOR
 
 Orchestration:
   start               Start the orchestrator (foreground)
+  start --once        Run a single orchestration tick and exit
   start --daemon      Start the orchestrator (background)
   stop                Stop the background orchestrator
   status              Show orchestrator status
@@ -202,6 +272,7 @@ Project Management:
   project add          Add a new project (interactive wizard)
   project list         List all configured projects
   project remove       Remove a project
+  repo sync            Refresh repositories from the linked GitHub Project
 
 Global Options:
   --config <dir>      Config directory (default: ~/.gh-symphony)

package/dist/{project-O57C32WF.js → chunk-3AWF54PI.js}

@@ -3,38 +3,33 @@ import {
   abortIfCancelled,
   generateProjectId,
   writeConfig
-} from "./chunk-5YLETHMR.js";
+} from "./chunk-RN2PACNV.js";
 import {
+  start_default
+} from "./chunk-EKKT5USP.js";
+import {
+  GhAuthError,
   GitHubScopeError,
   checkRequiredScopes,
   createClient,
+  getGhTokenWithSource,
   getProjectDetail,
   listUserProjects,
+  resolveGitHubAuth,
   validateToken
-} from "./chunk-62L6QQE6.js";
-import {
-  start_default
-} from "./chunk-ZYYY55WB.js";
-import {
-  GhAuthError,
-  ensureGhAuth,
-  getGhToken
-} from "./chunk-7UBUBSMH.js";
-import {
-  stop_default
-} from "./chunk-Y6TYJMNT.js";
+} from "./chunk-TILHWBP6.js";
 import {
   status_default
 } from "./chunk-XN5ABWZ6.js";
 import {
   stripAnsi
 } from "./chunk-MVRF7BES.js";
-import "./chunk-LZE6YUSB.js";
-import "./chunk-OL73UN2X.js";
 import {
   resolveRuntimeRoot
 } from "./chunk-5NV3LSAJ.js";
-import "./chunk-C7G7RJ4G.js";
+import {
+  stop_default
+} from "./chunk-Y6TYJMNT.js";
 import {
   daemonPidPath,
   httpStatusPath,
@@ -68,7 +63,7 @@ Then re-run: ${retryCommand}`,
   );
 }
 function parseProjectAddFlags(args) {
-  const flags = { nonInteractive: false, assignedOnly: false };
+  const flags = { nonInteractive: false };
   for (let i = 0; i < args.length; i += 1) {
     const arg = args[i];
     const next = args[i + 1];
@@ -308,12 +303,12 @@ async function projectAdd(args, options) {
     await projectAddNonInteractive(flags, options);
     return;
   }
-  await projectAddInteractive(options);
+  await projectAddInteractive(flags, options);
 }
 async function projectAddNonInteractive(flags, options) {
   let token;
   try {
-    token = getGhToken();
+    token = getGhTokenWithSource().token;
   } catch {
     process.stderr.write(
       "Error: GitHub token not found. Run 'gh auth login --scopes repo,read:org,project' or set GITHUB_GRAPHQL_TOKEN.\n"
@@ -381,7 +376,7 @@ async function projectAddNonInteractive(flags, options) {
 `);
   }
 }
-async function projectAddInteractive(options) {
+async function projectAddInteractive(flags, options) {
   p.intro("gh-symphony - Project Setup");
   const defaultWorkspaceDir = join(options.configDir, "workspaces");
   const existingConfig = await loadGlobalConfig(options.configDir);
@@ -399,32 +394,19 @@ async function projectAddInteractive(options) {
     }
   }
   const s1 = p.spinner();
-  s1.start("Checking gh CLI authentication...");
+  s1.start("Checking GitHub authentication...");
   let login;
   let client;
   try {
-    const { login: ghLogin, token } = ensureGhAuth();
-    login = ghLogin;
-    client = createClient(token);
-    s1.stop(`Authenticated as ${login}`);
+    const auth = await resolveGitHubAuth();
+    const sourceLabel = auth.source === "env" ? "GITHUB_GRAPHQL_TOKEN" : "gh CLI";
+    login = auth.login;
+    client = createClient(auth.token);
+    s1.stop(`Authenticated via ${sourceLabel} as ${login}`);
   } catch (error) {
     s1.stop("Authentication failed.");
     if (error instanceof GhAuthError) {
-      if (error.code === "not_installed") {
-        p.log.error(
-          "gh CLI\uAC00 \uC124\uCE58\uB418\uC5B4 \uC788\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. https://cli.github.com \uC5D0\uC11C \uC124\uCE58\uD558\uC138\uC694."
-        );
-      } else if (error.code === "not_authenticated") {
-        p.log.error(
-          "gh auth login --scopes repo,read:org,project \uB97C \uC2E4\uD589\uD558\uC138\uC694."
-        );
-      } else if (error.code === "missing_scopes") {
-        p.log.error(
-          "gh auth refresh --scopes repo,read:org,project \uB97C \uC2E4\uD589\uD558\uC138\uC694."
-        );
-      } else {
-        p.log.error(error.message);
-      }
+      p.log.error(error.message);
     } else {
       p.log.error(error instanceof Error ? error.message : "Unknown error");
     }
@@ -486,10 +468,64 @@ async function projectAddInteractive(options) {
     process.exitCode = 1;
     return;
   }
+  const {
+    assignedOnly: promptAssignedOnly,
+    selectedRepos,
+    workspaceDir
+  } = await promptProjectRegistrationOptions({
+    projectDetail,
+    defaultWorkspaceDir,
+    assignedOnlyMessage: "Step 2/2 - Only process issues assigned to the authenticated GitHub user?",
+    assignedOnlyInitialValue: flags.assignedOnly
+  });
+  const assignedOnly = flags.assignedOnly || promptAssignedOnly;
+  const repoSummary = selectedRepos.length === projectDetail.linkedRepositories.length ? `${selectedRepos.map((repo) => `${repo.owner}/${repo.name}`).join(", ")}  (all ${selectedRepos.length} linked)` : `${selectedRepos.map((repo) => `${repo.owner}/${repo.name}`).join(", ")}  (${selectedRepos.length} of ${projectDetail.linkedRepositories.length} linked)`;
+  p.note(
+    renderProjectRegistrationSummary({
+      login,
+      projectTitle: projectDetail.title,
+      repoSummary,
+      assignedOnly,
+      workspaceDir
+    }),
+    "Configuration Summary"
+  );
+  const confirmed = await abortIfCancelled(
+    p.confirm({ message: "Apply this configuration?" })
+  );
+  if (!confirmed) {
+    p.cancel("Setup cancelled.");
+    process.exitCode = 130;
+    return;
+  }
+  const projectId = generateProjectId(projectDetail.title, projectDetail.id);
+  const s6 = p.spinner();
+  s6.start("Writing configuration...");
+  try {
+    await writeConfig(options.configDir, {
+      projectId,
+      project: projectDetail,
+      repos: selectedRepos,
+      workspaceDir,
+      assignedOnly
+    });
+    s6.stop("Configuration saved.");
+  } catch (error) {
+    s6.stop("Failed to write configuration.");
+    p.log.error(error instanceof Error ? error.message : "Unknown error");
+    process.exitCode = 1;
+    return;
+  }
+  p.outro(
+    `Project "${projectId}" created.
+  Run 'gh-symphony start' to begin orchestration.`
+  );
+}
+async function promptProjectRegistrationOptions(input) {
   const assignedOnly = await abortIfCancelled(
     p.confirm({
-      message: "Step 2/2 - Only process issues assigned to the authenticated GitHub user?",
-      initialValue: false
+      message: input.assignedOnlyMessage ?? "Only process issues assigned to the authenticated GitHub user?",
+      initialValue: input.assignedOnlyInitialValue ?? false
     })
   );
   const customizeAdvancedOptions = await abortIfCancelled(
@@ -498,8 +534,8 @@ async function projectAddInteractive(options) {
       initialValue: false
     })
   );
-  let selectedRepos = projectDetail.linkedRepositories;
-  let workspaceDir = defaultWorkspaceDir;
+  let selectedRepos = input.projectDetail.linkedRepositories;
+  let workspaceDir = input.defaultWorkspaceDir;
   if (customizeAdvancedOptions) {
     const filterRepositories = await abortIfCancelled(
       p.confirm({
@@ -511,7 +547,7 @@ async function projectAddInteractive(options) {
       selectedRepos = await abortIfCancelled(
         p.multiselect({
           message: "Select repositories to orchestrate:",
-          options: projectDetail.linkedRepositories.map((repo) => ({
+          options: input.projectDetail.linkedRepositories.map((repo) => ({
             value: repo,
             label: `${repo.owner}/${repo.name}`
           })),
@@ -522,55 +558,28 @@ async function projectAddInteractive(options) {
     workspaceDir = await abortIfCancelled(
       p.text({
         message: "Workspace root directory:",
-        placeholder: defaultWorkspaceDir,
-        defaultValue: defaultWorkspaceDir,
+        placeholder: input.defaultWorkspaceDir,
+        defaultValue: input.defaultWorkspaceDir,
         validate(value) {
           return value.trim().length > 0 ? void 0 : "Workspace directory is required.";
         }
       })
     );
   }
-  const repoSummary = selectedRepos.length === projectDetail.linkedRepositories.length ? `${selectedRepos.map((repo) => `${repo.owner}/${repo.name}`).join(", ")}  (all ${selectedRepos.length} linked)` : `${selectedRepos.map((repo) => `${repo.owner}/${repo.name}`).join(", ")}  (${selectedRepos.length} of ${projectDetail.linkedRepositories.length} linked)`;
-  p.note(
-    [
-      `User:       ${login}`,
-      `Project:    ${projectDetail.title}`,
-      `Repos:      ${repoSummary}`,
-      `Assigned:   ${assignedOnly ? `Only issues assigned to ${login}` : "All project issues"}`,
-      `Workspace:  ${workspaceDir}`
-    ].join("\n"),
-    "Configuration Summary"
-  );
-  const confirmed = await abortIfCancelled(
-    p.confirm({ message: "Apply this configuration?" })
-  );
-  if (!confirmed) {
-    p.cancel("Setup cancelled.");
-    process.exitCode = 130;
-    return;
-  }
-  const projectId = generateProjectId(projectDetail.title, projectDetail.id);
-  const s6 = p.spinner();
-  s6.start("Writing configuration...");
-  try {
-    await writeConfig(options.configDir, {
-      projectId,
-      project: projectDetail,
-      repos: selectedRepos,
-      workspaceDir,
-      assignedOnly
-    });
-    s6.stop("Configuration saved.");
-  } catch (error) {
-    s6.stop("Failed to write configuration.");
-    p.log.error(error instanceof Error ? error.message : "Unknown error");
-    process.exitCode = 1;
-    return;
-  }
-  p.outro(
-    `Project "${projectId}" created.
-  Run 'gh-symphony start' to begin orchestration.`
-  );
+  return {
+    assignedOnly,
+    selectedRepos,
+    workspaceDir
+  };
+}
+function renderProjectRegistrationSummary(input) {
+  return [
+    `User:       ${input.login}`,
+    `Project:    ${input.projectTitle}`,
+    `Repos:      ${input.repoSummary}`,
+    `Assigned:   ${input.assignedOnly ? `Only issues assigned to ${input.login}` : "All project issues"}`,
+    `Workspace:  ${input.workspaceDir}`
+  ].join("\n");
 }
 async function projectList(options) {
   const global = await loadGlobalConfig(options.configDir);
@@ -650,7 +659,9 @@ async function projectRemove(args, options) {
 async function projectSwitch(options) {
   const global = await loadGlobalConfig(options.configDir);
   if (!global || global.projects.length === 0) {
-    process.stderr.write("No projects configured. Run 'gh-symphony init'.\n");
+    process.stderr.write(
+      "No projects configured. Run 'gh-symphony workflow init'.\n"
+    );
     process.exitCode = 1;
     return;
   }
@@ -676,6 +687,9 @@ async function projectSwitch(options) {
   process.stdout.write(`Switched to project: ${selected}
 `);
 }
+
 export {
-  project_default as default
+  project_default,
+  promptProjectRegistrationOptions,
+  renderProjectRegistrationSummary
 };

package/dist/{chunk-ZYYY55WB.js → chunk-EKKT5USP.js}

@@ -1,23 +1,11 @@
 #!/usr/bin/env node
-import {
-  getGhToken
-} from "./chunk-7UBUBSMH.js";
-import {
-  bold,
-  cyan,
-  dim,
-  green,
-  red,
-  setNoColor,
-  yellow
-} from "./chunk-MVRF7BES.js";
 import {
   OrchestratorService,
   acquireProjectLock,
   createStore,
   releaseProjectLock,
   resolveOrchestratorLogLevel
-} from "./chunk-LZE6YUSB.js";
+} from "./chunk-HZVDTAPS.js";
 import {
   deriveIssueWorkspaceKeyFromIdentifier,
   isFileMissing,
@@ -26,7 +14,19 @@ import {
   parseRecentEvents,
   readJsonFile,
   safeReadDir
-} from "./chunk-OL73UN2X.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";
@@ -387,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];
@@ -395,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("-")) {
@@ -649,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
@@ -761,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({
@@ -780,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) {
@@ -798,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;
       }