@catalyst-cloud/cli 0.16.19 → 0.16.21

package/dist/env/shell.js

@@ -0,0 +1,288 @@
+// shell.ts — `catalyst env shell [--check]`: open this repository's environment on this computer.
+// Every refusal a person can fix in the file or the terminal fires before Docker is touched; the
+// cloud is asked only when a credential-free download is refused (shell-pull.ts).
+import { execFile } from "node:child_process";
+import { readFileSync, realpathSync } from "node:fs";
+import { basename, isAbsolute, relative, resolve } from "node:path";
+import { parseEnv, promisify } from "node:util";
+import { flagBool, flagList, flagString, positionals } from "../args.js";
+import { UsageError } from "../errors.js";
+import { IMAGE_REF, RUNNER_HOST_IMAGES } from "../onboard-runner.js";
+import { readLocalRepositoryName } from "../onboard-settings-context.js";
+import { readLocalSettings } from "./settings-authority.js";
+import { readShellDeclaration, resolveShellVariables } from "./shell-declaration.js";
+import { spawnEnvShellDocker } from "./shell-docker.js";
+import { parseCheckOutput, shellRunArgs, START_EXIT_TOOLCHAIN, toolchainSpecs } from "./shell-plan.js";
+import { downloadImage } from "./shell-pull.js";
+const DECLARATION = ".catalyst/catalyst.toml";
+const IMAGE_UID = 10001;
+const run = promisify(execFile);
+/** Git with no global or system config, no prompt, bounded: a path, or null. */
+async function gitPath(cwd, args) {
+    try {
+        const { stdout } = await run("git", args, {
+            cwd,
+            timeout: 3_000,
+            maxBuffer: 16_384,
+            env: {
+                PATH: process.env.PATH,
+                GIT_CONFIG_GLOBAL: "/dev/null",
+                GIT_CONFIG_NOSYSTEM: "1",
+                GIT_TERMINAL_PROMPT: "0",
+            },
+        });
+        const path = stdout.trim();
+        return path !== "" && isAbsolute(path) ? path : null;
+    }
+    catch {
+        return null;
+    }
+}
+const defaultGitTopLevel = (cwd) => gitPath(cwd, ["rev-parse", "--show-toplevel"]);
+const defaultGitCommonDir = (root) => gitPath(root, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+/** The digest shortened for a person: `<name>@sha256:<12 hex>…`. */
+function shortImage(image) {
+    return image.replace(/@sha256:([0-9a-f]{12})[0-9a-f]{52}$/, "@sha256:$1…");
+}
+function inside(child, parent) {
+    const rel = relative(parent, child);
+    return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+function unmountable(path) {
+    if (path.includes(","))
+        return `env shell cannot mount ${path}: the path contains a comma.`;
+    if (/[\r\n]/.test(path))
+        return `env shell cannot mount ${JSON.stringify(path)}: the path contains a line break.`;
+    return null;
+}
+function toolchainLine(toolchains) {
+    return toolchains.length === 0
+        ? "  Toolchain: none declared"
+        : `  Toolchain: ${toolchains.map((t) => `${t.name} ${t.version}`).join(", ")} (the first start downloads any version the image lacks)`;
+}
+function joinSources(sources) {
+    return sources.length <= 1 ? (sources[0] ?? "") : `${sources.slice(0, -1).join(", ")} and ${sources.at(-1)}`;
+}
+export async function runEnvShell(args, ctx, deps = {}) {
+    // 1. Flags.
+    const [, ...rest] = positionals(args);
+    if (rest.length > 0)
+        throw new UsageError(`env shell takes no positional arguments (got "${rest[0]}"); use --root DIR`);
+    const check = flagBool(args, "check");
+    const json = args.json;
+    if (json && !check)
+        throw new UsageError("env shell --json needs --check: the shell itself is interactive");
+    const imageFlag = flagString(args, "image");
+    if (imageFlag !== undefined && !IMAGE_REF.test(imageFlag))
+        throw new UsageError("env shell --image needs a digest-pinned reference, such as ghcr.io/owner/image@sha256:<64 hex>");
+    const image = imageFlag ?? RUNNER_HOST_IMAGES.runner;
+    const say = (line) => {
+        if (!json)
+            ctx.stdout(line);
+    };
+    const notice = (line) => (json ? ctx.stderr(line) : ctx.stdout(line));
+    const refuse = (refusal) => {
+        if (json)
+            ctx.stdout(JSON.stringify({ ok: false, refusal }));
+        else
+            for (const line of refusal.message.split("\n"))
+                ctx.stderr(line);
+        return 1;
+    };
+    // 2. Root.
+    const rootFlag = flagString(args, "root");
+    const start = resolve(rootFlag ?? ".");
+    const requested = rootFlag !== undefined ? start : ((await (deps.gitTopLevel ?? defaultGitTopLevel)(start)) ?? start);
+    let root;
+    try {
+        root = realpathSync(requested);
+    }
+    catch {
+        return refuse({
+            code: "declaration_missing",
+            message: `No ${DECLARATION} in ${requested}. Draft one with: catalyst env draft --write`,
+        });
+    }
+    const rootProblem = unmountable(root);
+    if (rootProblem)
+        return refuse({ code: "repository_path_unsupported", message: rootProblem });
+    // 3. Declaration.
+    const text = await readLocalSettings(root);
+    if (text === null)
+        return refuse({
+            code: "declaration_missing",
+            message: `No ${DECLARATION} in ${root}. Draft one with: catalyst env draft --write`,
+        });
+    const declaration = readShellDeclaration(text);
+    if (declaration.state === "invalid")
+        return refuse({
+            code: "declaration_invalid",
+            message: [...declaration.errors.map((error) => `${DECLARATION}: ${error}`), "Fix the file, then run catalyst env check."].join("\n"),
+        });
+    if (declaration.state === "unsupported") {
+        const { name, version } = declaration.toolchain;
+        return refuse({
+            code: "toolchain_version_unsupported",
+            message: `${name} ${JSON.stringify(version)} is a version range. env shell prepares an exact or prefix version, such as 22 or 22.23.3. Change it in ${DECLARATION}.`,
+        });
+    }
+    // 4. Variables.
+    const envFiles = [];
+    for (const path of flagList(args, "env-file")) {
+        try {
+            envFiles.push({ path, values: parseEnv(readFileSync(resolve(path), "utf8")) });
+        }
+        catch {
+            return refuse({ code: "env_file_unreadable", message: `could not read --env-file ${path}` });
+        }
+    }
+    const variables = resolveShellVariables(declaration.variables, { env: ctx.env, envFiles, platform: deps.platform });
+    if (variables.missingRequired.length > 0)
+        return refuse({
+            code: "variables_missing",
+            message: `These required variables are not set in this terminal or an --env-file: ${variables.missingRequired.join(", ")}. Set them, then run catalyst env shell again.`,
+            names: variables.missingRequired,
+        });
+    // 5. Engine.
+    const docker = deps.docker ?? spawnEnvShellDocker({ env: ctx.env });
+    const server = await docker.server();
+    if (server.state === "missing")
+        return refuse({
+            code: "docker_missing",
+            message: "Docker is not installed on this computer. Install Docker Desktop, OrbStack or Docker Engine, then run catalyst env shell again.",
+        });
+    if (server.state === "not_running")
+        return refuse({
+            code: "docker_not_running",
+            message: "Docker is installed but not running. Start Docker Desktop, OrbStack or Docker Engine, then run catalyst env shell again.",
+        });
+    if (server.state === "not_linux")
+        return refuse({
+            code: "docker_not_linux",
+            message: `Docker is running ${server.os} containers. Switch it to Linux containers, then run catalyst env shell again.`,
+        });
+    // 6. Image.
+    const readRepositoryName = deps.readRepositoryName ?? readLocalRepositoryName;
+    const repository = (await readRepositoryName(root)) ?? basename(root);
+    say(`Environment for ${repository}, from ${DECLARATION}`);
+    const present = await docker.imagePresent(image);
+    say(`  Image: ${shortImage(image)} (${present ? "already on this computer" : "not on this computer yet"})`);
+    let credential = "none";
+    if (!present) {
+        const endpoint = await docker.endpoint();
+        if (!endpoint.ok)
+            return refuse(endpoint.reason === "conflict"
+                ? {
+                    code: "docker_endpoint_conflict",
+                    message: "DOCKER_HOST and DOCKER_CONTEXT are both set. Unset one, then run catalyst env shell again.",
+                }
+                : {
+                    code: "docker_endpoint_unreadable",
+                    message: "Docker's current context could not be read. Check it with docker context ls, then run catalyst env shell again.",
+                });
+        const downloaded = await downloadImage({ ref: image, host: endpoint.host, root, ctx, docker, notify: notice, readRepositoryName });
+        if (!downloaded.ok)
+            return refuse(downloaded.refusal);
+        credential = downloaded.credential;
+    }
+    // 7. Git common directory: a worktree's shared .git outside the root is mounted at its own path.
+    const commonDir = await (deps.gitCommonDir ?? defaultGitCommonDir)(root);
+    let gitCommonDir = null;
+    if (commonDir !== null) {
+        let real = commonDir;
+        try {
+            real = realpathSync(commonDir);
+        }
+        catch {
+            // Not there any more: git inside the shell reports it; nothing is mounted.
+        }
+        if (!inside(real, root)) {
+            const problem = unmountable(real);
+            if (problem)
+                return refuse({ code: "repository_path_unsupported", message: problem });
+            gitCommonDir = real;
+        }
+    }
+    // 8. Run.
+    const tty = !check && (deps.isTty?.() ?? (process.stdin.isTTY === true && process.stdout.isTTY === true));
+    const checkNames = declaration.variables.map((v) => v.name).filter((name) => !variables.skippedReserved.includes(name));
+    const argv = shellRunArgs({
+        mode: check ? "check" : "shell",
+        image,
+        root,
+        gitCommonDir,
+        toolchains: declaration.toolchains,
+        passNames: variables.set,
+        tty,
+        checkNames,
+    });
+    const runEnv = { ...ctx.env, ...variables.values };
+    if (tty)
+        runEnv.TERM = ctx.env.TERM || "xterm-256color";
+    if (variables.skippedReserved.length > 0)
+        notice(`  Note: env shell sets ${variables.skippedReserved.join(", ")} itself, so the declared value is not used.`);
+    const uid = deps.uid ?? process.getuid?.();
+    if ((deps.platform ?? process.platform) === "linux" && uid !== undefined && uid !== IMAGE_UID)
+        notice(`Note: the shell runs as uid ${IMAGE_UID}, as Catalyst's agents do. Files here belong to uid ${uid}, so on Docker Engine for Linux the shell may not be able to write them.`);
+    const toolchainNotPrepared = {
+        code: "toolchain_not_prepared",
+        message: `The shell did not start: a declared toolchain could not be prepared (mise's message above says which). Check the name and version in ${DECLARATION}, then run catalyst env shell --check.`,
+    };
+    const secret = new Set(declaration.variables.filter((v) => v.secret).map((v) => v.name));
+    if (!check) {
+        say(toolchainLine(declaration.toolchains));
+        const set = variables.set.map((name) => (secret.has(name) ? `${name} (secret)` : name));
+        const parts = [
+            ...(set.length > 0 ? [`${set.join(", ")} set from ${joinSources(variables.sources)}`] : []),
+            ...(variables.unsetOptional.length > 0 ? [`not set: ${variables.unsetOptional.map((name) => `${name} (optional)`).join(", ")}`] : []),
+        ];
+        say(`  Variables: ${parts.length > 0 ? parts.join("; ") : "none declared"}`);
+        say(`  Your repository is at /workspace. Type exit to leave.`);
+        const result = await docker.run(argv, runEnv, "interactive");
+        if (result.code === START_EXIT_TOOLCHAIN)
+            return refuse(toolchainNotPrepared);
+        return result.code;
+    }
+    const result = await docker.run(argv, runEnv, "capture");
+    if (result.code === START_EXIT_TOOLCHAIN)
+        return refuse(toolchainNotPrepared);
+    const specs = toolchainSpecs(declaration.toolchains);
+    const report = result.code === 0 ? parseCheckOutput(result.stdout, specs, checkNames) : null;
+    if (report === null)
+        return refuse({
+            code: "check_incomplete",
+            message: `The environment check did not finish (exit ${result.code}). Run catalyst env shell --check again; if it repeats, open the shell and run mise doctor.`,
+        });
+    const byName = new Map(declaration.variables.map((v) => [v.name, v]));
+    const resolvedBySpec = new Map(report.toolchains.map((t) => [t.spec, t.resolved]));
+    const resolvedOf = (t) => resolvedBySpec.get(`${t.name}@${t.version}`) ?? "";
+    if (json) {
+        ctx.stdout(JSON.stringify({
+            ok: true,
+            repository,
+            declaration: DECLARATION,
+            image: { reference: image, source: present ? "present" : "downloaded", credential },
+            toolchains: declaration.toolchains.map((t) => ({ name: t.name, version: t.version, resolved: resolvedOf(t) })),
+            variables: report.variables.map((v) => ({
+                name: v.name,
+                required: byName.get(v.name)?.required === true,
+                secret: byName.get(v.name)?.secret === true,
+                set: v.set,
+            })),
+        }));
+        return 0;
+    }
+    say(declaration.toolchains.length === 0
+        ? "  Toolchain: none declared"
+        : `  Toolchain: ${declaration.toolchains.map((t) => `${t.name} ${t.version} → ${resolvedOf(t)}`).join(", ")}`);
+    say(`  Variables: ${report.variables.length === 0
+        ? "none declared"
+        : report.variables
+            .map((v) => {
+            const notes = [...(secret.has(v.name) ? ["secret"] : []), ...(!v.set && byName.get(v.name)?.required !== true ? ["optional"] : [])];
+            return `${v.name} ${v.set ? "set" : "not set"}${notes.length > 0 ? ` (${notes.join(", ")})` : ""}`;
+        })
+            .join(", ")}`);
+    say("Ready: catalyst env shell opens this environment.");
+    return 0;
+}

package/dist/env.js

@@ -1,7 +1,9 @@
-// env.ts — `catalyst env inventory` / `env check`: a LOCAL, OFFLINE, repo-scoped reporter and
-// validator. Unlike every other verb in this file's siblings, `cmdEnv` never calls `requireConfig` or
-// `apiClient` — it needs neither a login nor a network call, which is the whole point of the feature:
-// a person reviews what a repository declares without connecting anything first.
+// env.ts — `catalyst env inventory` / `check` / `migrate` / `draft`: a LOCAL, OFFLINE, repo-scoped
+// reporter and validator. Unlike every other verb in this file's siblings, those four never call
+// `requireConfig` or `apiClient` — they need neither a login nor a network call, which is the whole
+// point of the feature: a person reviews what a repository declares without connecting anything first.
+// `env shell` (env/shell.ts) talks to Docker, and asks the cloud only when a credential-free download
+// of the image is refused; Catalyst's own image needs no login.
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { flagBool, flagString, positionals } from "./args.js";
@@ -10,11 +12,14 @@ import { convertLegacyEnvironmentJson } from "./env/legacy.js";
 import { draftEnvironment } from "./env/draft.js";
 import { inventoryRepo } from "./env/inventory.js";
 import { inventoryToJson, renderInventory } from "./env/render.js";
+import { runEnvShell } from "./env/shell.js";
 import { UsageError } from "./errors.js";
 export async function cmdEnv(args, ctx, deps = {}) {
     const [sub, ...rest] = positionals(args);
     if (sub === undefined)
-        throw new UsageError("env needs a subcommand: inventory | check | migrate | draft");
+        throw new UsageError("env needs a subcommand: inventory | check | migrate | draft | shell");
+    if (sub === "shell")
+        return await runEnvShell(args, ctx, deps.shell ?? {});
     if (sub === "draft") {
         if (rest.length > 0)
             throw new UsageError("env draft takes no positional arguments; use --root DIR");
@@ -172,5 +177,5 @@ export async function cmdEnv(args, ctx, deps = {}) {
                 ctx.stderr(`${file}: ${error}`);
         return result.state === "invalid" ? 1 : 0;
     }
-    throw new UsageError(`unknown env subcommand "${sub}": inventory | check | migrate | draft`);
+    throw new UsageError(`unknown env subcommand "${sub}": inventory | check | migrate | draft | shell`);
 }

package/dist/execution.js

@@ -311,9 +311,12 @@ export async function cmdQueue(args, ctx) {
     ctx.stdout(args.json ? JSON.stringify(out) : JSON.stringify(out, null, 2));
     return 0;
 }
-/** The five status words `/api/v1/coding-accounts` reports, in the words a customer reads. */
+/** The status words `/api/v1/coding-accounts` reports, in the words a customer reads. */
 export const ACCOUNT_STATUS = {
-    "expired-or-revoked": "expired or revoked — replace its credential on the AI accounts page (Settings → AI accounts → the account → Replace credential) before it can take work",
+    "expired-or-revoked": "credential expired or missing — replace its credential on the AI accounts page (Settings → AI accounts → the account → Replace credential) before it can take work",
+    // CTC-6204: revoked and ended accounts share one history-only end state (Ryan, 2026-10-19).
+    ended: "removed — kept for history, takes no work",
+    "out-of-rotation": "paused — its owner took it out of rotation",
     walled: "walled — the provider's usage limit is spent for now",
     active: "active — observed working",
     attested: "attested — healthy at last check, no work observed since",
@@ -326,12 +329,18 @@ export function accountDisplayName(a) {
             return v.trim();
     return a.accountSlot ?? "?";
 }
+/** CTC-6204: a revoked account, or one whose paid access ended, can never take work again and takes
+ *  no new credential. It is kept for history only. An older cloud still calls a revoked account
+ *  `expired-or-revoked`, so `revokedAtMs` decides as well as the status word. */
+export function historyOnly(a) {
+    return typeof a.revokedAtMs === "number" || a.status === "ended";
+}
 /** One slot as a line a human reads: who it is, what state it is in, and what it is spending on. */
 export function renderAccount(a) {
     const display = accountDisplayName(a);
     const name = display === (a.accountSlot ?? "?") ? display : `${display} (${a.accountSlot ?? "?"})`;
     const harness = a.harness ? `/${a.harness}` : "";
-    const status = a.status ? (ACCOUNT_STATUS[a.status] ?? a.status) : "status unknown";
+    const status = historyOnly(a) ? ACCOUNT_STATUS.ended : a.status ? (ACCOUNT_STATUS[a.status] ?? a.status) : "status unknown";
     const bits = [`${name}  ${a.provider ?? "?"}${harness}  ${status}`];
     // CTC-4199: a cancelled subscription is kept for reporting and not used; never re-credential it (Ryan, 2026-09-29).
     if (a.renewalStatus === "canceled")
@@ -367,17 +376,29 @@ export async function cmdAccounts(args, ctx) {
     if (res.status === 404)
         throw needsNewerCloud("coding-account status", cfg);
     const accounts = Array.isArray(res.body) ? res.body : (res.body?.accounts ?? []);
+    // CTC-6204: removed accounts are history, so they are left out unless --all asks for them. Listed,
+    // they read as accounts to repair, and agents kept trying to revive them.
+    const shown = flagBool(args, "all") ? accounts : accounts.filter((a) => !historyOnly(a));
+    const hidden = accounts.length - shown.length;
     if (args.json) {
-        const named = accounts.map((a) => ({ ...a, displayName: accountDisplayName(a) }));
-        ctx.stdout(JSON.stringify(Array.isArray(res.body) ? named : { ...res.body, accounts: named }));
+        const named = shown.map((a) => ({ ...a, displayName: accountDisplayName(a), removed: historyOnly(a) }));
+        ctx.stdout(JSON.stringify(Array.isArray(res.body) ? named : { ...res.body, accounts: named, removedHidden: hidden }));
         return 0;
     }
+    const addAt = `${normalizeBaseUrl(cfg.baseUrl)}/settings/coding-accounts`;
+    const hiddenLine = `${hidden} removed account${hidden === 1 ? " is" : "s are"} kept for history and take no work; catalyst accounts --all lists ${hidden === 1 ? "it" : "them"}.`;
     if (accounts.length === 0) {
-        ctx.stdout(`No coding accounts are enrolled in this workspace. A workspace owner or admin adds one at ${normalizeBaseUrl(cfg.baseUrl)}/settings/coding-accounts; there is no command for that yet.`);
+        ctx.stdout(`No coding accounts are enrolled in this workspace. A workspace owner or admin adds one at ${addAt}; there is no command for that yet.`);
+        return 0;
+    }
+    if (shown.length === 0) {
+        ctx.stdout(`No AI account in this workspace can take work. A workspace owner or admin adds one at ${addAt}. ${hiddenLine}`);
         return 0;
     }
-    for (const a of accounts)
+    for (const a of shown)
         ctx.stdout(renderAccount(a));
+    if (hidden > 0)
+        ctx.stdout(hiddenLine);
     return 0;
 }
 /**

package/dist/onboard-accounts.js

@@ -97,11 +97,13 @@ async function inventory(ctx, journal, signal) {
  * (the server's isUsableCodingAccount): any provider, any member's account, and a canceled
  * subscription keeps working until its paid access ends. */
 function unusableCause(row, now) {
-    if (row.declaredState !== "active")
-        return "coding_account_inactive";
+    // CTC-6204: ended first. A revoked account is usually also declared inactive, and "turn it on"
+    // is advice it can never take.
     if (row.revokedAtMs !== null ||
         (row.accessEndsAtMs !== null && row.accessEndsAtMs <= now))
         return "coding_account_ended";
+    if (row.declaredState !== "active")
+        return "coding_account_inactive";
     if (row.needsCredential)
         return "coding_account_needs_login";
     if (row.quarantined)

package/dist/onboard-next.js

@@ -109,7 +109,6 @@ const REASONS = {
     workflow_unavailable: "Setup could not read the team's workflow. Run catalyst onboard again to retry.",
     capacity_context_unverified: "Setup could not confirm this project's registered repositories and its default repository for capacity. Run catalyst ready to see the project checks, then run catalyst setup again. Starting a ticket checks its own repository's admission.",
     capacity_identity_unverified: "Setup could not confirm your workspace and administrator role for the capacity check. Run catalyst login, then run catalyst setup again.",
-    capacity_admission_unverified: "No runner is allowed to take work for this workspace yet. Enroll a self-hosted runner host, or ask Catalyst to enable cloud runners for it. Then run catalyst onboard.",
     capacity_currently_full: "Every runner slot for this repository is in use. Run catalyst onboard again after current work finishes.",
     capacity_unavailable: "Setup could not read runner capacity. Run catalyst onboard again to retry.",
     runner_not_selected: "This setup does not start a runner on this machine. To start one, run catalyst onboard --runner.",
@@ -424,9 +423,16 @@ export function onboardReasonText(step, context = {}) {
             ? `This setup step is not available on this server yet. Continue in the web app at ${page}, then run catalyst onboard.`
             : "This setup step is not available on this server yet. Run catalyst onboard after the server update.";
     }
+    // CTC-6180: the command that enrolls this computer, named with its team.
+    // The command is its own line (never wrapped), and runnable as printed: with no known team key,
+    // setup asks for the team.
+    if (reason === "capacity_admission_unverified") {
+        const key = onboardTeamKey(context.journal);
+        return `No runner is allowed to take work for this workspace yet. To use Catalyst's cloud runners, ask Catalyst support to turn on cloud runners for your workspace, then run catalyst onboard. To run work on this computer instead, enroll it as a self-hosted runner${key ? "" : " (setup asks for your Linear team)"} with:\ncatalyst onboard --runner${key ? ` --team ${key}` : ""}`;
+    }
     if (reason === "runner_native_egress_setup_required") {
-        const commands = nativeEgressInstallCommands();
-        return "Native Linux needs a root-managed session egress producer before the runner can take work. Its elevated installation creates the isolated session network and private-range and host-isolation nftables rules. Review and authorize this separately; setup has not run it. It requires systemd, python3, Docker and nftables. " + (commands ? "Install the verified bundled artifacts, then run the same setup command:\n" + commands : "Setup could not verify its bundled artifacts. Reinstall the CLI before authorizing installation.");
+        const command = nativeEgressInstallCommands();
+        return "Native Linux needs a root-managed session egress service before this computer can take work. It creates the isolated session network and the nftables rules that keep sessions off private addresses and this machine. It needs systemd, python3, Docker and nftables, and setup has not run it. " + (command ? "Review it, run this one command, then run the same setup command:\n" + command : "Setup could not verify its bundled files. Reinstall the CLI, then run the same setup command.");
     }
     if (reason === "runner_images_unavailable" || reason === "runner_supervisor_image_unavailable") {
         const image = step.evidence?.image;

package/dist/onboard-runner-egress.js

@@ -51,10 +51,20 @@ export async function nativeEgressReady(now, signal, io = nodeReads) {
         return false;
     }
 }
-/** Exact bundled bytes are checked before showing the separate, elevated install commands. */
+export const EGRESS_INSTALLER = { name: 'install-session-egress.sh', digest: 'b187180a9e5965ebe5e356a5c133ff2ec715fb294197cd636f8ff1301dc49ff0' };
+const quote = (s) => "'" + s.replaceAll("'", "'\\''") + "'";
+/** CTC-6180: root copies the installer into its own temp file, checks the pinned digest there and
+ * runs only those bytes, so an edit to the user-writable CLI install cannot run as root. */
+export function egressInstallCommand(vendor, digest = EGRESS_INSTALLER.digest, sudo = 'sudo ') {
+    const script = `t=$(mktemp) && cp -- ${quote(join(vendor, EGRESS_INSTALLER.name))} "$t" && echo ${quote(digest + '  ')}"$t" | sha256sum -c --quiet - && sh "$t" ${quote(vendor)}; s=$?; rm -f "$t"; exit $s`;
+    return `${sudo}sh -c ${quote(script)}`;
+}
+/** Exact bundled bytes are checked before showing the one elevated install command (CTC-6180). */
 export function nativeEgressInstallCommands() {
-    const root = join(packageRoot(), 'vendor/self-host/linux-session-egress');
+    const vendor = join(packageRoot(), 'vendor'), root = join(vendor, 'self-host/linux-session-egress');
     try {
+        if (hash(readFileSync(join(vendor, EGRESS_INSTALLER.name))) !== EGRESS_INSTALLER.digest)
+            return null;
         for (const artifact of EGRESS_ARTIFACTS)
             if (hash(readFileSync(join(root, artifact.name))) !== artifact.digest)
                 return null;
@@ -62,6 +72,5 @@ export function nativeEgressInstallCommands() {
     catch {
         return null;
     }
-    const quote = (s) => "'" + s.replaceAll("'", "'\\''") + "'";
-    return EGRESS_ARTIFACTS.map(a => `sudo install ${a.name === 'session-egress.py' ? '-D ' : ''}-o root -g root -m ${a.mode.toString(8)} ${quote(join(root, a.name))} ${quote(a.path)}`).join('\n') + '\nsudo systemctl daemon-reload\nsudo systemctl enable --now catalyst-session-egress.service catalyst-session-egress-attest.timer\nsudo /usr/bin/python3 /usr/lib/catalyst/session-egress.py attest';
+    return egressInstallCommand(vendor);
 }

package/dist/onboard-runner.js

@@ -29,7 +29,7 @@ export const RUNNER_HOST_IMAGES = {
     watchdog: "ghcr.io/coalesce-labs/catalyst-deadline-watchdog@sha256:63a9b20c3be3dc3ea328d77aa68dece942a40be46cb3126d9a7868e082828feb",
     runner: "ghcr.io/coalesce-labs/catalyst-runner@sha256:a19f7b0859a9814740935f7aadd8fe5c5c9c5974f9a5956a057b983ada16ea01",
 };
-const IMAGE_REF = /^[a-z0-9][a-z0-9._:/-]{0,255}@sha256:[0-9a-f]{64}$/;
+export const IMAGE_REF = /^[a-z0-9][a-z0-9._:/-]{0,255}@sha256:[0-9a-f]{64}$/;
 const HOST_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,62}$/;
 const JOIN_TOKEN = /^[A-Za-z0-9._~+/=-]{16,1024}$/;
 const ENROLLMENTS = "/api/v1/hosts/enrollments";

package/dist/setup-render.js

@@ -122,19 +122,21 @@ export function createSetupRenderer(stream, env, banner = {}) {
         const indent = /^ */.exec(text)?.[0].length ?? 0;
         col += indent;
         text = text.slice(indent);
-        return wrapAnsi(text, Math.max(1, width - col), {
-            hard: false,
-            wordWrap: true,
-            trim: true,
-        })
-            .split("\n")
-            .map((line) => {
-            const plain = visible(line);
-            const indent = /^https?:\/\/\S+$/.test(plain) && stringWidth(plain) > width - col
-                ? textCol
-                : col;
-            return prefix(indent) + line;
-        });
+        // CTC-6180: each line after the first is a command a person copies, so it is never wrapped.
+        const [prose = "", ...commands] = text.split("\n");
+        return [...wrapAnsi(prose, Math.max(1, width - col), {
+                hard: false,
+                wordWrap: true,
+                trim: true,
+            })
+                .split("\n")
+                .map((line) => {
+                const plain = visible(line);
+                const indent = /^https?:\/\/\S+$/.test(plain) && stringWidth(plain) > width - col
+                    ? textCol
+                    : col;
+                return prefix(indent) + line;
+            }), ...commands.map((command) => prefix(col) + command)];
     };
     const stepRows = (kind, number, title, outcome, plan = false) => {
         refresh();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@catalyst-cloud/cli",
-  "version": "0.16.19",
+  "version": "0.16.21",
   "description": "Set up Catalyst Cloud, check your tickets and manage your account from the command line.",
   "license": "MIT",
   "type": "module",

package/skills/catalyst-github/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   Catalyst's GitHub: show a ticket's pull request with its checks, reviews and review threads, say whether it is mergeable under this repository's policy, and explain what a PR accumulates as the ticket moves (the branch, the draft, the rewrite, the force-pushes, the labels, the queue). Use when someone asks "show me the PR", "what are the checks saying", "why hasn't it merged", "what does the queue need", "what does that label mean", or wants the branch and merge conventions Catalyst follows.
 allowed-tools: Bash(catalyst:*) Bash(npx -p @catalyst-cloud/cli catalyst:*)
 ---
-<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.19 — written in this repository for customer accounts -->
+<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.21 — written in this repository for customer accounts -->
 
 # Catalyst's GitHub
 

package/skills/catalyst-linear/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   Catalyst's view of Linear on the customer's own cloud account. Reads a ticket with its comments, relations, labels, linked pull requests and agent sessions inline, from the cloud API by default, with local replica reads available as an explicit opt-in, always naming the source; searches tickets, PRs, projects and initiatives; writes comments, card moves, labels and new tickets through the account's agent proxy as the app actor, with every route, stage id, label id and marker read from the account's contract. Knows what a ticket accumulates as Catalyst works it (phase-outcome comments, the document per phase, the agent session, the labels, the single blocks relation, the bookkeeping marker, the eyes acknowledgement). Use when a person says "show me the ticket", "what did Catalyst write on it", "comment on it", "move it", "label it" or "file a ticket". Not for raising a decision for a human (what-needs-me) and not for pull requests (catalyst-github).
 allowed-tools: Bash(catalyst:*) Bash(npx -p @catalyst-cloud/cli catalyst:*)
 ---
-<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.19 — written in this repository for customer accounts -->
+<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.21 — written in this repository for customer accounts -->
 
 # Catalyst Linear
 

package/skills/catalyst-onboard/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   Set up Catalyst Cloud and say whether setup is working. Walks a person from nothing to their first ticket running, one step at a time: the coding account, the project, the integrations and connected accounts, each repository's settings file, then one real ticket moving. Also logs this machine in, reads the readiness verdict with who can fix each failure, and checks the optional local replica. Use when someone says "set me up", "onboard me", "I just signed up", "get me started", "what do I do first", "log me in", "which account is this machine on", "am I set up", "what is missing", "why does nothing happen" or "is the replica running", when a login expired, or when a skill script exits 2 saying this machine is not connected. Does every step a key can do through the catalyst CLI, hands over the exact page for the steps only a browser can do, and never claims a step it did not watch succeed.
 allowed-tools: Bash(catalyst:*) Bash(npx -p @catalyst-cloud/cli catalyst:*)
 ---
-<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.19 — written in this repository for customer accounts -->
+<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.21 — written in this repository for customer accounts -->
 
 # Onboard me
 

package/skills/catalyst-onboard/scripts/where-am-i.mjs

@@ -32,7 +32,7 @@ const NOTES = [
   "Reads, in this order: `status` (machine), `ready --json` (machine checks and project checks, kept apart),",
   "`replica status --probe --json` and `events status --from-cache --probe --json` (optional local freshness),",
   "`me --json` and personal connection statuses (person), `contract --path …` for the account, the projects and the repositories,",
-  "`contract --path codingAccounts` and `accounts --json` (coding accounts, and which one needs a new credential), and each",
+  "`contract --path codingAccounts` and `accounts --all --json` (coding accounts, and which one needs a new credential), and each",
   "project's hosts_current check with its fixedWhere (host), and each project's environment_declared check with its per-repository notes (repository declarations). The teams read is refreshed, so a mapping just saved reads back mapped.",
   "Reads `capabilities --json` once: when the installed CLI can run a step for this person's role (`team check`, `team map`), the next step is that command; otherwise the page, with who can.",
   "Reads `legacy --json` when the CLI has the verb: leftovers of the old local Catalyst runtime become a machine line and a note; removing them is the person's yes.",
@@ -716,7 +716,8 @@ const credentialProblem = (a) => {
   return null;
 };
 const readAccountRows = () => {
-  const acc = runCli(["accounts", "--json"]);
+  // --all: the CLI leaves removed accounts out by default, and the retire note needs them.
+  const acc = runCli(["accounts", "--all", "--json"]);
   const doc = tryJson(acc.stdout);
   const rows = Array.isArray(doc)
     ? doc

package/skills/run-this-project/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   Own one Catalyst Cloud project end to end until it closes. Use when the person says "run this project for me", "own this until it ships", "keep this moving", or hands you a project id or a set of tickets to drive. Subscribes to the account's event stream for the scope through the catalyst CLI, reacts to each change in the same turn, makes tickets ready and moves them to dispatch, parks what should stop, chases stalls, escalates inward, and keeps one status summary current. Writes to Linear as the app actor; never polls.
 allowed-tools: Bash(catalyst:*) Bash(npx -p @catalyst-cloud/cli catalyst:*)
 ---
-<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.19 — written in this repository for customer accounts -->
+<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.21 — written in this repository for customer accounts -->
 
 # Run this project
 

package/skills/unstick/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   Get a stuck Catalyst Cloud ticket moving again. Use when the person asks "why is this parked and can you release it?", "unpark this", "get things flowing again", "the outage is over, retry what failed", or hands you a ticket that is not moving. Reads why nothing runs and what holds the ticket through the catalyst CLI, decides whether the recorded cause is fixed, previews the release, releases every governor holding the ticket the right way (or one failure class across a team), and raises an ask only for what a person has to do. Never releases a cause it cannot show changed without saying so.
 allowed-tools: Bash(catalyst:*) Bash(npx -p @catalyst-cloud/cli catalyst:*)
 ---
-<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.19 — written in this repository for customer accounts -->
+<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.21 — written in this repository for customer accounts -->
 
 # Unstick
 

package/skills/what-needs-me/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   The human's decision inbox on Catalyst Cloud, and the one way an agent raises a decision on their behalf. Use when the person asks "what needs me?", "what am I blocking?", or when active work is gated on a choice only they can make. Lists open asks ranked by how much open work each one holds, files an ask through the cloud's ask route with the account's own template, and records the answer so the held work releases. Never answers as the human, never duplicates an open ask.
 allowed-tools: Bash(catalyst:*) Bash(npx -p @catalyst-cloud/cli catalyst:*)
 ---
-<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.19 — written in this repository for customer accounts -->
+<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.21 — written in this repository for customer accounts -->
 
 # What needs me
 

package/skills/what-this-repo-needs/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   What environment variable names does this repository need, and where does each one come from? Scans the repository offline (no login, no network) and lists the names in three groups (build/test, deploy-only, bindings), each with where it was found, what uses it, and where a local value would come from. Never reads a value or prints one. Also checks the environment variable table in `.catalyst/catalyst.toml` offline. Use when someone asks "what does catalyst.env.json mean", "what env vars does this repo need", "why does the container need this", or before reviewing or writing the declaration.
 allowed-tools: Bash(catalyst:*) Bash(npx -p @catalyst-cloud/cli catalyst:*)
 ---
-<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.19 — written in this repository for customer accounts -->
+<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.21 — written in this repository for customer accounts -->
 
 # What this repository needs