xcode-build-queue 0.1.0

package/dist/cli.js

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const config_js_1 = require("./config.js");
+const daemon_js_1 = require("./daemon.js");
+const enqueue_js_1 = require("./enqueue.js");
+const worktree_js_1 = require("./worktree.js");
+const setup_claude_js_1 = require("./setup-claude.js");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const utils_js_1 = require("./utils.js");
+const program = new commander_1.Command();
+program
+    .name("xbq")
+    .description("Serial build queue for Xcode projects with git worktrees")
+    .version("0.1.0");
+// --- init ---
+program
+    .command("init [repo-path]")
+    .description("Initialize xbq with your main Xcode repo path")
+    .action(async (repoPath) => {
+    await (0, config_js_1.initConfig)(repoPath);
+});
+// --- build ---
+program
+    .command("build")
+    .description("Enqueue a build job")
+    .option("-b, --branch <branch>", "Branch to build (optional in worktree)")
+    .option("-s, --scheme <scheme>", "Xcode scheme")
+    .option("-d, --destination <dest>", "Simulator destination (e.g. 'platform=iOS Simulator,name=iPhone 16,OS=18.0')")
+    .option("--backend <backend>", "Backend: mcp or xcodebuild")
+    .option("--timeout <seconds>", "Timeout in seconds", "1800")
+    .action(async (opts) => {
+    const result = await (0, enqueue_js_1.enqueueAndWait)({
+        action: "build",
+        branch: opts.branch,
+        scheme: opts.scheme,
+        destination: opts.destination,
+        backend: opts.backend,
+        timeout: parseInt(opts.timeout),
+    });
+    printResult(result);
+    process.exit(result.status === "passed" ? 0 : 1);
+});
+// --- test ---
+program
+    .command("test")
+    .description("Enqueue a test job")
+    .option("-b, --branch <branch>", "Branch to test (optional in worktree)")
+    .option("-s, --scheme <scheme>", "Xcode scheme")
+    .option("-t, --test-plan <plan>", "Test plan name")
+    .option("-d, --destination <dest>", "Simulator destination")
+    .option("--backend <backend>", "Backend: mcp or xcodebuild")
+    .option("--timeout <seconds>", "Timeout in seconds", "1800")
+    .action(async (opts) => {
+    const result = await (0, enqueue_js_1.enqueueAndWait)({
+        action: "test",
+        branch: opts.branch,
+        scheme: opts.scheme,
+        testPlan: opts.testPlan,
+        destination: opts.destination,
+        backend: opts.backend,
+        timeout: parseInt(opts.timeout),
+    });
+    printResult(result);
+    process.exit(result.status === "passed" ? 0 : 1);
+});
+// --- daemon ---
+const daemon = program
+    .command("daemon")
+    .description("Manage the build queue daemon");
+daemon
+    .command("start")
+    .description("Start the daemon")
+    .option("-f, --foreground", "Run in foreground")
+    .action(async (opts) => {
+    if (opts.foreground) {
+        await (0, daemon_js_1.startDaemon)({ foreground: true });
+    }
+    else {
+        await (0, daemon_js_1.startDaemon)();
+    }
+});
+daemon
+    .command("stop")
+    .description("Stop the daemon")
+    .action(() => {
+    (0, daemon_js_1.stopDaemon)();
+});
+daemon
+    .command("status")
+    .description("Show daemon and queue status")
+    .action(() => {
+    (0, daemon_js_1.daemonStatus)();
+});
+// --- status ---
+program
+    .command("status")
+    .description("Show queue status")
+    .action(() => {
+    (0, daemon_js_1.daemonStatus)();
+});
+// --- logs ---
+program
+    .command("logs [job-id]")
+    .description("View build logs")
+    .option("-n, --lines <n>", "Number of lines to show", "50")
+    .action((jobId, opts) => {
+    if (jobId) {
+        const logPath = (0, node_path_1.join)(utils_js_1.BQ_LOGS_DIR, `${jobId}.log`);
+        if (!(0, node_fs_1.existsSync)(logPath)) {
+            utils_js_1.log.error(`Log not found: ${logPath}`);
+            process.exit(1);
+        }
+        const content = (0, node_fs_1.readFileSync)(logPath, "utf-8");
+        const lines = content.split("\n");
+        const n = parseInt(opts?.lines || "50");
+        console.log(lines.slice(-n).join("\n"));
+    }
+    else {
+        // List recent results
+        if (!(0, node_fs_1.existsSync)(utils_js_1.BQ_RESULTS_DIR)) {
+            utils_js_1.log.info("No results yet");
+            return;
+        }
+        const files = (0, node_fs_1.readdirSync)(utils_js_1.BQ_RESULTS_DIR)
+            .filter(f => f.endsWith(".json"))
+            .sort()
+            .reverse()
+            .slice(0, 10);
+        if (files.length === 0) {
+            utils_js_1.log.info("No results yet");
+            return;
+        }
+        console.log("Recent jobs:");
+        for (const f of files) {
+            const r = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(utils_js_1.BQ_RESULTS_DIR, f), "utf-8"));
+            const icon = r.status === "passed" ? "\x1b[32m\u2713\x1b[0m" : r.status === "failed" ? "\x1b[31m\u2717\x1b[0m" : "\x1b[33m!\x1b[0m";
+            console.log(`  ${icon} ${r.id}  ${r.summary}  (${r.duration_seconds}s)`);
+        }
+    }
+});
+// --- worktree ---
+const worktree = program
+    .command("worktree")
+    .description("Manage git worktrees for parallel sessions");
+worktree
+    .command("new [name]")
+    .description("Create a new worktree (and optionally start Claude Code)")
+    .option("-c, --claude", "Start Claude Code in the new worktree")
+    .action((name, opts) => {
+    const path = (0, worktree_js_1.createWorktree)(name, { startClaude: opts?.claude });
+    console.log(path);
+});
+worktree
+    .command("list")
+    .description("List all worktrees")
+    .action(() => {
+    (0, worktree_js_1.listWorktrees)();
+});
+worktree
+    .command("clean")
+    .description("Remove merged and stale worktrees")
+    .option("-f, --force", "Force remove all non-main worktrees")
+    .option("-d, --days <n>", "Max age in days for stale worktrees", "7")
+    .action((opts) => {
+    (0, worktree_js_1.cleanWorktrees)({
+        force: opts.force,
+        maxAgeDays: parseInt(opts.days),
+    });
+});
+// --- session (shortcut: worktree new + claude) ---
+program
+    .command("session [name]")
+    .description("Create a worktree and start Claude Code in it")
+    .action((name) => {
+    (0, worktree_js_1.createWorktree)(name, { startClaude: true });
+});
+// --- setup-claude ---
+program
+    .command("setup-claude [dir]")
+    .description("Inject xbq instructions into CLAUDE.md (run in worktree root)")
+    .option("--remove", "Remove xbq instructions from CLAUDE.md")
+    .action((dir, opts) => {
+    if (opts?.remove) {
+        (0, setup_claude_js_1.removeClaude)(dir);
+    }
+    else {
+        (0, setup_claude_js_1.setupClaude)(dir);
+    }
+});
+// --- clean ---
+program
+    .command("clean")
+    .description("Clean old results and logs")
+    .option("-d, --days <n>", "Remove results older than N days", "7")
+    .action((opts) => {
+    const maxAge = parseInt(opts.days) * 86400 * 1000;
+    const now = Date.now();
+    let cleaned = 0;
+    for (const dir of [utils_js_1.BQ_RESULTS_DIR, utils_js_1.BQ_LOGS_DIR]) {
+        if (!(0, node_fs_1.existsSync)(dir))
+            continue;
+        for (const f of (0, node_fs_1.readdirSync)(dir)) {
+            const path = (0, node_path_1.join)(dir, f);
+            const stat = require("node:fs").statSync(path);
+            if (now - stat.mtimeMs > maxAge) {
+                require("node:fs").unlinkSync(path);
+                cleaned++;
+            }
+        }
+    }
+    utils_js_1.log.ok(`Cleaned ${cleaned} old files`);
+});
+function printResult(result) {
+    console.log();
+    if (result.status === "passed") {
+        utils_js_1.log.ok(result.summary);
+    }
+    else if (result.status === "failed") {
+        utils_js_1.log.error(result.summary);
+        if (result.build_errors.length > 0) {
+            console.log("\n  Build errors:");
+            for (const e of result.build_errors.slice(0, 10)) {
+                console.log(`    \x1b[31m\u2022\x1b[0m ${e}`);
+            }
+        }
+        if (result.failures.length > 0) {
+            console.log("\n  Test failures:");
+            for (const f of result.failures.slice(0, 10)) {
+                console.log(`    \x1b[31m\u2022\x1b[0m ${f}`);
+            }
+        }
+    }
+    else {
+        utils_js_1.log.error(result.summary);
+    }
+    if (result.log_path) {
+        console.log(`\n  Full log: xbq logs ${result.id}`);
+    }
+    console.log();
+}
+program.parse();

package/dist/config.d.ts

@@ -0,0 +1,15 @@
+import { type BQConfig } from "./types.js";
+export declare function loadConfig(): BQConfig;
+export declare function saveConfig(config: BQConfig): void;
+export declare function getMainRepo(): string;
+/**
+ * Auto-detect an .xcworkspace in the given directory.
+ * Excludes project.xcworkspace (Xcode internal).
+ */
+export declare function detectWorkspace(repoPath: string): string | null;
+/**
+ * Derive a scheme name from a workspace name.
+ * "Foo.xcworkspace" → "Foo"
+ */
+export declare function detectScheme(_repoPath: string, workspace: string): string;
+export declare function initConfig(repoPath?: string): Promise<void>;

package/dist/config.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.getMainRepo = getMainRepo;
+exports.detectWorkspace = detectWorkspace;
+exports.detectScheme = detectScheme;
+exports.initConfig = initConfig;
+const node_fs_1 = require("node:fs");
+const utils_js_1 = require("./utils.js");
+const types_js_1 = require("./types.js");
+function loadConfig() {
+    if (!(0, node_fs_1.existsSync)(utils_js_1.BQ_CONFIG_PATH)) {
+        return { ...types_js_1.DEFAULT_CONFIG };
+    }
+    const raw = (0, node_fs_1.readFileSync)(utils_js_1.BQ_CONFIG_PATH, "utf-8");
+    return { ...types_js_1.DEFAULT_CONFIG, ...JSON.parse(raw) };
+}
+function saveConfig(config) {
+    (0, utils_js_1.ensureDirs)();
+    (0, node_fs_1.writeFileSync)(utils_js_1.BQ_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+}
+function getMainRepo() {
+    const config = loadConfig();
+    if (!config.main_repo) {
+        utils_js_1.log.error("No main repo configured. Run 'xbq init' first.");
+        process.exit(1);
+    }
+    return (0, utils_js_1.expandPath)(config.main_repo);
+}
+/**
+ * Auto-detect an .xcworkspace in the given directory.
+ * Excludes project.xcworkspace (Xcode internal).
+ */
+function detectWorkspace(repoPath) {
+    try {
+        const entries = (0, node_fs_1.readdirSync)(repoPath).filter((e) => e.endsWith(".xcworkspace") && e !== "project.xcworkspace");
+        return entries.length > 0 ? entries[0] : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Derive a scheme name from a workspace name.
+ * "Foo.xcworkspace" → "Foo"
+ */
+function detectScheme(_repoPath, workspace) {
+    return workspace.replace(".xcworkspace", "");
+}
+async function initConfig(repoPath) {
+    (0, utils_js_1.ensureDirs)();
+    const config = loadConfig();
+    // Resolve repo path
+    let repo = repoPath || config.main_repo;
+    if (!repo) {
+        // Try current directory
+        const cwd = process.cwd();
+        if ((0, node_fs_1.existsSync)(`${cwd}/.git`)) {
+            repo = cwd;
+        }
+        else {
+            utils_js_1.log.error("Please provide the main repo path: xbq init <path>");
+            process.exit(1);
+        }
+    }
+    repo = (0, utils_js_1.expandPath)(repo);
+    // Validate
+    if (!(0, node_fs_1.existsSync)(repo)) {
+        utils_js_1.log.error(`Directory not found: ${repo}`);
+        process.exit(1);
+    }
+    if (!(0, node_fs_1.existsSync)(`${repo}/.git`)) {
+        utils_js_1.log.error(`Not a git repo: ${repo}`);
+        process.exit(1);
+    }
+    config.main_repo = repo;
+    // Auto-detect workspace
+    const workspace = detectWorkspace(repo);
+    if (workspace) {
+        config.workspace = workspace;
+        utils_js_1.log.ok(`Found workspace: ${config.workspace}`);
+    }
+    else {
+        utils_js_1.log.warn("No .xcworkspace found — set workspace manually in ~/.bq/config.json");
+    }
+    // Auto-detect scheme from workspace name
+    if (config.workspace) {
+        config.default_scheme = detectScheme(repo, config.workspace);
+        utils_js_1.log.ok(`Default scheme: ${config.default_scheme}`);
+    }
+    // Detect backend
+    try {
+        (0, utils_js_1.run)("xcrun --find mcpbridge", { quiet: true });
+        config.backend = "mcp";
+        utils_js_1.log.ok("Xcode MCP (mcpbridge) found — default backend: mcp");
+    }
+    catch {
+        config.backend = "xcodebuild";
+        utils_js_1.log.warn("mcpbridge not found — default backend: xcodebuild");
+    }
+    config.xcodebuild_fallback = true;
+    config.git_restore_mtime = true;
+    saveConfig(config);
+    utils_js_1.log.ok(`Configuration saved to ${utils_js_1.BQ_CONFIG_PATH}`);
+    console.log();
+    console.log(`  Main repo:     ${config.main_repo}`);
+    console.log(`  Workspace:     ${config.workspace || "(not detected)"}`);
+    console.log(`  Scheme:        ${config.default_scheme || "(not detected)"}`);
+    console.log(`  Destination:   ${config.default_destination}`);
+    console.log(`  Backend:       ${config.backend}`);
+    console.log();
+    utils_js_1.log.info("Next: run 'xbq daemon start' to start the build queue");
+}

package/dist/daemon.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Start the daemon in foreground (for development) or detect if already running.
+ */
+export declare function startDaemon(opts?: {
+    foreground?: boolean;
+}): Promise<void>;
+export declare function stopDaemon(): void;
+export declare function daemonStatus(): void;

package/dist/daemon.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startDaemon = startDaemon;
+exports.stopDaemon = stopDaemon;
+exports.daemonStatus = daemonStatus;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const executor_js_1 = require("./executor.js");
+const utils_js_1 = require("./utils.js");
+const POLL_INTERVAL_MS = 1000;
+/**
+ * Start the daemon in foreground (for development) or detect if already running.
+ */
+async function startDaemon(opts = {}) {
+    (0, utils_js_1.ensureDirs)();
+    // Check if already running
+    if ((0, node_fs_1.existsSync)(utils_js_1.BQ_PID_FILE)) {
+        const existingPid = parseInt((0, node_fs_1.readFileSync)(utils_js_1.BQ_PID_FILE, "utf-8").trim());
+        if ((0, utils_js_1.isProcessAlive)(existingPid)) {
+            utils_js_1.log.warn(`Daemon already running (PID: ${existingPid})`);
+            return;
+        }
+        // Stale PID file
+        (0, node_fs_1.unlinkSync)(utils_js_1.BQ_PID_FILE);
+    }
+    // Write PID
+    (0, node_fs_1.writeFileSync)(utils_js_1.BQ_PID_FILE, String(process.pid));
+    utils_js_1.log.ok(`Daemon started (PID: ${process.pid})`);
+    // Clean up stale active jobs
+    cleanupActive();
+    // Handle signals for graceful shutdown
+    const shutdown = () => {
+        utils_js_1.log.info("Daemon shutting down...");
+        try {
+            (0, node_fs_1.unlinkSync)(utils_js_1.BQ_PID_FILE);
+        }
+        catch { }
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    // Main loop
+    while (true) {
+        try {
+            const job = pickNextJob();
+            if (job) {
+                await processJob(job);
+            }
+        }
+        catch (err) {
+            utils_js_1.log.error(`Daemon error: ${err}`);
+        }
+        await sleep(POLL_INTERVAL_MS);
+    }
+}
+function stopDaemon() {
+    if (!(0, node_fs_1.existsSync)(utils_js_1.BQ_PID_FILE)) {
+        utils_js_1.log.warn("Daemon is not running");
+        return;
+    }
+    const pid = parseInt((0, node_fs_1.readFileSync)(utils_js_1.BQ_PID_FILE, "utf-8").trim());
+    if ((0, utils_js_1.isProcessAlive)(pid)) {
+        process.kill(pid, "SIGTERM");
+        utils_js_1.log.ok(`Daemon stopped (PID: ${pid})`);
+    }
+    else {
+        utils_js_1.log.warn("Daemon was not running (stale PID file)");
+    }
+    try {
+        (0, node_fs_1.unlinkSync)(utils_js_1.BQ_PID_FILE);
+    }
+    catch { }
+}
+function daemonStatus() {
+    if (!(0, node_fs_1.existsSync)(utils_js_1.BQ_PID_FILE)) {
+        utils_js_1.log.info("Daemon is not running");
+        showQueueStatus();
+        return;
+    }
+    const pid = parseInt((0, node_fs_1.readFileSync)(utils_js_1.BQ_PID_FILE, "utf-8").trim());
+    if ((0, utils_js_1.isProcessAlive)(pid)) {
+        utils_js_1.log.ok(`Daemon is running (PID: ${pid})`);
+    }
+    else {
+        utils_js_1.log.warn("Daemon PID file exists but process is not running");
+        try {
+            (0, node_fs_1.unlinkSync)(utils_js_1.BQ_PID_FILE);
+        }
+        catch { }
+    }
+    showQueueStatus();
+}
+function showQueueStatus() {
+    const queued = (0, node_fs_1.existsSync)(utils_js_1.BQ_QUEUE_DIR) ? (0, node_fs_1.readdirSync)(utils_js_1.BQ_QUEUE_DIR).filter(f => f.endsWith(".json")) : [];
+    const active = (0, node_fs_1.existsSync)(utils_js_1.BQ_ACTIVE_DIR) ? (0, node_fs_1.readdirSync)(utils_js_1.BQ_ACTIVE_DIR).filter(f => f.endsWith(".json")) : [];
+    console.log();
+    if (active.length > 0) {
+        for (const f of active) {
+            const job = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(utils_js_1.BQ_ACTIVE_DIR, f), "utf-8"));
+            const source = job.snapshot_sha ? `snapshot ${job.snapshot_sha.slice(0, 8)}` : `branch ${job.branch}`;
+            utils_js_1.log.status(`Running: ${job.action} on ${source} (${job.id})`);
+        }
+    }
+    if (queued.length > 0) {
+        utils_js_1.log.info(`Queued: ${queued.length} job(s)`);
+        for (const f of queued.sort()) {
+            const job = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(utils_js_1.BQ_QUEUE_DIR, f), "utf-8"));
+            const source = job.snapshot_sha ? `snapshot ${job.snapshot_sha.slice(0, 8)}` : `branch ${job.branch}`;
+            console.log(`  - ${job.action} on ${source} (${job.id})`);
+        }
+    }
+    else if (active.length === 0) {
+        utils_js_1.log.info("Queue is empty");
+    }
+}
+/**
+ * Pick the oldest job from the queue (FIFO).
+ */
+function pickNextJob() {
+    if (!(0, node_fs_1.existsSync)(utils_js_1.BQ_QUEUE_DIR))
+        return null;
+    const files = (0, node_fs_1.readdirSync)(utils_js_1.BQ_QUEUE_DIR)
+        .filter(f => f.endsWith(".json"))
+        .sort(); // Lexicographic = chronological since IDs are timestamp-prefixed
+    if (files.length === 0)
+        return null;
+    const file = files[0];
+    const jobPath = (0, node_path_1.join)(utils_js_1.BQ_QUEUE_DIR, file);
+    const activePath = (0, node_path_1.join)(utils_js_1.BQ_ACTIVE_DIR, file);
+    // Move to active
+    const job = JSON.parse((0, node_fs_1.readFileSync)(jobPath, "utf-8"));
+    (0, node_fs_1.renameSync)(jobPath, activePath);
+    return job;
+}
+/**
+ * Process a job and write the result.
+ */
+async function processJob(job) {
+    utils_js_1.log.info(`Processing job: ${job.id} (${job.action} on ${job.branch})`);
+    const activeFile = (0, node_path_1.join)(utils_js_1.BQ_ACTIVE_DIR, `${job.id}.json`);
+    let result;
+    try {
+        result = await (0, executor_js_1.executeJob)(job);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        result = {
+            id: job.id,
+            status: "error",
+            duration_seconds: 0,
+            summary: message,
+            failures: [],
+            build_errors: [message],
+            warnings: [],
+            log_path: "",
+        };
+    }
+    // Write result
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(utils_js_1.BQ_RESULTS_DIR, `${job.id}.json`), JSON.stringify(result, null, 2) + "\n");
+    // Remove from active
+    try {
+        (0, node_fs_1.unlinkSync)(activeFile);
+    }
+    catch { }
+    if (result.status === "passed") {
+        utils_js_1.log.ok(`Job ${job.id}: ${result.summary} (${result.duration_seconds}s)`);
+    }
+    else {
+        utils_js_1.log.error(`Job ${job.id}: ${result.summary} (${result.duration_seconds}s)`);
+    }
+}
+/**
+ * Clean up stale active jobs (from crashed daemon).
+ */
+function cleanupActive() {
+    if (!(0, node_fs_1.existsSync)(utils_js_1.BQ_ACTIVE_DIR))
+        return;
+    const files = (0, node_fs_1.readdirSync)(utils_js_1.BQ_ACTIVE_DIR).filter(f => f.endsWith(".json"));
+    for (const f of files) {
+        utils_js_1.log.warn(`Requeuing stale active job: ${f}`);
+        (0, node_fs_1.renameSync)((0, node_path_1.join)(utils_js_1.BQ_ACTIVE_DIR, f), (0, node_path_1.join)(utils_js_1.BQ_QUEUE_DIR, f));
+    }
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/dist/enqueue.d.ts

@@ -0,0 +1,14 @@
+import { type JobResult } from "./types.js";
+export interface EnqueueOptions {
+    action: "build" | "test";
+    branch?: string;
+    scheme?: string;
+    testPlan?: string;
+    destination?: string;
+    backend?: "mcp" | "xcodebuild";
+    timeout?: number;
+}
+/**
+ * Enqueue a job, wait for result, and return it.
+ */
+export declare function enqueueAndWait(opts: EnqueueOptions): Promise<JobResult>;