@bli-cockpit/cli 0.1.27 → 0.1.28

package/README.md

@@ -45,11 +45,11 @@ cockpit onboard --email <APPROVED_EMAIL> --workspace ~/BLI --workspace ~/side-pr
 The CLI defaults to the production dashboard. Normal intern/operator setup,
 updates, and syncs omit `--dashboard-url`. Pass `--dashboard-url` only for
 staging, a custom dashboard, or deliberately forcing a different dashboard
-pairing. Already-onboarded users update with
-`npm install -g @bli-cockpit/cli@latest`, then run
-`cockpit onboard` from anywhere to refresh pairing, agent rules, autostart, and
-an initial sync against saved roots. `--repo <path>` remains supported for older
-prompts and the agent ticket-binding guardrail.
+pairing. Already-onboarded users update with `cockpit update` from anywhere. It
+installs the latest public CLI from npm, then reruns onboarding checks to
+refresh pairing, agent rules, autostart, and an initial sync against saved
+roots. `cockpit upgrade` is a compatibility alias. `--repo <path>` remains
+supported for older prompts and the agent ticket-binding guardrail.
 
 On machines where Codex or Claude agents will do ticketed work, `cockpit
 onboard` refreshes `~/.codex/AGENTS.md` and `~/.claude/CLAUDE.md` after harvest

package/dist/commands/local-args.js

@@ -12,6 +12,9 @@ export function parseLocalArgs(argv) {
     switch (command) {
         case "onboard":
             return parseOnboardArgs(argv.slice(1));
+        case "update":
+        case "upgrade":
+            return parseUpdateArgs(command, argv.slice(1));
         case "install":
             return parseInstallArgs(argv.slice(1));
         case "login":
@@ -33,11 +36,13 @@ export function parseLocalArgs(argv) {
             return parseAutostartArgs(argv.slice(1));
         case "agent-rules":
             return parseAgentRulesArgs(argv.slice(1));
+        case "release":
+            return parseReleaseArgs(argv.slice(1));
         default:
             throw new Error(`Unknown local command: ${command ?? ""}`);
     }
 }
-function parseOnboardArgs(args) {
+function parseOnboardLikeArgs(args, command) {
     const values = parseNamedArgs(args, {
         allowedFlags: [
             "--home",
@@ -69,13 +74,13 @@ function parseOnboardArgs(args) {
             "--max-repos",
         ],
     });
-    assertNoPositionals(values.positionals, "onboard");
+    assertNoPositionals(values.positionals, command);
     return {
-        kind: "onboard",
         homeDir: optionalNonEmpty(values.flags.get("--home")),
         repoRoot: optionalNonEmpty(workRootFlagValue(values)),
         collectionRoots: optionalNonEmptyList(workRootFlagValues(values)),
         dashboardUrl: normalizeUrl(values.flags.get("--dashboard-url") ?? DEFAULT_DASHBOARD_URL),
+        dashboardUrlExplicit: values.flags.has("--dashboard-url"),
         claimedOwnerEmail: optionalEmail(values.flags.get("--email")),
         deviceName: optionalNonEmpty(values.flags.get("--device-name")),
         activeTicketId: optionalNonEmpty(values.flags.get("--ticket")),
@@ -87,6 +92,16 @@ function parseOnboardArgs(args) {
         maxRepos: optionalPositiveInteger(values.flags.get("--max-repos"), "--max-repos"),
     };
 }
+function parseOnboardArgs(args) {
+    return { kind: "onboard", ...parseOnboardLikeArgs(args, "onboard") };
+}
+function parseUpdateArgs(alias, args) {
+    return {
+        kind: "update",
+        alias,
+        ...parseOnboardLikeArgs(args, alias),
+    };
+}
 function parseInstallArgs(args) {
     const values = parseNamedArgs(args, {
         allowedFlags: [
@@ -115,6 +130,30 @@ function parseInstallArgs(args) {
         json: values.booleans.has("--json"),
     };
 }
+function parseReleaseArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: [
+            "--dry-run",
+            "--tag",
+            "--access",
+            "--otp",
+            "--skip-checks",
+        ],
+        valueFlags: ["--tag", "--access", "--otp"],
+    });
+    assertNoPositionals(values.positionals, "release");
+    const releaseArgs = [];
+    if (values.booleans.has("--dry-run"))
+        releaseArgs.push("--dry-run");
+    if (values.booleans.has("--skip-checks"))
+        releaseArgs.push("--skip-checks");
+    for (const flag of ["--tag", "--access", "--otp"]) {
+        const value = values.flags.get(flag);
+        if (value !== undefined)
+            releaseArgs.push(flag, value);
+    }
+    return { kind: "release", args: releaseArgs };
+}
 function parseLoginArgs(args) {
     const values = parseNamedArgs(args, {
         allowedFlags: [

package/dist/commands/local.js

@@ -1,4 +1,5 @@
-import { execFile } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { createCollectorServer } from "../server.js";
@@ -14,6 +15,8 @@ import { runAttributedWorktreeSync, } from "./session-sync.js";
 import { COLLECTION_ROOT_REQUIRED, resolveOnboardingRoots, } from "../onboarding-roots.js";
 export const rootCommandNames = new Set([
     "onboard",
+    "update",
+    "upgrade",
     "install",
     "login",
     "pair",
@@ -25,6 +28,7 @@ export const rootCommandNames = new Set([
     "serve",
     "autostart",
     "agent-rules",
+    "release",
 ]);
 export async function runLocalCockpitCli(argv, io = defaultIo()) {
     if (isLocalHelpRequest(argv)) {
@@ -47,6 +51,8 @@ export async function runLocalCockpitCli(argv, io = defaultIo()) {
                 return await runInstall(command, io);
             case "onboard":
                 return await runOnboard(command, io);
+            case "update":
+                return await runUpdate(command, io);
             case "login":
                 return await runLogin(command, io);
             case "logout":
@@ -65,6 +71,8 @@ export async function runLocalCockpitCli(argv, io = defaultIo()) {
                 return await runAutostart(command, io);
             case "agent-rules":
                 return await runAgentRules(command, io);
+            case "release":
+                return await runRelease(command, io);
         }
     }
     catch (error) {
@@ -77,6 +85,8 @@ export function localCommandHelp(command) {
         return localSubcommandHelp(command);
     return [
         "  cockpit onboard [--ticket <id>] [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--workspace <path>] [--branch <name>] [--max-depth <n>] [--max-repos <n>] [--json]",
+        "  cockpit update [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--workspace <path>] [--json]",
+        "  cockpit upgrade [same flags as update]",
         "  cockpit install [--dashboard-url <url>] [--workspace <path>] [--json]",
         "  cockpit login [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--json]",
         "  cockpit pair [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--json]",
@@ -88,6 +98,7 @@ export function localCommandHelp(command) {
         "  cockpit serve [--port <port>] [--workspace <path>]",
         "  cockpit autostart [install|uninstall|status] [--workspace <path>] [--dashboard-url <url>] [--interval-seconds <n>] [--json]",
         "  cockpit agent-rules [install|uninstall|status] [--host codex|claude|all] [--workspace <path>] [--json]",
+        "  cockpit release [--dry-run] [--skip-checks] [--tag <tag>] [--access <public|restricted>] [--otp <code>]",
         "",
         `Default dashboard: ${DEFAULT_DASHBOARD_URL}. Omit --dashboard-url for normal production use; pass it only for staging/custom dashboards or to force a different pairing.`,
     ].join("\n");
@@ -118,6 +129,25 @@ function localSubcommandHelp(command) {
                 "Omit --dashboard-url for the production dashboard; pass it only for staging/custom dashboards.",
             ],
         ],
+        [
+            "update",
+            [
+                "Usage: cockpit update [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--workspace <path>] [--json]",
+                "",
+                "Updates the global public CLI from npm, then reruns `cockpit onboard`",
+                "with the same setup flags so pairing, saved roots, agent rules,",
+                "autostart, and the initial sync are refreshed in one command.",
+                "`cockpit upgrade` is an alias.",
+            ],
+        ],
+        [
+            "upgrade",
+            [
+                "Usage: cockpit upgrade [same flags as cockpit update]",
+                "",
+                "Alias for `cockpit update`.",
+            ],
+        ],
         [
             "login",
             [
@@ -222,6 +252,17 @@ function localSubcommandHelp(command) {
                 "Action defaults to `install`.",
             ],
         ],
+        [
+            "release",
+            [
+                "Usage: cockpit release [--dry-run] [--skip-checks] [--tag <tag>] [--access <public|restricted>] [--otp <code>]",
+                "",
+                "Maintainer-only helper. Run from inside the bli-cockpit repo checkout.",
+                "Requires a clean `main` branch and runs `git pull --ff-only` before publishing.",
+                "Delegates to `npm run publish:public -- ...` so public packages are",
+                "built, checked, and published in the safe telemetry-core then CLI order.",
+            ],
+        ],
     ]);
     return (helpByCommand.get(command) ?? [localCommandHelp()]).join("\n");
 }
@@ -244,6 +285,186 @@ async function runInstall(command, io) {
     writeLine(io.stdout, "Next: run `cockpit login`, then `cockpit start` inside the repo; add `--ticket <id>` only when ticket work begins.");
     return 0;
 }
+async function runUpdate(command, io) {
+    const exec = io.exec ?? defaultExec();
+    const installArgs = [
+        "install",
+        "-g",
+        "@bli-cockpit/cli@latest",
+        "--prefer-online",
+    ];
+    if (!command.json) {
+        writeLine(io.stdout, "Updating Cockpit CLI from npm...");
+    }
+    const install = await exec("npm", installArgs);
+    writeExecOutput(io, install, { stdout: !command.json, stderr: true });
+    if (install.code !== 0) {
+        if (command.json) {
+            writeLine(io.stdout, JSON.stringify({
+                status: "blocked",
+                step: "npm_install",
+                command: `npm ${installArgs.join(" ")}`,
+                exit_code: install.code,
+            }, null, 2));
+        }
+        else {
+            writeLine(io.stderr, "BLOCKED: npm install failed; Cockpit CLI was not refreshed.");
+        }
+        return install.code || 1;
+    }
+    if (!command.json) {
+        writeLine(io.stdout, "Cockpit CLI updated. Rechecking onboarding...");
+    }
+    const onboard = await exec("cockpit", [
+        "onboard",
+        ...updateOnboardArgs(command),
+    ]);
+    writeExecOutput(io, onboard, { stdout: true, stderr: true });
+    return onboard.code;
+}
+async function runRelease(command, io) {
+    const releaseRoot = await findPublicReleaseRoot(process.cwd());
+    if (!releaseRoot) {
+        writeLine(io.stderr, "cockpit release must be run inside the bli-cockpit repo checkout (missing publish:public script).");
+        return 1;
+    }
+    const exec = io.exec ?? defaultExec();
+    const gitReady = await prepareReleaseMainBranch(releaseRoot, exec, io);
+    if (!gitReady)
+        return 1;
+    writeLine(io.stdout, "Running Cockpit public package release...");
+    const npmArgs = ["--prefix", releaseRoot, "run", "publish:public"];
+    if (command.args.length > 0)
+        npmArgs.push("--", ...command.args);
+    const releaseExec = io.interactiveExec ?? defaultInteractiveExec();
+    const result = await releaseExec("npm", npmArgs);
+    writeExecOutput(io, result, { stdout: true, stderr: true });
+    return result.code;
+}
+async function prepareReleaseMainBranch(releaseRoot, exec, io) {
+    const branch = await exec("git", [
+        "-C",
+        releaseRoot,
+        "rev-parse",
+        "--abbrev-ref",
+        "HEAD",
+    ]);
+    writeExecOutput(io, branch, { stdout: false, stderr: true });
+    if (branch.code !== 0) {
+        writeLine(io.stderr, "BLOCKED: cockpit release could not read the current git branch.");
+        return false;
+    }
+    const currentBranch = branch.stdout.trim();
+    if (currentBranch !== "main") {
+        writeLine(io.stderr, `BLOCKED: cockpit release only publishes from main. Current branch is ${currentBranch || "unknown"}.`);
+        writeLine(io.stderr, "Merge the release changes, switch to main, then rerun `cockpit release`.");
+        return false;
+    }
+    const status = await exec("git", [
+        "-C",
+        releaseRoot,
+        "status",
+        "--porcelain",
+    ]);
+    writeExecOutput(io, status, { stdout: false, stderr: true });
+    if (status.code !== 0) {
+        writeLine(io.stderr, "BLOCKED: cockpit release could not inspect git status.");
+        return false;
+    }
+    if (status.stdout.trim()) {
+        writeLine(io.stderr, "BLOCKED: cockpit release requires a clean main checkout.");
+        writeLine(io.stderr, "Commit or discard local changes, then rerun `cockpit release`.");
+        return false;
+    }
+    writeLine(io.stdout, "Syncing main with git pull --ff-only...");
+    const pull = await exec("git", ["-C", releaseRoot, "pull", "--ff-only"]);
+    writeExecOutput(io, pull, { stdout: true, stderr: true });
+    if (pull.code !== 0) {
+        writeLine(io.stderr, "BLOCKED: git pull --ff-only failed; main is not safely current.");
+        return false;
+    }
+    return true;
+}
+async function findPublicReleaseRoot(startDir) {
+    let current = path.resolve(startDir);
+    while (true) {
+        const packageJsonPath = path.join(current, "package.json");
+        try {
+            const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+            if (packageJson.scripts?.["publish:public"] !== undefined)
+                return current;
+        }
+        catch {
+            // Keep walking: nested packages may be missing package.json or have one
+            // without the release script.
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+function updateOnboardArgs(command) {
+    const args = [];
+    if (command.homeDir)
+        args.push("--home", command.homeDir);
+    for (const root of updateCollectionRoots(command)) {
+        args.push("--workspace", root);
+    }
+    if (command.dashboardUrlExplicit) {
+        args.push("--dashboard-url", command.dashboardUrl);
+    }
+    if (command.claimedOwnerEmail)
+        args.push("--email", command.claimedOwnerEmail);
+    if (command.deviceName)
+        args.push("--device-name", command.deviceName);
+    if (command.activeTicketId)
+        args.push("--ticket", command.activeTicketId);
+    if (command.branch)
+        args.push("--branch", command.branch);
+    if (command.pollIntervalMs !== undefined) {
+        args.push("--poll-interval-ms", String(command.pollIntervalMs));
+    }
+    if (command.timeoutMs !== undefined) {
+        args.push("--timeout-ms", String(command.timeoutMs));
+    }
+    if (command.maxDepth !== undefined)
+        args.push("--max-depth", String(command.maxDepth));
+    if (command.maxRepos !== undefined)
+        args.push("--max-repos", String(command.maxRepos));
+    if (command.json)
+        args.push("--json");
+    return args;
+}
+function updateCollectionRoots(command) {
+    const roots = command.collectionRoots?.length
+        ? command.collectionRoots
+        : command.repoRoot
+            ? [command.repoRoot]
+            : [];
+    const seen = new Set();
+    const deduped = [];
+    for (const root of roots) {
+        if (seen.has(root))
+            continue;
+        seen.add(root);
+        deduped.push(root);
+    }
+    return deduped;
+}
+function writeExecOutput(io, result, options) {
+    if (options.stdout)
+        writeRaw(io.stdout, result.stdout);
+    if (options.stderr)
+        writeRaw(io.stderr, result.stderr);
+}
+function writeRaw(stream, text) {
+    if (!text)
+        return;
+    stream.write(text);
+    if (!text.endsWith("\n"))
+        stream.write("\n");
+}
 function isInteractiveStdin(io) {
     return Boolean(io.stdin.isTTY);
 }
@@ -1343,6 +1564,17 @@ function defaultExec() {
         });
     });
 }
+function defaultInteractiveExec() {
+    return (cmd, args) => new Promise((resolve) => {
+        const child = spawn(cmd, args, { stdio: "inherit" });
+        child.on("error", (error) => {
+            resolve({ code: 1, stdout: "", stderr: errorMessage(error) });
+        });
+        child.on("close", (code) => {
+            resolve({ code: code ?? 1, stdout: "", stderr: "" });
+        });
+    });
+}
 function defaultIo() {
     if (!globalThis.fetch) {
         throw new Error("global fetch is unavailable; use Node.js 20 or newer.");
@@ -1354,6 +1586,7 @@ function defaultIo() {
         env: process.env,
         fetch: globalThis.fetch.bind(globalThis),
         exec: defaultExec(),
+        interactiveExec: defaultInteractiveExec(),
     };
 }
 function writeLine(stream, text) {

package/dist/commands/public-root.js

@@ -22,13 +22,15 @@ function cockpitHelp() {
     "Usage:",
     localCommandHelp(),
     "",
-    "Install/update: `npm install -g @bli-cockpit/cli@latest`.",
+    "Install: `npm install -g @bli-cockpit/cli@latest`.",
+    "Update: run `cockpit update` to refresh the global CLI and rerun onboarding checks.",
     "Intern path: run `cockpit onboard`; it confirms a `/BLI` collection root before syncing.",
     "Headless/reused laptop path: `cockpit onboard --email <email> --workspace ~/BLI`.",
-    "Already onboarded: rerun `cockpit onboard` from anywhere to refresh pairing, roots, agent rules, autostart, and sync.",
+    "Already onboarded: run `cockpit update` from anywhere to refresh pairing, roots, agent rules, autostart, and sync.",
     "Agent setup: `cockpit onboard` refreshes AGENTS.md/CLAUDE.md rules; use `cockpit agent-rules install --workspace ~/BLI` for repair.",
     "Dashboard URL is optional for normal production use; pass `--dashboard-url` only for staging/custom dashboards or forced re-pairing.",
     "Manual collector path: `install`, `login`, `start [--ticket <id>] [--topic <label>] [--intent <intent>] [--phase <phase>]`, `sync`, `status`, `agent-rules`.",
+    "Maintainer release path: merge to main first, then run `cockpit release --dry-run` and `cockpit release` from a clean main checkout.",
   ].join("\n");
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.1.27",
+  "version": "0.1.28",
   "private": false,
   "type": "module",
   "bin": {