@gh-symphony/cli 0.0.12 → 0.0.14

package/README.md

@@ -62,6 +62,38 @@ You can further customize the agent's behavior by editing `WORKFLOW.md` — this
 
 > Currently supported runtimes: **Codex**, **Claude Code**
 
+### Project `.env` Mapping
+
+If your hooks or worker runs need staging hosts, database URLs, Playwright base URLs, or other runtime-only values, store them in the project runtime directory instead of hardcoding them in `WORKFLOW.md`.
+
+1. Find the project id from `gh-symphony project list`.
+2. Create the runtime env file:
+
+```bash
+mkdir -p ~/.gh-symphony/projects/<project-id>
+cat > ~/.gh-symphony/projects/<project-id>/.env <<'EOF'
+STAGING_API_HOST=https://staging.example.com
+DATABASE_URL=postgres://user:pass@staging-db:5432/app
+PLAYWRIGHT_BASE_URL=http://localhost:3000
+EOF
+```
+
+3. Reference those variables from `WORKFLOW.md` hooks or repository setup scripts:
+
+```yaml
+hooks:
+  after_create: 'echo "API_HOST=$STAGING_API_HOST" >> .env.development'
+  before_run: 'echo "BASE_URL=$PLAYWRIGHT_BASE_URL" > playwright.env'
+```
+
+Env precedence during hook execution and worker spawn is:
+
+- `project .env` as the base
+- system env as the override layer
+- Symphony context vars such as `SYMPHONY_*` as the highest-priority layer
+
+If you use `--config <dir>`, replace `~/.gh-symphony` with that directory.
+
 ## 3. Set Orchestrator Runner (Project)
 
 On the machine where you want the orchestrator to run, register a project:

package/dist/config.d.ts

@@ -8,9 +8,10 @@ export type CliGlobalConfig = {
     activeProject: string | null;
     projects: string[];
 };
-export type CliProjectTrackerSettings = Record<string, string | boolean> & {
+export type CliProjectTrackerSettings = Record<string, string | number | boolean> & {
     projectId?: string;
     assignedOnly?: boolean;
+    timeoutMs?: number;
 };
 export type CliProjectConfig = Omit<OrchestratorProjectConfig, "tracker"> & {
     displayName?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gh-symphony/cli",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "license": "MIT",
   "author": "hojinzs",
   "description": "Interactive CLI for GitHub Symphony orchestration",
@@ -37,10 +37,10 @@
   "dependencies": {
     "@clack/prompts": "^0.9.1",
     "commander": "^14.0.1",
-    "@gh-symphony/core": "0.0.12",
-    "@gh-symphony/tracker-github": "0.0.12",
-    "@gh-symphony/worker": "0.0.12",
-    "@gh-symphony/orchestrator": "0.0.12"
+    "@gh-symphony/core": "0.0.14",
+    "@gh-symphony/tracker-github": "0.0.14",
+    "@gh-symphony/orchestrator": "0.0.14",
+    "@gh-symphony/worker": "0.0.14"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",

package/dist/commands/parse-cli-args.d.ts

@@ -1,6 +0,0 @@
-import { parseArgs, type ParseArgsOptionsConfig } from "node:util";
-type ParseCliArgsResult = ReturnType<typeof parseArgs> | {
-    error: string;
-};
-export declare function parseCliArgs(args: string[], options: ParseArgsOptionsConfig): ParseCliArgsResult;
-export {};

package/dist/commands/parse-cli-args.js

@@ -1,20 +0,0 @@
-import { parseArgs } from "node:util";
-export function parseCliArgs(args, options) {
-    try {
-        return parseArgs({
-            args,
-            options,
-            allowPositionals: false,
-            strict: true,
-        });
-    }
-    catch (error) {
-        return { error: formatParseArgsError(error) };
-    }
-}
-function formatParseArgsError(error) {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    return "Invalid arguments";
-}

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

@@ -1,348 +0,0 @@
-import * as p from "@clack/prompts";
-import { createClient, validateToken, checkRequiredScopes, listUserProjects, getProjectDetail, GitHubScopeError, } from "../github/client.js";
-import { ensureGhAuth, getGhToken, GhAuthError } from "../github/gh-auth.js";
-import { loadGlobalConfig, saveGlobalConfig, loadTenantConfig, tenantConfigDir, } from "../config.js";
-import { writeConfig, generateTenantId, abortIfCancelled } from "./init.js";
-// ── Scope error display ───────────────────────────────────────────────────────
-const KNOWN_REQUIRED_SCOPES = ["repo", "read:org", "project"];
-function displayScopeError(error, retryCommand) {
-    const plural = error.requiredScopes.length === 1 ? "" : "s";
-    p.log.error(`Token is missing required scope${plural}: ${error.requiredScopes.join(", ")}`);
-    const currentSet = new Set(error.currentScopes.map((s) => s.toLowerCase()));
-    const scopesToAdd = KNOWN_REQUIRED_SCOPES.filter((s) => !currentSet.has(s));
-    const scopeArg = scopesToAdd.length > 0
-        ? scopesToAdd.join(",")
-        : error.requiredScopes.join(",");
-    p.note(`gh auth refresh --scopes ${scopeArg}\n\nThen re-run: ${retryCommand}`, "Fix missing scope");
-}
-function parseTenantAddFlags(args) {
-    const flags = { nonInteractive: false, assignedOnly: false };
-    for (let i = 0; i < args.length; i += 1) {
-        const arg = args[i];
-        const next = args[i + 1];
-        switch (arg) {
-            case "--non-interactive":
-                flags.nonInteractive = true;
-                break;
-            case "--project":
-                flags.project = next;
-                i += 1;
-                break;
-            case "--workspace-dir":
-                flags.workspaceDir = next;
-                i += 1;
-                break;
-            case "--assigned-only":
-                flags.assignedOnly = true;
-                break;
-        }
-    }
-    return flags;
-}
-// ── Tenant command handler ────────────────────────────────────────────────────
-const handler = async (args, options) => {
-    const [subcommand, ...rest] = args;
-    switch (subcommand) {
-        case "add":
-            await tenantAdd(rest, options);
-            return;
-        case "list":
-            await tenantList(options);
-            return;
-        case "remove":
-            await tenantRemove(rest, options);
-            return;
-        default:
-            process.stdout.write("Usage: gh-symphony tenant <add|list|remove>\n");
-    }
-};
-export default handler;
-// ── tenant add ───────────────────────────────────────────────────────────────
-async function tenantAdd(args, options) {
-    const flags = parseTenantAddFlags(args);
-    if (flags.nonInteractive) {
-        await tenantAddNonInteractive(flags, options);
-        return;
-    }
-    await tenantAddInteractive(options);
-}
-// ── Non-interactive tenant add ───────────────────────────────────────────────
-async function tenantAddNonInteractive(flags, options) {
-    let token;
-    try {
-        token = getGhToken();
-    }
-    catch {
-        process.stderr.write("Error: GitHub token not found. Run 'gh auth login --scopes repo,read:org,project' or set GITHUB_GRAPHQL_TOKEN.\n");
-        process.exitCode = 1;
-        return;
-    }
-    const client = createClient(token);
-    // Validate token
-    let viewer;
-    try {
-        viewer = await validateToken(client);
-    }
-    catch {
-        process.stderr.write("Error: Invalid GitHub token.\n");
-        process.exitCode = 1;
-        return;
-    }
-    const scopeCheck = checkRequiredScopes(viewer.scopes);
-    if (!scopeCheck.valid) {
-        process.stderr.write(`Error: Missing required PAT scopes: ${scopeCheck.missing.join(", ")}\n`);
-        process.exitCode = 1;
-        return;
-    }
-    // Find project
-    const projects = await listUserProjects(client);
-    let project;
-    if (flags.project) {
-        const match = projects.find((p) => p.id === flags.project || p.url === flags.project);
-        if (!match) {
-            process.stderr.write(`Error: Project not found: ${flags.project}\n`);
-            process.exitCode = 1;
-            return;
-        }
-        project = await getProjectDetail(client, match.id);
-    }
-    else if (projects.length === 1) {
-        project = await getProjectDetail(client, projects[0].id);
-    }
-    else {
-        process.stderr.write("Error: --project is required when multiple projects exist.\n");
-        process.exitCode = 1;
-        return;
-    }
-    const tenantId = generateTenantId(project.title, project.id);
-    const workspaceDir = flags.workspaceDir ?? `${options.configDir}/workspaces`;
-    await writeConfig(options.configDir, {
-        tenantId,
-        project,
-        repos: project.linkedRepositories,
-        workspaceDir,
-        assignedOnly: flags.assignedOnly,
-    });
-    if (options.json) {
-        process.stdout.write(JSON.stringify({ tenantId, status: "created" }) + "\n");
-    }
-    else {
-        process.stdout.write(`Tenant created: ${tenantId}\n`);
-        process.stdout.write(`Run 'gh-symphony start' to begin orchestration.\n`);
-    }
-}
-// ── Interactive tenant add ───────────────────────────────────────────────────
-async function tenantAddInteractive(options) {
-    p.intro("gh-symphony — Tenant Setup");
-    // Detect existing config
-    const existingConfig = await loadGlobalConfig(options.configDir);
-    if (existingConfig) {
-        const action = await abortIfCancelled(p.select({
-            message: "Existing configuration detected. What would you like to do?",
-            options: [
-                { value: "add", label: "Add a new tenant" },
-                { value: "overwrite", label: "Start fresh (overwrite)" },
-            ],
-        }));
-        if (action === "overwrite") {
-            // Continue with fresh setup — will overwrite config
-        }
-        // "add" continues to create a new tenant alongside existing ones
-    }
-    // ── Step 1: gh CLI authentication ─────────────────────────────────────────────
-    const s1 = p.spinner();
-    s1.start("Checking gh CLI authentication...");
-    let login;
-    let client;
-    try {
-        const { login: ghLogin, token } = ensureGhAuth();
-        login = ghLogin;
-        client = createClient(token);
-        s1.stop(`Authenticated as ${login}`);
-    }
-    catch (error) {
-        s1.stop("Authentication failed.");
-        if (error instanceof GhAuthError) {
-            if (error.code === "not_installed") {
-                p.log.error("gh CLI가 설치되어 있지 않습니다. https://cli.github.com 에서 설치하세요.");
-            }
-            else if (error.code === "not_authenticated") {
-                p.log.error("gh auth login --scopes repo,read:org,project 를 실행하세요.");
-            }
-            else if (error.code === "missing_scopes") {
-                p.log.error("gh auth refresh --scopes repo,read:org,project 를 실행하세요.");
-            }
-            else {
-                p.log.error(error.message);
-            }
-        }
-        else {
-            p.log.error(error instanceof Error ? error.message : "Unknown error");
-        }
-        process.exitCode = 1;
-        return;
-    }
-    // ── Step 2: Project selection ───────────────────────────────────────────────
-    const s2 = p.spinner();
-    s2.start("Loading projects...");
-    let projects;
-    try {
-        projects = await listUserProjects(client);
-        s2.stop(`Found ${projects.length} project${projects.length === 1 ? "" : "s"}`);
-    }
-    catch (error) {
-        s2.stop("Failed to load projects.");
-        if (error instanceof GitHubScopeError) {
-            displayScopeError(error, "gh-symphony tenant add");
-        }
-        else {
-            p.log.error(error instanceof Error ? error.message : "Unknown error");
-        }
-        process.exitCode = 1;
-        return;
-    }
-    if (projects.length === 0) {
-        p.log.error("No GitHub Projects found. Create a project at https://github.com/orgs/YOUR_ORG/projects and re-run.");
-        process.exitCode = 1;
-        return;
-    }
-    const selectedProjectId = await abortIfCancelled(p.select({
-        message: "Step 1/4 — Select a GitHub Project:",
-        options: projects.map((proj) => ({
-            value: proj.id,
-            label: `${proj.owner.login}/${proj.title}`,
-            hint: `${proj.openItemCount} items`,
-        })),
-        maxItems: 15,
-    }));
-    const s2d = p.spinner();
-    s2d.start("Loading project details...");
-    let projectDetail;
-    try {
-        projectDetail = await getProjectDetail(client, selectedProjectId);
-        s2d.stop(`Loaded: ${projectDetail.title}`);
-    }
-    catch (error) {
-        s2d.stop("Failed to load project details.");
-        p.log.error(error instanceof Error ? error.message : "Unknown error");
-        process.exitCode = 1;
-        return;
-    }
-    // ── Step 2: Repository selection ────────────────────────────────────────────
-    if (projectDetail.linkedRepositories.length === 0) {
-        p.log.warn("No linked repositories found in this project. Add issues from repositories to the project first.");
-        process.exitCode = 1;
-        return;
-    }
-    const selectedRepos = await abortIfCancelled(p.multiselect({
-        message: "Step 2/4 — Select repositories to orchestrate:",
-        options: projectDetail.linkedRepositories.map((repo) => ({
-            value: repo,
-            label: `${repo.owner}/${repo.name}`,
-        })),
-        required: true,
-    }));
-    // ── Step 3: Assignment filter ────────────────────────────────────────────────
-    const assignedOnly = await abortIfCancelled(p.confirm({
-        message: "Step 3/4 — Only process issues assigned to the authenticated GitHub user?",
-        initialValue: false,
-    }));
-    const workspaceDir = await abortIfCancelled(p.text({
-        message: "Step 4/4 — Workspace root directory:",
-        placeholder: `${options.configDir}/workspaces`,
-        defaultValue: `${options.configDir}/workspaces`,
-        validate(value) {
-            return value.trim().length > 0
-                ? undefined
-                : "Workspace directory is required.";
-        },
-    }));
-    // ── Confirmation ─────────────────────────────────────────────────────────────
-    p.note([
-        `User:       ${login}`,
-        `Project:    ${projectDetail.title}`,
-        `Repos:      ${selectedRepos.map((r) => `${r.owner}/${r.name}`).join(", ")}`,
-        `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;
-    }
-    // ── Write config files ────────────────────────────────────────────────────────
-    const tenantId = generateTenantId(projectDetail.title, projectDetail.id);
-    const s6 = p.spinner();
-    s6.start("Writing configuration...");
-    try {
-        await writeConfig(options.configDir, {
-            tenantId,
-            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(`Tenant "${tenantId}" created!\n  Run 'gh-symphony start' to begin orchestration.`);
-}
-// ── tenant list ───────────────────────────────────────────────────────────────
-async function tenantList(options) {
-    const global = await loadGlobalConfig(options.configDir);
-    if (!global?.tenants?.length) {
-        process.stdout.write("No tenants configured.\n");
-        return;
-    }
-    process.stdout.write("Configured tenants:\n");
-    const configs = await Promise.all(global.tenants.map((id) => loadTenantConfig(options.configDir, id)));
-    for (let i = 0; i < global.tenants.length; i++) {
-        const tenantId = global.tenants[i];
-        const config = configs[i];
-        const active = global.activeTenant === tenantId ? " (active)" : "";
-        const slug = config?.slug ?? tenantId;
-        process.stdout.write(`  ${slug}${active}\n`);
-    }
-}
-// ── tenant remove ─────────────────────────────────────────────────────────────
-async function tenantRemove(args, options) {
-    const tenantId = args[0];
-    if (!tenantId) {
-        process.stderr.write("Usage: gh-symphony tenant remove <tenant-id>\n");
-        process.exitCode = 1;
-        return;
-    }
-    const global = await loadGlobalConfig(options.configDir);
-    if (!global) {
-        process.stderr.write("No configuration found.\n");
-        process.exitCode = 1;
-        return;
-    }
-    const updatedTenants = (global.tenants ?? []).filter((t) => t !== tenantId);
-    if (updatedTenants.length === global.tenants.length) {
-        process.stderr.write(`Tenant "${tenantId}" not found.\n`);
-        process.exitCode = 1;
-        return;
-    }
-    const updatedConfig = {
-        ...global,
-        tenants: updatedTenants,
-        activeTenant: global.activeTenant === tenantId ? null : global.activeTenant,
-    };
-    await saveGlobalConfig(options.configDir, updatedConfig);
-    const { rm } = await import("node:fs/promises");
-    const dir = tenantConfigDir(options.configDir, tenantId);
-    try {
-        await rm(dir, { recursive: true, force: true });
-    }
-    catch {
-        // Directory may not exist
-    }
-    process.stdout.write(`Tenant "${tenantId}" removed.\n`);
-}