@gh-symphony/cli 0.0.14 → 0.0.15

package/dist/commands/recover.js

@@ -1,119 +0,0 @@
-import { readFile, readdir } from "node:fs/promises";
-import { join } from "node:path";
-import { runCli as orchestratorRunCli } from "@gh-symphony/orchestrator";
-import { resolveRuntimeRoot, } from "../orchestrator-runtime.js";
-import { handleMissingManagedProjectConfig, resolveManagedProjectConfig, } from "../project-selection.js";
-function parseRecoverArgs(args) {
-    const parsed = { dryRun: false };
-    for (let i = 0; i < args.length; i += 1) {
-        const arg = args[i];
-        if (arg === "--dry-run") {
-            parsed.dryRun = true;
-        }
-        if (arg === "--project" || arg === "--project-id") {
-            parsed.projectId = args[i + 1];
-            i += 1;
-        }
-    }
-    return parsed;
-}
-const handler = async (args, options) => {
-    const parsed = parseRecoverArgs(args);
-    const projectConfig = await resolveManagedProjectConfig({
-        configDir: options.configDir,
-        requestedProjectId: parsed.projectId,
-    });
-    if (!projectConfig) {
-        handleMissingManagedProjectConfig();
-        return;
-    }
-    const runtimeRoot = resolveRuntimeRoot(options.configDir);
-    const projectId = projectConfig.projectId;
-    if (parsed.dryRun) {
-        process.stdout.write("Dry run — scanning for stalled runs...\n");
-        const candidates = await listRecoverCandidates(runtimeRoot, projectId);
-        if (options.json) {
-            process.stdout.write(JSON.stringify(candidates, null, 2) + "\n");
-            return;
-        }
-        if (candidates.length === 0) {
-            process.stdout.write("No recoverable runs found.\n");
-            return;
-        }
-        for (const candidate of candidates) {
-            process.stdout.write(`${candidate.issueIdentifier} (${candidate.runId}) — ${candidate.reason}\n`);
-        }
-        return;
-    }
-    process.stdout.write("Recovering stalled runs...\n");
-    await orchestratorRunCli([
-        "recover",
-        "--runtime-root",
-        runtimeRoot,
-        "--project-id",
-        projectId,
-    ]);
-};
-export default handler;
-async function listRecoverCandidates(runtimeRoot, projectId) {
-    const runsDir = join(runtimeRoot, "projects", projectId, "runs");
-    const candidates = [];
-    let entries = [];
-    try {
-        entries = await readdir(runsDir);
-    }
-    catch {
-        return candidates;
-    }
-    for (const entry of entries) {
-        const runPath = join(runsDir, entry, "run.json");
-        try {
-            const raw = await readFile(runPath, "utf8");
-            const run = JSON.parse(raw);
-            if (run.projectId !== projectId) {
-                continue;
-            }
-            const reason = detectRecoveryReason(run);
-            if (!reason) {
-                continue;
-            }
-            candidates.push({
-                runId: run.runId,
-                issueIdentifier: run.issueIdentifier,
-                status: run.status,
-                reason,
-            });
-        }
-        catch {
-            // Skip malformed or partial run records.
-        }
-    }
-    return candidates;
-}
-function detectRecoveryReason(run) {
-    if (run.processId) {
-        const startedAt = run.startedAt ? new Date(run.startedAt).getTime() : 0;
-        const runningForMs = Date.now() - startedAt;
-        if (isProcessRunning(run.processId) && runningForMs > 30 * 60 * 1000) {
-            return "worker appears stuck";
-        }
-        if (!isProcessRunning(run.processId)) {
-            return "worker process is no longer running";
-        }
-    }
-    if (run.status === "retrying" &&
-        run.nextRetryAt &&
-        new Date(run.nextRetryAt).getTime() <= Date.now()) {
-        return "retry window has elapsed";
-    }
-    return null;
-}
-function isProcessRunning(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

package/dist/commands/repo.d.ts

@@ -1,3 +0,0 @@
-import type { GlobalOptions } from "../index.js";
-declare const handler: (args: string[], options: GlobalOptions) => Promise<void>;
-export default handler;

package/dist/commands/repo.js

@@ -1,103 +0,0 @@
-import { loadActiveProjectConfig, loadGlobalConfig, saveProjectConfig, } from "../config.js";
-const handler = async (args, options) => {
-    const [subcommand, ...rest] = args;
-    switch (subcommand) {
-        case "list":
-            await repoList(options);
-            break;
-        case "add":
-            await repoAdd(rest, options);
-            break;
-        case "remove":
-            await repoRemove(rest, options);
-            break;
-        default:
-            process.stderr.write("Usage: gh-symphony repo <list|add|remove> [repo]\n");
-            process.exitCode = 2;
-    }
-};
-export default handler;
-// ── 6.4: repo list / add / remove ────────────────────────────────────────────
-async function repoList(options) {
-    const ws = await loadActiveProjectConfig(options.configDir);
-    if (!ws) {
-        process.stderr.write("No project configured.\n");
-        process.exitCode = 1;
-        return;
-    }
-    if (options.json) {
-        process.stdout.write(JSON.stringify(ws.repositories, null, 2) + "\n");
-        return;
-    }
-    process.stdout.write("Repositories:\n");
-    for (const repo of ws.repositories) {
-        process.stdout.write(`  ${repo.owner}/${repo.name}\n`);
-    }
-}
-async function repoAdd(args, options) {
-    const [repoSpec] = args;
-    if (!repoSpec || !repoSpec.includes("/")) {
-        process.stderr.write("Usage: gh-symphony repo add <owner/name>\n");
-        process.exitCode = 2;
-        return;
-    }
-    const global = await loadGlobalConfig(options.configDir);
-    if (!global?.activeProject) {
-        process.stderr.write("No active project.\n");
-        process.exitCode = 1;
-        return;
-    }
-    const ws = await loadActiveProjectConfig(options.configDir);
-    if (!ws) {
-        process.stderr.write("Project config missing.\n");
-        process.exitCode = 1;
-        return;
-    }
-    const [owner, name] = repoSpec.split("/");
-    if (!owner || !name) {
-        process.stderr.write("Invalid repo format. Use: owner/name\n");
-        process.exitCode = 2;
-        return;
-    }
-    if (ws.repositories.some((r) => r.owner === owner && r.name === name)) {
-        process.stdout.write(`Repository ${repoSpec} is already configured.\n`);
-        return;
-    }
-    ws.repositories.push({
-        owner,
-        name,
-        cloneUrl: `https://github.com/${owner}/${name}.git`,
-    });
-    await saveProjectConfig(options.configDir, global.activeProject, ws);
-    process.stdout.write(`Added repository: ${repoSpec}\n`);
-}
-async function repoRemove(args, options) {
-    const [repoSpec] = args;
-    if (!repoSpec || !repoSpec.includes("/")) {
-        process.stderr.write("Usage: gh-symphony repo remove <owner/name>\n");
-        process.exitCode = 2;
-        return;
-    }
-    const global = await loadGlobalConfig(options.configDir);
-    if (!global?.activeProject) {
-        process.stderr.write("No active project.\n");
-        process.exitCode = 1;
-        return;
-    }
-    const ws = await loadActiveProjectConfig(options.configDir);
-    if (!ws) {
-        process.stderr.write("Project config missing.\n");
-        process.exitCode = 1;
-        return;
-    }
-    const [owner, name] = repoSpec.split("/");
-    const idx = ws.repositories.findIndex((r) => r.owner === owner && r.name === name);
-    if (idx === -1) {
-        process.stderr.write(`Repository ${repoSpec} is not configured.\n`);
-        process.exitCode = 1;
-        return;
-    }
-    ws.repositories.splice(idx, 1);
-    await saveProjectConfig(options.configDir, global.activeProject, ws);
-    process.stdout.write(`Removed repository: ${repoSpec}\n`);
-}

package/dist/commands/run.d.ts

@@ -1,3 +0,0 @@
-import type { GlobalOptions } from "../index.js";
-declare const handler: (args: string[], options: GlobalOptions) => Promise<void>;
-export default handler;

package/dist/commands/run.js

@@ -1,95 +0,0 @@
-import { runCli as orchestratorRunCli } from "@gh-symphony/orchestrator";
-import { resolveRuntimeRoot, } from "../orchestrator-runtime.js";
-import { handleMissingManagedProjectConfig, resolveManagedProjectConfig, } from "../project-selection.js";
-function parseRunArgs(args) {
-    const parsed = {
-        watch: false,
-    };
-    for (let i = 0; i < args.length; i += 1) {
-        const arg = args[i];
-        if (arg === "--watch" || arg === "-w") {
-            parsed.watch = true;
-        }
-        else if (arg === "--project" || arg === "--project-id") {
-            const value = args[i + 1];
-            if (!value || value.startsWith("-")) {
-                parsed.error = `Option '${arg}' argument missing`;
-                return parsed;
-            }
-            parsed.projectId = value;
-            i += 1;
-        }
-        else if (arg === "--log-level") {
-            const value = args[i + 1];
-            if (!value || value.startsWith("-")) {
-                parsed.error = `Option '${arg}' argument missing`;
-                return parsed;
-            }
-            parsed.logLevel = value;
-            i += 1;
-        }
-        else if (!arg?.startsWith("-")) {
-            // Positional arg = issue identifier
-            parsed.issue = arg;
-        }
-        else {
-            parsed.error = `Unknown option '${arg}'`;
-            return parsed;
-        }
-    }
-    return parsed;
-}
-const handler = async (args, options) => {
-    const parsed = parseRunArgs(args);
-    if (parsed.error) {
-        process.stderr.write(`${parsed.error}\n`);
-        process.exitCode = 2;
-        return;
-    }
-    if (!parsed.issue) {
-        process.stderr.write("Usage: gh-symphony run <owner/repo#number>\n");
-        process.exitCode = 2;
-        return;
-    }
-    const projectConfig = await resolveManagedProjectConfig({
-        configDir: options.configDir,
-        requestedProjectId: parsed.projectId,
-    });
-    if (!projectConfig) {
-        handleMissingManagedProjectConfig();
-        return;
-    }
-    const runtimeRoot = resolveRuntimeRoot(options.configDir);
-    const projectId = projectConfig.projectId;
-    // Validate the issue identifier belongs to a configured repo
-    const [repoSpec] = parsed.issue.split("#");
-    if (repoSpec &&
-        !projectConfig.repositories.some((r) => `${r.owner}/${r.name}` === repoSpec)) {
-        process.stderr.write(`Repository "${repoSpec}" is not configured in this project.\n` +
-            `Configured repos: ${projectConfig.repositories.map((r) => `${r.owner}/${r.name}`).join(", ")}\n`);
-        process.exitCode = 1;
-        return;
-    }
-    process.stdout.write(`Dispatching issue: ${parsed.issue}\n`);
-    await orchestratorRunCli([
-        "run-issue",
-        "--runtime-root",
-        runtimeRoot,
-        "--project-id",
-        projectId,
-        "--issue",
-        parsed.issue,
-        ...(parsed.logLevel ? ["--log-level", parsed.logLevel] : []),
-    ]);
-    if (parsed.watch) {
-        process.stdout.write("\nWatching for status changes...\n");
-        await orchestratorRunCli([
-            "status",
-            "--runtime-root",
-            runtimeRoot,
-            "--project-id",
-            projectId,
-        ]);
-    }
-};
-export default handler;

package/dist/commands/start.d.ts

@@ -1,20 +0,0 @@
-import { rm } from "node:fs/promises";
-import type { GlobalOptions } from "../index.js";
-import { releaseProjectLock, type ProjectLockHandle } from "@gh-symphony/orchestrator";
-type ForegroundShutdownOptions = {
-    configDir: string;
-    projectId: string;
-    statusServer: {
-        close(): void;
-    };
-    projectLock?: ProjectLockHandle | null;
-    service?: {
-        shutdown(): Promise<void>;
-    };
-    exit?: (code?: number) => never;
-    removePortFile?: typeof rm;
-    releaseLock?: typeof releaseProjectLock;
-};
-declare const handler: (args: string[], options: GlobalOptions) => Promise<void>;
-export declare function shutdownForegroundOrchestrator(input: ForegroundShutdownOptions): Promise<never>;
-export default handler;

package/dist/commands/start.js

@@ -1,344 +0,0 @@
-import { writeFile, mkdir, readFile, rm } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { spawn } from "node:child_process";
-import { once } from "node:events";
-import { daemonPidPath, orchestratorLogPath, orchestratorPortPath, } from "../config.js";
-import { OrchestratorService, acquireProjectLock, createStore, releaseProjectLock, resolveOrchestratorLogLevel, startOrchestratorStatusServer, } from "@gh-symphony/orchestrator";
-import { resolveRuntimeRoot, } from "../orchestrator-runtime.js";
-import { handleMissingManagedProjectConfig, resolveManagedProjectConfig, } from "../project-selection.js";
-import { bold, dim, green, red, yellow, cyan, setNoColor } from "../ansi.js";
-import { getGhToken } from "../github/gh-auth.js";
-function timestamp() {
-    const now = new Date();
-    const hh = String(now.getHours()).padStart(2, "0");
-    const mm = String(now.getMinutes()).padStart(2, "0");
-    const ss = String(now.getSeconds()).padStart(2, "0");
-    return dim(`${hh}:${mm}:${ss}`);
-}
-function logLine(icon, msg) {
-    process.stdout.write(`${timestamp()} ${icon} ${msg}\n`);
-}
-// ── Arg parsing ───────────────────────────────────────────────────────────────
-function parseStartArgs(args) {
-    const parsed = {
-        daemon: false,
-    };
-    for (let i = 0; i < args.length; i += 1) {
-        const arg = args[i];
-        if (arg === "--daemon" || arg === "-d") {
-            parsed.daemon = true;
-            continue;
-        }
-        if (arg === "--project" || arg === "--project-id") {
-            const value = args[i + 1];
-            if (!value || value.startsWith("-")) {
-                parsed.error = `Option '${arg}' argument missing`;
-                return parsed;
-            }
-            parsed.projectId = value;
-            i += 1;
-            continue;
-        }
-        if (arg === "--log-level") {
-            const value = args[i + 1];
-            if (!value || value.startsWith("-")) {
-                parsed.error = `Option '${arg}' argument missing`;
-                return parsed;
-            }
-            parsed.logLevel = value;
-            i += 1;
-            continue;
-        }
-        if (arg?.startsWith("-")) {
-            parsed.error = `Unknown option '${arg}'`;
-            return parsed;
-        }
-    }
-    return parsed;
-}
-// ── Tick logging ──────────────────────────────────────────────────────────────
-function logTickResult(snapshot, prevSnapshot, isFirst) {
-    if (isFirst) {
-        const healthColor = snapshot.health === "degraded"
-            ? red
-            : snapshot.health === "running"
-                ? green
-                : cyan;
-        logLine(green("\u25CF"), `Project ${bold(snapshot.slug)} connected ${dim("(")}${healthColor(snapshot.health)}${dim(")")}`);
-        if (snapshot.summary.activeRuns > 0) {
-            logLine(cyan("\u25B8"), `${snapshot.summary.activeRuns} active run(s)`);
-        }
-        return;
-    }
-    if (prevSnapshot && prevSnapshot.health !== snapshot.health) {
-        const icon = snapshot.health === "degraded" ? red("\u25CF") : green("\u25CF");
-        logLine(icon, `Health changed: ${prevSnapshot.health} \u2192 ${bold(snapshot.health)}`);
-    }
-    if (snapshot.lastError && snapshot.lastError !== prevSnapshot?.lastError) {
-        logLine(red("\u2717"), red(snapshot.lastError));
-    }
-    if (!snapshot.lastError && prevSnapshot?.lastError) {
-        logLine(green("\u2713"), green("Error cleared"));
-    }
-    const prevDispatched = prevSnapshot?.summary.dispatched ?? 0;
-    if (snapshot.summary.dispatched > prevDispatched) {
-        const delta = snapshot.summary.dispatched - prevDispatched;
-        logLine(yellow("\u25B8"), `Dispatched ${bold(String(delta))} new run(s)`);
-    }
-    const prevRunIds = new Set(prevSnapshot?.activeRuns.map((run) => run.runId) ?? []);
-    for (const run of snapshot.activeRuns) {
-        if (!prevRunIds.has(run.runId)) {
-            logLine(cyan("\u25B8"), `Run started: ${bold(run.issueIdentifier)} ${dim("state=")}${run.issueState} ${dim("status=")}${run.status}`);
-        }
-    }
-    const currentRunIds = new Set(snapshot.activeRuns.map((run) => run.runId));
-    for (const prevRun of prevSnapshot?.activeRuns ?? []) {
-        if (!currentRunIds.has(prevRun.runId)) {
-            logLine(green("\u2713"), `Run finished: ${bold(prevRun.issueIdentifier)} ${dim("(")}${prevRun.status}${dim(")")}`);
-        }
-    }
-    const prevSuppressed = prevSnapshot?.summary.suppressed ?? 0;
-    if (snapshot.summary.suppressed > prevSuppressed) {
-        const delta = snapshot.summary.suppressed - prevSuppressed;
-        logLine(dim("\u25CB"), dim(`${delta} issue(s) suppressed (already running or at limit)`));
-    }
-    const prevRecovered = prevSnapshot?.summary.recovered ?? 0;
-    if (snapshot.summary.recovered > prevRecovered) {
-        const delta = snapshot.summary.recovered - prevRecovered;
-        logLine(yellow("\u21BA"), `Recovered ${bold(String(delta))} stalled run(s)`);
-    }
-    const prevRetryCount = prevSnapshot?.retryQueue.length ?? 0;
-    if (snapshot.retryQueue.length > prevRetryCount) {
-        const delta = snapshot.retryQueue.length - prevRetryCount;
-        logLine(yellow("\u25CC"), `${delta} run(s) queued for retry`);
-    }
-    const changed = snapshot.health !== prevSnapshot?.health ||
-        snapshot.lastError !== prevSnapshot?.lastError ||
-        snapshot.summary.dispatched !== prevSnapshot?.summary.dispatched ||
-        snapshot.summary.suppressed !== prevSnapshot?.summary.suppressed ||
-        snapshot.summary.recovered !== prevSnapshot?.summary.recovered ||
-        snapshot.activeRuns.length !== (prevSnapshot?.activeRuns.length ?? 0) ||
-        snapshot.retryQueue.length !== (prevSnapshot?.retryQueue.length ?? 0);
-    if (!changed) {
-        logLine(dim("\u00B7"), dim(`tick \u2014 ${snapshot.summary.activeRuns} active, ${snapshot.health}`));
-    }
-}
-// ── Handler ───────────────────────────────────────────────────────────────────
-const handler = async (args, options) => {
-    setNoColor(options.noColor);
-    const parsed = parseStartArgs(args);
-    if (parsed.error) {
-        process.stderr.write(`${parsed.error}\n`);
-        process.stderr.write("Usage: gh-symphony start --project-id <project-id> [--daemon]\n");
-        process.exitCode = 2;
-        return;
-    }
-    const projectConfig = await resolveManagedProjectConfig({
-        configDir: options.configDir,
-        requestedProjectId: parsed.projectId,
-    });
-    if (!projectConfig) {
-        handleMissingManagedProjectConfig();
-        return;
-    }
-    const runtimeRoot = resolveRuntimeRoot(options.configDir);
-    const projectId = projectConfig.projectId;
-    let logLevel;
-    try {
-        logLevel = resolveOrchestratorLogLevel(parsed.logLevel ?? process.env.SYMPHONY_LOG_LEVEL);
-    }
-    catch (error) {
-        process.stderr.write(`${error instanceof Error ? error.message : "Unsupported log level"}\n`);
-        process.exitCode = 2;
-        return;
-    }
-    if (parsed.daemon) {
-        await startDaemon(options, projectId, parsed.logLevel);
-        return;
-    }
-    // ── 5.1: Foreground mode with live logging ────────────────────────────────
-    if (!process.env.GITHUB_GRAPHQL_TOKEN) {
-        try {
-            process.env.GITHUB_GRAPHQL_TOKEN = getGhToken();
-        }
-        catch {
-            // gh CLI not installed/authenticated — GITHUB_GRAPHQL_TOKEN stays unset
-            // Workers will fail if token is needed but not available
-        }
-    }
-    let projectLock = null;
-    try {
-        projectLock = await acquireProjectLock({
-            runtimeRoot,
-            projectId,
-        });
-        const store = createStore(runtimeRoot);
-        const service = new OrchestratorService(store, projectConfig, {
-            logLevel,
-        });
-        const statusServer = startOrchestratorStatusServer({
-            host: "127.0.0.1",
-            port: 0,
-            getProjectStatus: () => service.status(),
-            onRefresh: async () => {
-                await service.runOnce();
-            },
-        });
-        await persistStatusServerPort(options.configDir, projectId, statusServer);
-        logLine(green("\u25B2"), `Starting orchestrator for project: ${bold(projectId)}`);
-        logLine(dim("\u00B7"), dim("Press Ctrl+C to stop"));
-        let running = true;
-        let shuttingDown = false;
-        let shutdownPromise = null;
-        const shutdown = async () => {
-            if (shuttingDown) {
-                return shutdownPromise;
-            }
-            shuttingDown = true;
-            running = false;
-            const heldLock = projectLock;
-            projectLock = null;
-            shutdownPromise = shutdownForegroundOrchestrator({
-                configDir: options.configDir,
-                projectId,
-                statusServer,
-                projectLock: heldLock,
-                service,
-            });
-            return shutdownPromise;
-        };
-        process.on("SIGINT", () => {
-            void shutdown();
-        });
-        process.on("SIGTERM", () => {
-            void shutdown();
-        });
-        let prevSnapshot = null;
-        let isFirst = true;
-        while (running) {
-            try {
-                const snapshot = await service.runOnce();
-                logTickResult(snapshot, prevSnapshot, isFirst);
-                if (!isFirst) {
-                    const currentRunIds = new Set(snapshot.activeRuns.map((run) => run.runId));
-                    for (const prevRun of prevSnapshot?.activeRuns ?? []) {
-                        if (!currentRunIds.has(prevRun.runId)) {
-                            await tailWorkerLog(runtimeRoot, projectId, prevRun.runId, prevRun.issueIdentifier);
-                        }
-                    }
-                }
-                prevSnapshot = snapshot;
-                isFirst = false;
-            }
-            catch (error) {
-                logLine(red("\u2717"), red(`Tick error: ${error instanceof Error ? error.message : "Unknown error"}`));
-            }
-            if (!running) {
-                if (shutdownPromise) {
-                    await shutdownPromise;
-                }
-                break;
-            }
-            // Poll interval: default 30s
-            await new Promise((r) => setTimeout(r, 30_000));
-        }
-    }
-    finally {
-        await releaseProjectLock(projectLock);
-    }
-};
-export async function shutdownForegroundOrchestrator(input) {
-    logLine(yellow("\u25BC"), "Shutting down...");
-    // Drain active workers before tearing down infrastructure so that child
-    // processes receive SIGTERM/SIGKILL and do not become orphans.
-    if (input.service) {
-        try {
-            await input.service.shutdown();
-        }
-        catch (error) {
-            logLine(red("\u2717"), red(`Failed to shut down workers: ${error instanceof Error ? error.message : "Unknown error"}`));
-        }
-    }
-    try {
-        input.statusServer.close();
-    }
-    catch (error) {
-        logLine(red("\u2717"), red(`Failed to close status server: ${error instanceof Error ? error.message : "Unknown error"}`));
-    }
-    try {
-        await (input.removePortFile ?? rm)(orchestratorPortPath(input.configDir, input.projectId), {
-            force: true,
-        });
-    }
-    catch (error) {
-        logLine(yellow("\u26A0"), `Failed to remove persisted status port: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    try {
-        await (input.releaseLock ?? releaseProjectLock)(input.projectLock);
-    }
-    catch (error) {
-        logLine(yellow("\u26A0"), `Failed to release project lock: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    return (input.exit ?? process.exit)(0);
-}
-async function tailWorkerLog(runtimeRoot, projectId, runId, issueIdentifier) {
-    try {
-        const logPath = join(runtimeRoot, "projects", projectId, "runs", runId, "worker.log");
-        const content = await readFile(logPath, "utf8");
-        const lines = content.split("\n").filter((l) => l.trim());
-        if (lines.length === 0)
-            return;
-        const tail = lines.slice(-30);
-        logLine(red("\u2717"), red(`Worker stderr (${issueIdentifier}):`));
-        for (const line of tail) {
-            process.stdout.write(`  ${dim(line)}\n`);
-        }
-    }
-    catch {
-        // worker.log 없거나 읽기 실패 시 무시
-    }
-}
-export default handler;
-// ── 5.2: Daemon mode ─────────────────────────────────────────────────────────
-async function startDaemon(options, projectId, logLevel) {
-    const logPath = orchestratorLogPath(options.configDir, projectId);
-    await mkdir(dirname(logPath), { recursive: true });
-    const { openSync } = await import("node:fs");
-    const logFd = openSync(logPath, "a");
-    const child = spawn(process.execPath, [
-        process.argv[1],
-        "start",
-        "--project",
-        projectId,
-        ...(logLevel ? ["--log-level", logLevel] : []),
-    ], {
-        cwd: process.cwd(),
-        env: {
-            ...process.env,
-            GH_SYMPHONY_CONFIG_DIR: options.configDir,
-        },
-        detached: true,
-        stdio: ["ignore", logFd, logFd],
-    });
-    const pidPath = daemonPidPath(options.configDir, projectId);
-    await mkdir(dirname(pidPath), { recursive: true });
-    await writeFile(pidPath, String(child.pid), "utf8");
-    child.unref();
-    const { closeSync } = await import("node:fs");
-    closeSync(logFd);
-    process.stdout.write(`Orchestrator started in background (PID: ${child.pid}).\n` +
-        `Logs: ${logPath}\n` +
-        `Stop with: gh-symphony project stop --project-id ${projectId}\n`);
-}
-async function persistStatusServerPort(configDir, projectId, statusServer) {
-    if (!statusServer.listening) {
-        await once(statusServer, "listening");
-    }
-    const address = statusServer.address();
-    if (!address || typeof address !== "object") {
-        return;
-    }
-    const portPath = orchestratorPortPath(configDir, projectId);
-    await mkdir(dirname(portPath), { recursive: true });
-    await writeFile(portPath, `${address.port}\n`, "utf8");
-}