@uluops/setup 0.6.5 → 0.8.1

package/dist/commands/setup.js

@@ -2,92 +2,253 @@ import chalk from "chalk";
 import { join } from "node:path";
 import { loadManifest, saveManifest, } from "../lib/manifest.js";
 import { findProjectRoot } from "../lib/paths.js";
-import { info, printSetupSummary } from "../lib/display.js";
+import { info, printSetupSummary, warn } from "../lib/display.js";
 import { getVersion } from "../lib/version.js";
 import { getProfile } from "../harnesses/index.js";
-import { initContext, checkConflicts, configureMcpStep, installAgentsDefs, installCommandsDefs, configureMetricsStep, configureCliStep, runHealthCheck, configureShell, } from "./helpers.js";
+import { acquireInstallLock, } from "../lib/install-lock.js";
+import { initContext, checkConflicts, configureMcpStep, installAgentsDefs, installCommandsDefs, installSkillsDefs, configureMetricsStep, configureCliStep, configureAgentMetricsCliStep, runHealthCheck, configureShell, } from "./helpers.js";
+import { ConflictRejectedError } from "./errors.js";
+import { classifyExit, } from "./per-harness.js";
 export async function runSetup(opts) {
+    if (opts.harnesses.length === 0) {
+        info(chalk.dim("Nothing to install — re-run with at least one harness selected.\n"));
+        return;
+    }
     const version = await getVersion();
-    const profile = getProfile(opts.harness);
+    // Resolve every harness up front so a typo fails fast before any state
+    // is touched. getProfile throws HarnessNotTestedError or a friendly
+    // unknown-name error; the top-level catch in cli.ts surfaces them.
+    const profiles = opts.harnesses.map((name) => getProfile(name));
     console.log();
     console.log(`  ${chalk.dim("⟨u⟩")} ${chalk.cyan.bold("ulu")}${chalk.bold("·ops")}`);
     console.log(`      ${chalk.dim("operating intelligence as infrastructure")}`);
     console.log();
-    console.log(`  Setup v${version} — ${chalk.bold(profile.displayName)}`);
+    const targetSummary = profiles.length === 1
+        ? profiles[0].displayName
+        : `${profiles.length} harnesses (${profiles.map((p) => p.displayName).join(", ")})`;
+    console.log(`  Setup v${version} — ${chalk.bold(targetSummary)}`);
     console.log();
     if (opts.dryRun) {
         info(chalk.dim("(dry run — no changes will be made)\n"));
     }
+    // === Once-per-run: BEFORE the per-harness loop ===
     const { env, apiKey } = await initContext(opts);
     console.log();
-    // Load existing manifest for update detection
-    const existingManifest = await loadManifest();
-    const existingHarness = existingManifest?.harnesses[profile.name];
-    if (existingManifest && existingManifest.version !== version) {
-        info(`Updating ${chalk.dim(existingManifest.version)} → ${chalk.green(version)}`);
-        console.log();
-    }
-    else if (existingHarness) {
-        info(chalk.dim(`Already at v${version} — checking for changes`));
-        console.log();
-    }
-    // Check for conflicts on first install for this harness
-    if (!existingHarness && !opts.yes && !opts.dryRun) {
-        await checkConflicts(profile, opts.localDefs);
-    }
-    const mcpResult = await configureMcpStep(profile, apiKey, opts);
-    const agentsResult = await installAgentsDefs(profile, opts, existingHarness?.agents);
-    const commandsResult = await installCommandsDefs(profile, opts, existingHarness?.commands);
-    const metricsResult = await configureMetricsStep(profile, opts);
-    const cliResult = await configureCliStep({
-        withCli: opts.withCli,
-        cli: opts.cli,
-        yes: opts.yes,
-        apiKey: opts.apiKey,
-        dryRun: opts.dryRun,
-    });
-    await runHealthCheck(opts);
-    const shellModified = await configureShell(env, apiKey, opts);
-    // Save manifest
+    // Acquire the install lock before touching any shared state. Skipped on
+    // dry-run (read-only). The lock excludes a second concurrent uluops-setup
+    // from racing the manifest / MCP config / shell-profile / settings.json
+    // read-merge-write windows. Held across the entire multi-harness loop —
+    // concurrent multi-harness installs from separate processes serialize
+    // (spec §10.6).
+    let lock = null;
     if (!opts.dryRun) {
-        const now = new Date().toISOString();
-        const harnessEntry = {
-            installedAt: now,
-            setupVersion: version,
-            mcpScope: opts.scope,
-            mcpConfigPath: mcpResult.configPath,
-            defsScope: opts.localDefs ? "local" : "global",
-            defsPath: opts.localDefs
-                ? join(await findProjectRoot(), "uluops")
-                : profile.paths.home,
-            agents: agentsResult.files,
-            commands: commandsResult.files,
-            hooksInstalled: metricsResult.hookConfigured,
-            hooksInstalledVersion: metricsResult.hooksInstalledVersion,
-        };
-        const manifest = existingManifest ?? {
-            version,
-            installedAt: now,
-            shellModified: false,
-            harnesses: {},
-        };
-        manifest.version = version;
-        manifest.installedAt = now;
-        manifest.shellModified = shellModified || manifest.shellModified;
-        manifest.harnesses[profile.name] = harnessEntry;
-        // Only flip cliInstalled to true when WE installed it (not when user-installed).
-        // Once true, persist across re-runs so uninstall remains symmetric — until the
-        // user explicitly removes it with --no-cli + uninstall, this manifest owns it.
-        if (cliResult && cliResult.installed && !cliResult.alreadyPresent) {
-            manifest.cliInstalled = true;
-            manifest.cliInstalledVersion = cliResult.version;
+        lock = await acquireInstallLock();
+    }
+    try {
+        const existingManifest = await loadManifest();
+        if (existingManifest && existingManifest.version !== version) {
+            info(`Updating ${chalk.dim(existingManifest.version)} → ${chalk.green(version)}`);
+            console.log();
         }
-        await saveManifest(manifest);
+        // === Per-harness loop ===
+        const perHarnessResults = [];
+        for (const profile of profiles) {
+            const harnessName = profile.name;
+            // Read each harness's own slice of prior state every iteration. Never
+            // reuse a single existingHarness across iterations — installAgents/
+            // Commands/Skills consume prev lists from existingHarness for drift
+            // detection; using the wrong harness's prev list silently orphans
+            // files (spec §7.6.1 per-iteration state isolation).
+            const existingHarness = existingManifest?.harnesses[harnessName];
+            console.log(chalk.dim(`▸ ${profile.displayName}`));
+            if (existingHarness && !existingHarness.partial) {
+                info(chalk.dim(`  Already installed at v${version} — checking for changes`));
+            }
+            // First-install conflict check, OR re-run after a partial install
+            // (the user never confirmed the conflict on the failing run, so we
+            // re-prompt — spec §7.6.5).
+            const needsConflictCheck = !opts.yes &&
+                !opts.dryRun &&
+                (!existingHarness || existingHarness.partial != null);
+            if (needsConflictCheck) {
+                try {
+                    await checkConflicts(profile, opts.localDefs);
+                }
+                catch (err) {
+                    if (err instanceof ConflictRejectedError) {
+                        perHarnessResults.push({
+                            harnessName,
+                            profile,
+                            status: "declined",
+                            error: err.message,
+                        });
+                        warn(`[${harnessName}] skipped (user declined conflict) — continuing with remaining harnesses`);
+                        console.log();
+                        continue;
+                    }
+                    throw err;
+                }
+            }
+            // MCP must succeed for a manifest entry to exist (the entry depends
+            // on mcpResult.configPath). An MCP throw means no manifest entry —
+            // harness marked failed and the loop continues to siblings.
+            let mcpResult;
+            try {
+                mcpResult = await configureMcpStep(profile, apiKey, opts);
+            }
+            catch (err) {
+                perHarnessResults.push({
+                    harnessName,
+                    profile,
+                    status: "failed",
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                warn(`[${harnessName}] MCP configuration failed — continuing with remaining harnesses`);
+                console.log();
+                continue;
+            }
+            // Subsequent steps may throw on pre-loop work (mkdir EACCES, etc.).
+            // If they do, build a partial manifest entry naming the failed step
+            // (spec §7.6.2 Case B). The per-file failures[] arrays on each
+            // result are surfaced inside the helper's warn() calls.
+            let agentsResult;
+            let commandsResult;
+            let skillsResult;
+            let metricsResult;
+            let failedStep = null;
+            let failedError;
+            try {
+                agentsResult = await installAgentsDefs(profile, opts, existingHarness?.agents);
+                commandsResult = await installCommandsDefs(profile, opts, existingHarness?.commands);
+                skillsResult = await installSkillsDefs(profile, opts, existingHarness?.skills);
+                metricsResult = await configureMetricsStep(profile, opts);
+            }
+            catch (err) {
+                failedError = err instanceof Error ? err.message : String(err);
+                failedStep = !agentsResult
+                    ? "agents"
+                    : !commandsResult
+                        ? "commands"
+                        : !skillsResult
+                            ? "skills"
+                            : "metrics";
+                warn(`[${harnessName}] ${failedStep} step failed: ${failedError} — recording partial state`);
+            }
+            perHarnessResults.push({
+                harnessName,
+                profile,
+                status: failedStep ? "failed" : "ok",
+                error: failedError,
+                mcpResult,
+                agentsResult,
+                commandsResult,
+                skillsResult,
+                metricsResult,
+                partial: failedStep,
+            });
+            console.log();
+        }
+        // === Once-per-run: AFTER the per-harness loop ===
+        // Global @uluops/cli install — single prompt, single install across the
+        // whole run regardless of harness count.
+        const cliResult = await configureCliStep({
+            withCli: opts.withCli,
+            cli: opts.cli,
+            yes: opts.yes,
+            apiKey: opts.apiKey,
+            dryRun: opts.dryRun,
+        });
+        // Agent-metrics CLI install — gated on AT LEAST ONE harness having
+        // successfully configured the hook. Aggregate gate replaces the
+        // per-iteration gate from the single-harness version. Without this,
+        // a multi-harness run where only one harness supports hooks (e.g.,
+        // Claude Code among Codex/Gemini siblings) would never prompt for the
+        // agent-metrics CLI (spec §7.6.2 aggregation).
+        const anyHookConfigured = perHarnessResults.some((r) => r.status === "ok" && r.metricsResult?.hookConfigured);
+        const agentMetricsCliResult = anyHookConfigured
+            ? await configureAgentMetricsCliStep({
+                withAgentMetricsCli: opts.withAgentMetricsCli,
+                agentMetricsCli: opts.agentMetricsCli,
+                yes: opts.yes,
+                apiKey: opts.apiKey,
+                dryRun: opts.dryRun,
+            })
+            : null;
+        await runHealthCheck(opts);
+        const shellModified = await configureShell(env, apiKey, opts);
+        // Save manifest ONCE at end, aggregating every successful or partial
+        // harness entry. Declined harnesses and pre-MCP failures land no entry.
+        if (!opts.dryRun) {
+            const now = new Date().toISOString();
+            const manifest = existingManifest ?? {
+                version,
+                installedAt: now,
+                shellModified: false,
+                harnesses: {},
+            };
+            manifest.version = version;
+            manifest.installedAt = now;
+            manifest.shellModified = shellModified || manifest.shellModified;
+            for (const r of perHarnessResults) {
+                if (!r.mcpResult)
+                    continue; // no MCP success → no entry
+                const harnessEntry = {
+                    installedAt: now,
+                    setupVersion: version,
+                    mcpScope: opts.scope,
+                    mcpConfigPath: r.mcpResult.configPath,
+                    defsScope: opts.localDefs ? "local" : "global",
+                    defsPath: opts.localDefs
+                        ? join(await findProjectRoot(), "uluops")
+                        : r.profile.paths.home,
+                    agents: r.agentsResult?.files ?? [],
+                    commands: r.commandsResult?.files ?? [],
+                    skills: r.skillsResult?.files ?? [],
+                    hooksInstalled: r.metricsResult?.hookConfigured ?? false,
+                    hooksInstalledVersion: r.metricsResult?.hooksInstalledVersion ?? null,
+                    partial: r.partial ?? null,
+                };
+                manifest.harnesses[r.harnessName] = harnessEntry;
+            }
+            // Same ownership rule as before — only manifest a global install we
+            // performed ourselves (not user-installed).
+            if (cliResult && cliResult.installed && !cliResult.alreadyPresent) {
+                manifest.cliInstalled = true;
+                manifest.cliInstalledVersion = cliResult.version;
+            }
+            if (agentMetricsCliResult &&
+                agentMetricsCliResult.installed &&
+                !agentMetricsCliResult.alreadyPresent) {
+                manifest.agentMetricsCliInstalled = true;
+                manifest.agentMetricsCliInstalledVersion =
+                    agentMetricsCliResult.version;
+            }
+            // Only save the manifest if it has at least one harness entry — the
+            // isNewManifest loader rejects empty-harnesses manifests, and saving
+            // one would write an unloadable file on every all-declined run.
+            if (Object.keys(manifest.harnesses).length > 0) {
+                await saveManifest(manifest);
+            }
+        }
+        // === Summary ===
+        // Single rendering call producing the full multi-harness block with
+        // per-harness status icons, partial markers, re-run hints, and the
+        // aggregate counts in the header. Single-harness path preserves
+        // today's Setup-complete banner format inside the same function.
+        await printSetupSummary({
+            results: perHarnessResults,
+            apiKey,
+        });
+        // Exit-code classifier (spec §7.5 4-tier table). One call, one place.
+        // Empty perHarnessResults already short-circuited above with the
+        // "nothing to install" message; classifyExit handles defense-in-depth.
+        const exitCode = classifyExit(perHarnessResults);
+        if (exitCode !== 0) {
+            process.exit(exitCode);
+        }
+    }
+    finally {
+        if (lock)
+            await lock.release();
     }
-    await printSetupSummary({
-        profile,
-        agentCount: agentsResult.files.length,
-        commandCount: commandsResult.files.length,
-        apiKey,
-    });
 }

package/dist/commands/uninstall-filter.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Filter parser for `runUninstall`. Mirrors the install-side selection
+ * syntax (`--harness all`, comma-split, `--all-detected` synonym, conflict
+ * detection) but resolves against the manifest's recorded harnesses
+ * rather than detection — uninstall only acts on what's actually
+ * installed.
+ *
+ * Returns the resolved subset of harness names to uninstall, or `null`
+ * meaning "every harness in the manifest" (the no-filter default —
+ * today's behavior preserved).
+ *
+ * Throws on:
+ *   - flag conflict: --harness <name> + --all-detected
+ *   - unknown harness in filter: every named harness must exist in the
+ *     manifest, otherwise the user typed something that won't do what
+ *     they expect (fail fast, don't pretend to uninstall a no-op)
+ */
+export declare class UninstallFilterError extends Error {
+    constructor(message: string);
+}
+export interface UninstallFilterInput {
+    /** Value of --harness (may be undefined when not passed). */
+    harnessArg?: string;
+    /** Whether --harness was actually passed on the CLI (not just defaulted). */
+    harnessFromCli: boolean;
+    /** Whether --all-detected was passed. */
+    allDetected: boolean;
+    /** Names of harnesses actually present in the on-disk manifest. */
+    manifestHarnesses: string[];
+}
+/**
+ * @returns string[] — subset of manifestHarnesses to uninstall
+ * @returns null — uninstall every harness in the manifest (today's
+ *                 default behavior; preserved for back-compat)
+ */
+export declare function resolveUninstallFilter(input: UninstallFilterInput): string[] | null;

package/dist/commands/uninstall-filter.js

@@ -0,0 +1,69 @@
+/**
+ * Filter parser for `runUninstall`. Mirrors the install-side selection
+ * syntax (`--harness all`, comma-split, `--all-detected` synonym, conflict
+ * detection) but resolves against the manifest's recorded harnesses
+ * rather than detection — uninstall only acts on what's actually
+ * installed.
+ *
+ * Returns the resolved subset of harness names to uninstall, or `null`
+ * meaning "every harness in the manifest" (the no-filter default —
+ * today's behavior preserved).
+ *
+ * Throws on:
+ *   - flag conflict: --harness <name> + --all-detected
+ *   - unknown harness in filter: every named harness must exist in the
+ *     manifest, otherwise the user typed something that won't do what
+ *     they expect (fail fast, don't pretend to uninstall a no-op)
+ */
+export class UninstallFilterError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "UninstallFilterError";
+    }
+}
+/**
+ * @returns string[] — subset of manifestHarnesses to uninstall
+ * @returns null — uninstall every harness in the manifest (today's
+ *                 default behavior; preserved for back-compat)
+ */
+export function resolveUninstallFilter(input) {
+    // Conflict: --all-detected with --harness <specific-name> is ambiguous.
+    // The 'all' literal is exempt because both flags mean the same thing
+    // there (uninstall everything).
+    if (input.allDetected &&
+        input.harnessFromCli &&
+        input.harnessArg &&
+        input.harnessArg.trim() !== "all") {
+        throw new UninstallFilterError(`--harness ${input.harnessArg} conflicts with --all-detected; pick one`);
+    }
+    // --all-detected (with or without --harness all) → no filter, uninstall all.
+    if (input.allDetected)
+        return null;
+    // No --harness passed → no filter, uninstall all (today's behavior).
+    if (!input.harnessFromCli || !input.harnessArg)
+        return null;
+    // --harness all → no filter, uninstall all.
+    const trimmed = input.harnessArg.trim();
+    if (trimmed === "all")
+        return null;
+    // Otherwise parse comma-split subset.
+    const requested = trimmed
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    if (requested.length === 0)
+        return null; // pathological — treat as no filter
+    // Validate every requested name exists in the manifest. A typo or a
+    // harness the user never installed should fail fast — silently
+    // skipping would let `--uninstall --harness claude-coed` succeed with
+    // zero work and the user thinking they uninstalled something.
+    const unknown = requested.filter((n) => !input.manifestHarnesses.includes(n));
+    if (unknown.length > 0) {
+        const listed = input.manifestHarnesses.length > 0
+            ? input.manifestHarnesses.join(", ")
+            : "(none)";
+        throw new UninstallFilterError(`Unknown harness in --harness filter: ${unknown.join(", ")}. ` +
+            `Manifest contains: ${listed}`);
+    }
+    return requested;
+}

package/dist/commands/uninstall.d.ts

@@ -1,3 +1,13 @@
-export declare function runUninstall(opts: {
+export interface RunUninstallOpts {
     dryRun: boolean;
-}): Promise<void>;
+    /**
+     * Value of --harness (may be 'all', comma-split list, or a single name).
+     * Undefined when --harness wasn't passed.
+     */
+    harnessArg?: string;
+    /** Whether --harness was explicitly passed (vs. its commander default). */
+    harnessFromCli?: boolean;
+    /** Whether --all-detected was passed. */
+    allDetected?: boolean;
+}
+export declare function runUninstall(opts: RunUninstallOpts): Promise<void>;