@gh-symphony/cli 0.0.14 → 0.0.15

package/dist/commands/status-refresh.d.ts

@@ -1,9 +0,0 @@
-type RefreshRequestOptions = {
-    fetchImpl?: typeof fetch;
-    timeoutMs?: number;
-    env?: NodeJS.ProcessEnv;
-    baseUrl?: string | null;
-};
-export declare function resolveOrchestratorStatusBaseUrl(env?: NodeJS.ProcessEnv): string;
-export declare function requestOrchestratorRefresh(options?: RefreshRequestOptions): Promise<boolean>;
-export {};

package/dist/commands/status-refresh.js

@@ -1,27 +0,0 @@
-export function resolveOrchestratorStatusBaseUrl(env = process.env) {
-    const host = env.ORCHESTRATOR_STATUS_HOST ?? "127.0.0.1";
-    const port = env.ORCHESTRATOR_STATUS_PORT ?? "4680";
-    const urlHost = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
-    return `http://${urlHost}:${port}`;
-}
-export async function requestOrchestratorRefresh(options = {}) {
-    const fetchImpl = options.fetchImpl ?? fetch;
-    const timeoutMs = options.timeoutMs ?? 5_000;
-    const signal = AbortSignal.timeout(timeoutMs);
-    const baseUrl = "baseUrl" in options
-        ? options.baseUrl
-        : resolveOrchestratorStatusBaseUrl(options.env);
-    if (!baseUrl) {
-        return false;
-    }
-    try {
-        const response = await fetchImpl(`${baseUrl}/api/v1/refresh`, {
-            method: "POST",
-            signal,
-        });
-        return response.ok;
-    }
-    catch {
-        return false;
-    }
-}

package/dist/commands/status.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/status.js

@@ -1,237 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { resolveRuntimeRoot, } from "../orchestrator-runtime.js";
-import { handleMissingManagedProjectConfig, resolveManagedProjectConfig, } from "../project-selection.js";
-import { bold, dim, green, red, yellow, cyan, stripAnsi } from "../ansi.js";
-import { clearScreen, showCursor, hideCursor } from "../ansi.js";
-import { renderDashboard } from "../dashboard/renderer.js";
-import { resolveProjectOrchestratorStatusBaseUrl } from "../orchestrator-status-endpoint.js";
-import { requestOrchestratorRefresh } from "./status-refresh.js";
-const WATCH_REFRESH_TIMEOUT_MS = 1_500;
-function healthIcon(health) {
-    switch (health) {
-        case "idle":
-        case "running":
-            return green("●");
-        case "degraded":
-            return red("●");
-    }
-}
-function relativeTime(isoString) {
-    const now = new Date();
-    const then = new Date(isoString);
-    const diffMs = now.getTime() - then.getTime();
-    const diffS = Math.floor(diffMs / 1000);
-    const diffM = Math.floor(diffS / 60);
-    const diffH = Math.floor(diffM / 60);
-    if (diffS < 60)
-        return `${diffS}s ago`;
-    if (diffM < 60)
-        return `${diffM}m ago`;
-    return `${diffH}h ago`;
-}
-function truncate(s, len) {
-    if (s.length <= len)
-        return s;
-    return s.slice(0, len - 3) + "...";
-}
-function renderLegacyStatus(snapshot, noColor) {
-    const apply = noColor ? (s) => stripAnsi(s) : (s) => s;
-    const lines = [];
-    // Header
-    const headerTitle = `gh-symphony ∙ ${snapshot.slug}`;
-    const headerWidth = 45;
-    const headerPadding = Math.max(0, headerWidth - stripAnsi(headerTitle).length);
-    lines.push("╭" + "─".repeat(headerWidth) + "╮");
-    lines.push("│  " + apply(bold(headerTitle)) + " ".repeat(headerPadding) + "│");
-    lines.push("╰" + "─".repeat(headerWidth) + "╯");
-    lines.push("");
-    // Health and last tick
-    const healthStr = apply(`${healthIcon(snapshot.health)} Health    ${snapshot.health}`);
-    const lastTickStr = apply(`Last tick  ${relativeTime(snapshot.lastTickAt)}`);
-    lines.push(`  ${healthStr}${" ".repeat(Math.max(0, 30 - stripAnsi(healthStr).length))}${lastTickStr}`);
-    lines.push("");
-    // Summary stats
-    const dispatchedStr = apply(`Dispatched   ${snapshot.summary.dispatched}`);
-    const activeRunsStr = apply(`Active Runs  ${snapshot.summary.activeRuns}`);
-    const suppressedStr = apply(`Suppressed   ${snapshot.summary.suppressed}`);
-    const recoveredStr = apply(`Recovered    ${snapshot.summary.recovered}`);
-    lines.push(`  ${dispatchedStr}${" ".repeat(Math.max(0, 20 - stripAnsi(dispatchedStr).length))}${activeRunsStr}`);
-    lines.push(`  ${suppressedStr}${" ".repeat(Math.max(0, 20 - stripAnsi(suppressedStr).length))}${recoveredStr}`);
-    lines.push("");
-    // Active runs table
-    if (snapshot.activeRuns.length > 0) {
-        lines.push("  Active Runs:");
-        for (const run of snapshot.activeRuns) {
-            const runIdDisplay = truncate(run.runId, 12);
-            const stateStr = apply(cyan(run.issueState));
-            const statusColor = run.status === "running"
-                ? green
-                : run.status === "failed"
-                    ? red
-                    : run.status === "succeeded"
-                        ? green
-                        : dim;
-            const statusStr = apply(statusColor(run.status));
-            lines.push(`    ${runIdDisplay}  ${run.issueIdentifier}  ${stateStr}  ${statusStr}`);
-        }
-        lines.push("");
-    }
-    else {
-        lines.push("  No active runs.");
-        lines.push("");
-    }
-    // Retry queue
-    if (snapshot.retryQueue.length > 0) {
-        lines.push("  Retry Queue:");
-        for (const retry of snapshot.retryQueue) {
-            const runIdDisplay = truncate(retry.runId, 12);
-            const nextRetryDisplay = retry.nextRetryAt
-                ? relativeTime(retry.nextRetryAt)
-                : "pending";
-            lines.push(`    ${runIdDisplay}  ${retry.issueIdentifier}  ${apply(yellow(retry.retryKind))}  ${nextRetryDisplay}`);
-        }
-        lines.push("");
-    }
-    // Last error
-    if (snapshot.lastError) {
-        lines.push(apply(red(`  ✗ ${snapshot.lastError}`)));
-        lines.push("");
-    }
-    // Token usage
-    if (snapshot.codexTotals) {
-        const tokenStr = apply(`Tokens: ${snapshot.codexTotals.inputTokens} in / ${snapshot.codexTotals.outputTokens} out / ${snapshot.codexTotals.totalTokens} total`);
-        lines.push(`  ${tokenStr}`);
-    }
-    else {
-        lines.push("  Tokens: 0 in / 0 out / 0 total");
-    }
-    return lines.join("\n");
-}
-function parseStatusArgs(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;
-            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?.startsWith("-")) {
-            parsed.error = `Unknown option '${arg}'`;
-            return parsed;
-        }
-    }
-    return parsed;
-}
-async function readStatusSnapshot(runtimeRoot, projectId) {
-    try {
-        const statusPath = join(runtimeRoot, "projects", projectId, "status.json");
-        const content = await readFile(statusPath, "utf-8");
-        return JSON.parse(content);
-    }
-    catch {
-        return null;
-    }
-}
-const handler = async (args, options) => {
-    const parsed = parseStatusArgs(args);
-    if (parsed.error) {
-        process.stderr.write(`${parsed.error}\n`);
-        process.stderr.write("Usage: gh-symphony status [--project-id <project-id>] [--watch]\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;
-    if (parsed.watch) {
-        const isTTY = process.stdout.isTTY === true;
-        let terminalWidth = process.stdout.columns ?? 115;
-        let runPromise = null;
-        const run = async () => {
-            const baseUrl = await resolveProjectOrchestratorStatusBaseUrl({
-                configDir: options.configDir,
-                projectId,
-            });
-            await requestOrchestratorRefresh({
-                baseUrl,
-                timeoutMs: WATCH_REFRESH_TIMEOUT_MS,
-            });
-            const snapshot = await readStatusSnapshot(runtimeRoot, projectId);
-            if (options.json || !isTTY) {
-                process.stdout.write(JSON.stringify(snapshot, null, 2) + "\n");
-            }
-            else {
-                if (!snapshot) {
-                    process.stdout.write(clearScreen() + "Unable to read status snapshot.\n");
-                    return;
-                }
-                process.stdout.write(clearScreen() +
-                    renderDashboard([snapshot], {
-                        terminalWidth,
-                        noColor: options.noColor,
-                    }) +
-                    "\n");
-            }
-        };
-        const tick = () => {
-            if (runPromise) {
-                return;
-            }
-            runPromise = run().finally(() => {
-                runPromise = null;
-            });
-        };
-        if (isTTY) {
-            process.stdout.write(hideCursor());
-        }
-        tick();
-        await runPromise;
-        const interval = setInterval(tick, 2000);
-        process.on("SIGWINCH", () => {
-            terminalWidth = process.stdout.columns ?? terminalWidth;
-        });
-        const shutdown = () => {
-            clearInterval(interval);
-            process.stdout.write(showCursor() + "\n");
-            process.exit(0);
-        };
-        process.on("SIGINT", shutdown);
-        process.on("SIGTERM", shutdown);
-        await new Promise(() => { });
-    }
-    // Single status query
-    const snapshot = await readStatusSnapshot(runtimeRoot, projectId);
-    if (snapshot) {
-        if (options.json) {
-            process.stdout.write(JSON.stringify(snapshot, null, 2) + "\n");
-        }
-        else {
-            process.stdout.write(renderLegacyStatus(snapshot, options.noColor) + "\n");
-        }
-    }
-    else {
-        process.stderr.write("Unable to read status snapshot.\n");
-        process.exitCode = 1;
-    }
-};
-export default handler;

package/dist/commands/stop.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/stop.js

@@ -1,92 +0,0 @@
-import { readFile, rm } from "node:fs/promises";
-import { daemonPidPath, orchestratorPortPath } from "../config.js";
-import { handleMissingManagedProjectConfig, resolveManagedProjectConfig, } from "../project-selection.js";
-function parseStopArgs(args) {
-    const parsed = {
-        force: false,
-    };
-    for (let i = 0; i < args.length; i += 1) {
-        const arg = args[i];
-        if (arg === "--force") {
-            parsed.force = 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?.startsWith("-")) {
-            parsed.error = `Unknown option '${arg}'`;
-            return parsed;
-        }
-    }
-    return parsed;
-}
-const handler = async (args, options) => {
-    const parsed = parseStopArgs(args);
-    if (parsed.error) {
-        process.stderr.write(`${parsed.error}\n`);
-        process.stderr.write("Usage: gh-symphony stop --project-id <project-id> [--force]\n");
-        process.exitCode = 2;
-        return;
-    }
-    const resolvedForce = parsed.force;
-    const projectConfig = await resolveManagedProjectConfig({
-        configDir: options.configDir,
-        requestedProjectId: parsed.projectId,
-    });
-    if (!projectConfig) {
-        handleMissingManagedProjectConfig();
-        return;
-    }
-    const resolvedProjectId = projectConfig.projectId;
-    const pidPath = daemonPidPath(options.configDir, resolvedProjectId);
-    const portPath = orchestratorPortPath(options.configDir, resolvedProjectId);
-    let pidStr;
-    try {
-        pidStr = await readFile(pidPath, "utf8");
-    }
-    catch {
-        process.stderr.write(`No running daemon found for project "${resolvedProjectId}" (PID file missing).\n`);
-        process.exitCode = 1;
-        return;
-    }
-    const pid = Number.parseInt(pidStr.trim(), 10);
-    if (!Number.isFinite(pid)) {
-        process.stderr.write(`Invalid PID in ${pidPath}: ${pidStr}\n`);
-        process.exitCode = 1;
-        return;
-    }
-    try {
-        // Check if process is running
-        process.kill(pid, 0);
-    }
-    catch {
-        process.stdout.write(`Daemon for project "${resolvedProjectId}" (PID ${pid}) is not running. Cleaning up PID file.\n`);
-        await rm(pidPath, { force: true });
-        await rm(portPath, { force: true });
-        return;
-    }
-    const signal = resolvedForce ? "SIGKILL" : "SIGTERM";
-    try {
-        process.kill(pid, signal);
-        process.stdout.write(`Sent ${signal} to orchestrator (PID ${pid}).\n`);
-    }
-    catch (error) {
-        process.stderr.write(`Failed to stop process ${pid}: ${error instanceof Error ? error.message : "Unknown error"}\n`);
-        process.exitCode = 1;
-        return;
-    }
-    await rm(pidPath, { force: true });
-    if (resolvedForce) {
-        await rm(portPath, { force: true });
-    }
-    process.stdout.write("Daemon stopped.\n");
-};
-export default handler;

package/dist/commands/version.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/version.js

@@ -1,21 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { resolve, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-const handler = async (_args, options) => {
-    let version = "0.0.0";
-    try {
-        const pkgPath = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
-        const pkg = JSON.parse(await readFile(pkgPath, "utf8"));
-        version = pkg.version ?? version;
-    }
-    catch {
-        // Fall back to default
-    }
-    if (options.json) {
-        process.stdout.write(JSON.stringify({ version }) + "\n");
-    }
-    else {
-        process.stdout.write(`gh-symphony v${version}\n`);
-    }
-};
-export default handler;

package/dist/completion.d.ts

@@ -1 +0,0 @@
-export declare function renderCompletionScript(shell: "bash" | "zsh" | "fish"): string;

package/dist/completion.js

@@ -1,204 +0,0 @@
-const TOP_LEVEL_COMMANDS = [
-    "init",
-    "start",
-    "stop",
-    "status",
-    "run",
-    "recover",
-    "logs",
-    "project",
-    "repo",
-    "config",
-    "completion",
-    "help",
-    "version",
-];
-const GLOBAL_OPTIONS = [
-    "--config",
-    "--config-dir",
-    "--verbose",
-    "-v",
-    "--json",
-    "--no-color",
-    "--help",
-    "-h",
-    "--version",
-    "-V",
-];
-const GLOBAL_OPTIONS_WITH_VALUES = ["--config", "--config-dir"];
-const COMMAND_OPTIONS = {
-    completion: ["bash", "zsh", "fish"],
-    start: ["--project-id", "--project", "--daemon", "-d", ...GLOBAL_OPTIONS],
-    stop: ["--project-id", "--project", "--force", ...GLOBAL_OPTIONS],
-    status: ["--project-id", "--project", "--watch", "-w", ...GLOBAL_OPTIONS],
-    run: ["--project-id", "--project", "--watch", "-w", ...GLOBAL_OPTIONS],
-    recover: ["--project-id", "--project", "--dry-run", ...GLOBAL_OPTIONS],
-    logs: [
-        "--project-id",
-        "--project",
-        "--follow",
-        "-f",
-        "--issue",
-        "--run",
-        "--level",
-        ...GLOBAL_OPTIONS,
-    ],
-    project: ["add", "list", "remove", "start", "stop", "switch", "status"],
-    "project:add": [
-        "--non-interactive",
-        "--project",
-        "--workspace-dir",
-        "--assigned-only",
-        ...GLOBAL_OPTIONS,
-    ],
-    "project:list": [...GLOBAL_OPTIONS],
-    "project:remove": [...GLOBAL_OPTIONS],
-    "project:start": [
-        "--project-id",
-        "--project",
-        "--daemon",
-        "-d",
-        ...GLOBAL_OPTIONS,
-    ],
-    "project:stop": ["--project-id", "--project", "--force", ...GLOBAL_OPTIONS],
-    "project:switch": [...GLOBAL_OPTIONS],
-    "project:status": [
-        "--project-id",
-        "--project",
-        "--watch",
-        "-w",
-        ...GLOBAL_OPTIONS,
-    ],
-    repo: ["list", "add", "remove"],
-    "repo:list": [...GLOBAL_OPTIONS],
-    "repo:add": [...GLOBAL_OPTIONS],
-    "repo:remove": [...GLOBAL_OPTIONS],
-    config: ["show", "set", "edit"],
-    "config:show": [...GLOBAL_OPTIONS],
-    "config:set": [...GLOBAL_OPTIONS],
-    "config:edit": [...GLOBAL_OPTIONS],
-};
-function quoteWords(values) {
-    return values.join(" ");
-}
-function renderBashCasePatterns() {
-    return Object.entries(COMMAND_OPTIONS)
-        .map(([key, values]) => {
-        const [command, subcommand] = key.split(":");
-        if (!subcommand) {
-            if (command === "completion") {
-                return `    completion)\n      COMPREPLY=( $(compgen -W "${quoteWords(values)}" -- "$cur") )\n      return\n      ;;`;
-            }
-            if (command === "project" ||
-                command === "repo" ||
-                command === "config") {
-                return `    ${command})\n      COMPREPLY=( $(compgen -W "${quoteWords(values)}" -- "$cur") )\n      return\n      ;;`;
-            }
-            return `    ${command})\n      COMPREPLY=( $(compgen -W "${quoteWords(values)}" -- "$cur") )\n      return\n      ;;`;
-        }
-        return `    ${command}:${subcommand})\n      COMPREPLY=( $(compgen -W "${quoteWords(values)}" -- "$cur") )\n      return\n      ;;`;
-    })
-        .join("\n");
-}
-function renderFishLines() {
-    const lines = GLOBAL_OPTIONS.map((option) => option.startsWith("--")
-        ? `complete -c gh-symphony -f -l ${option.slice(2)}`
-        : `complete -c gh-symphony -f -s ${option.slice(1)}`);
-    for (const command of TOP_LEVEL_COMMANDS) {
-        lines.push(`complete -c gh-symphony -f -n '__fish_use_subcommand' -a '${command}'`);
-    }
-    for (const subcommand of COMMAND_OPTIONS.project ?? []) {
-        lines.push(`complete -c gh-symphony -f -n '__fish_seen_subcommand_from project' -a '${subcommand}'`);
-    }
-    for (const subcommand of COMMAND_OPTIONS.repo ?? []) {
-        lines.push(`complete -c gh-symphony -f -n '__fish_seen_subcommand_from repo' -a '${subcommand}'`);
-    }
-    for (const subcommand of COMMAND_OPTIONS.config ?? []) {
-        lines.push(`complete -c gh-symphony -f -n '__fish_seen_subcommand_from config' -a '${subcommand}'`);
-    }
-    for (const shell of COMMAND_OPTIONS.completion ?? []) {
-        lines.push(`complete -c gh-symphony -f -n '__fish_seen_subcommand_from completion' -a '${shell}'`);
-    }
-    return lines.join("\n");
-}
-export function renderCompletionScript(shell) {
-    if (shell === "fish") {
-        return `${renderFishLines()}\n`;
-    }
-    const bashFunction = `# shellcheck shell=bash
-_gh_symphony_find_context() {
-  GH_SYMPHONY_COMMAND=""
-  GH_SYMPHONY_SUBCOMMAND=""
-
-  local idx=1
-  local token=""
-  local expects_value=0
-
-  while (( idx < COMP_CWORD )); do
-    token="\${COMP_WORDS[idx]}"
-
-    if (( expects_value )); then
-      expects_value=0
-      (( idx++ ))
-      continue
-    fi
-
-    case "\${token}" in
-      ${GLOBAL_OPTIONS_WITH_VALUES.map((option) => `${option}`).join("|")})
-        expects_value=1
-        ;;
-      ${GLOBAL_OPTIONS_WITH_VALUES.map((option) => `${option}=*`).join("|")})
-        ;;
-      ${GLOBAL_OPTIONS.filter((option) => !GLOBAL_OPTIONS_WITH_VALUES.includes(option)).join("|")})
-        ;;
-      -*)
-        ;;
-      *)
-        if [[ -z "\${GH_SYMPHONY_COMMAND}" ]]; then
-          GH_SYMPHONY_COMMAND="\${token}"
-        elif [[ -z "\${GH_SYMPHONY_SUBCOMMAND}" ]]; then
-          GH_SYMPHONY_SUBCOMMAND="\${token}"
-        fi
-        ;;
-    esac
-
-    (( idx++ ))
-  done
-}
-
-_gh_symphony_completion() {
-  local cur prev path
-  cur="\${COMP_WORDS[COMP_CWORD]}"
-  prev=""
-  if (( COMP_CWORD > 0 )); then
-    prev="\${COMP_WORDS[COMP_CWORD-1]}"
-  fi
-
-  _gh_symphony_find_context
-  path="\${GH_SYMPHONY_COMMAND}"
-
-  if [[ -z "\${path}" ]]; then
-    COMPREPLY=( $(compgen -W "${quoteWords(TOP_LEVEL_COMMANDS)} ${quoteWords(GLOBAL_OPTIONS)}" -- "$cur") )
-    return
-  fi
-
-  if [[ "\${path}" == "project" || "\${path}" == "repo" || "\${path}" == "config" || "\${path}" == "completion" ]]; then
-    if [[ -n "\${GH_SYMPHONY_SUBCOMMAND}" ]]; then
-      path="\${path}:\${GH_SYMPHONY_SUBCOMMAND}"
-    fi
-  fi
-
-  case "\${path}" in
-${renderBashCasePatterns()}
-  esac
-}
-`;
-    if (shell === "zsh") {
-        return `autoload -Uz compinit && compinit
-autoload -U +X bashcompinit && bashcompinit
-${bashFunction}complete -F _gh_symphony_completion gh-symphony
-`;
-    }
-    return `${bashFunction}complete -F _gh_symphony_completion gh-symphony
-`;
-}

package/dist/config.d.ts

@@ -1,38 +0,0 @@
-import type { OrchestratorProjectConfig } from "@gh-symphony/core";
-export declare const DEFAULT_CONFIG_DIR: string;
-export declare const CONFIG_FILE = "config.json";
-export declare const DAEMON_PID_FILE = "daemon.pid";
-export declare const ORCHESTRATOR_LOG_FILE = "orchestrator.log";
-export declare const ORCHESTRATOR_PORT_FILE = "port";
-export type CliGlobalConfig = {
-    activeProject: string | null;
-    projects: string[];
-};
-export type CliProjectTrackerSettings = Record<string, string | number | boolean> & {
-    projectId?: string;
-    assignedOnly?: boolean;
-    timeoutMs?: number;
-};
-export type CliProjectConfig = Omit<OrchestratorProjectConfig, "tracker"> & {
-    displayName?: string;
-    tracker: Omit<OrchestratorProjectConfig["tracker"], "settings"> & {
-        settings?: CliProjectTrackerSettings;
-    };
-};
-export type StateRole = "active" | "wait" | "terminal";
-export type StateMapping = {
-    role: StateRole;
-    goal?: string;
-};
-export declare function resolveConfigDir(override?: string): string;
-export declare function configFilePath(configDir: string): string;
-export declare function projectConfigDir(configDir: string, projectId: string): string;
-export declare function projectConfigPath(configDir: string, projectId: string): string;
-export declare function daemonPidPath(configDir: string, projectId: string): string;
-export declare function orchestratorLogPath(configDir: string, projectId: string): string;
-export declare function orchestratorPortPath(configDir: string, projectId: string): string;
-export declare function loadGlobalConfig(configDir: string): Promise<CliGlobalConfig | null>;
-export declare function saveGlobalConfig(configDir: string, config: CliGlobalConfig): Promise<void>;
-export declare function loadProjectConfig(configDir: string, projectId: string): Promise<CliProjectConfig | null>;
-export declare function saveProjectConfig(configDir: string, projectId: string, config: CliProjectConfig): Promise<void>;
-export declare function loadActiveProjectConfig(configDir: string): Promise<CliProjectConfig | null>;