@catalyst-cloud/cli 0.14.10 → 0.15.0

package/dist/onboard-runtime.js

@@ -3,7 +3,7 @@ import { userInfo } from "node:os";
 import { join } from "node:path";
 import { openConsentBrowser } from "./consent-browser.js";
 import { defaultSkillsDirFor, loadConfig, normalizeBaseUrl, readManifest, } from "./config.js";
-import { CliError } from "./errors.js";
+import { CliError, UsageError } from "./errors.js";
 import { cmdLegacy, findLegacy } from "./legacy.js";
 import { personalConsentAdapter } from "./onboard-personal.js";
 import { boundedOnboardSignin } from "./onboard-signin.js";
@@ -11,6 +11,7 @@ import { existingLinearAdapters } from "./onboard-existing.js";
 import { linearWorkspaceAdapter } from "./onboard-workspace.js";
 import { firstProjectAdapters } from "./onboard-projects.js";
 import { onboardCapacityAdapter } from "./onboard-capacity.js";
+import { onboardRunnerAdapter } from "./onboard-runner.js";
 import { onboardAutomationManagementAdapter } from "./onboard-automation-management.js";
 import { onboardWorkflowVerificationAdapter } from "./onboard-workflow.js";
 import { onboardAccountsAdapter } from "./onboard-accounts.js";
@@ -32,6 +33,8 @@ function sameHome(a, b) {
 }
 /** Only existing bearer routes are registered here. Missing server capabilities stay unfinished. */
 export function createOnboardRuntime(args, ctx, hooks) {
+    if (args.flags.runner === true && args.flags["no-runner"] === true)
+        throw new UsageError("choose one of --runner and --no-runner");
     const identity = async (stepCtx = ctx, journal) => {
         const cfg = loadConfig(stepCtx.home);
         if (!cfg)
@@ -128,17 +131,24 @@ export function createOnboardRuntime(args, ctx, hooks) {
             evidence: { found, remaining: found },
         };
     };
+    const interactiveWait = hooks.ui &&
+        hooks.ui.interactive !== false &&
+        !args.json &&
+        args.flags.yes !== true &&
+        args.flags.headless !== true;
     const personalAdapter = (provider) => personalConsentAdapter({
         provider,
         openBrowser: hooks.openBrowser ?? openConsentBrowser,
         sleep: hooks.sleep,
-        wait: hooks.ui
+        wait: interactiveWait
             ? (message, run) => hooks.ui.wait(message, run)
             : undefined,
     });
     const linear = existingLinearAdapters(args, hooks.ui?.chooseTeam
-        ? (teams) => hooks.ui.chooseTeam(teams.map((team) => ({ ...team })))
-        : undefined);
+        ? (teams, create) => hooks.ui.chooseTeam(teams.map((team) => ({ ...team })), create)
+        : undefined, hooks.ui?.nameNewTeam
+        ? (question) => hooks.ui.nameNewTeam(question)
+        : undefined, (text) => (hooks.ui ? hooks.ui.message(text) : ctx.stderr(text)));
     const adapters = {
         machine: {
             check: async () => process.platform === "darwin" || process.platform === "linux"
@@ -207,14 +217,14 @@ export function createOnboardRuntime(args, ctx, hooks) {
         "linear.workspace": linearWorkspaceAdapter({
             fallback: linear["linear.workspace"],
             openBrowser: hooks.openBrowser ?? openConsentBrowser,
-            wait: hooks.ui
+            wait: interactiveWait
                 ? (message, work) => hooks.ui.wait(message, work)
                 : undefined,
             sleep: hooks.sleep,
         }),
         "github.install": githubInstallationAdapter({
             openBrowser: hooks.openBrowser ?? openConsentBrowser,
-            wait: hooks.ui
+            wait: interactiveWait
                 ? (message, work) => hooks.ui.wait(message, work)
                 : undefined,
             sleep: hooks.sleep,
@@ -238,17 +248,47 @@ export function createOnboardRuntime(args, ctx, hooks) {
             message: (text) => (hooks.ui ? hooks.ui.message(text) : ctx.stderr(text)),
         }),
         accounts: onboardAccountsAdapter({
+            ...(hooks.ui &&
+                hooks.ui.interactive !== false &&
+                !args.json &&
+                args.flags.yes !== true &&
+                args.flags.headless !== true
+                ? {
+                    waitForAccount: (work) => hooks.ui.wait("Waiting for a coding account", work),
+                    sleep: hooks.sleep,
+                }
+                : {}),
             message: (text) => (hooks.ui ? hooks.ui.message(text) : ctx.stderr(text)),
+            ...(typeof args.flags["coding-account"] === "string"
+                ? { slot: args.flags["coding-account"] }
+                : {}),
         }),
         capacity: onboardCapacityAdapter({
             message: (text) => (hooks.ui ? hooks.ui.message(text) : ctx.stderr(text)),
         }),
-        "linear.adopt": onboardWorkflowVerificationAdapter({
+        runner: onboardRunnerAdapter({
+            selected: args.flags.runner === true
+                ? true
+                : args.flags["no-runner"] === true
+                    ? false
+                    : undefined,
+            choose: hooks.ui?.chooseRunner
+                ? () => hooks.ui.chooseRunner()
+                : undefined,
+            engine: hooks.runnerEngine,
+            sleep: hooks.sleep,
             message: (text) => (hooks.ui ? hooks.ui.message(text) : ctx.stderr(text)),
         }),
-        "linear.automations": onboardAutomationManagementAdapter({
+        "linear.adopt": onboardWorkflowVerificationAdapter({
             message: (text) => (hooks.ui ? hooks.ui.message(text) : ctx.stderr(text)),
+            ...(hooks.ui?.confirmWorkflowAdoption
+                ? {
+                    confirm: (team, lines) => hooks.ui.confirmWorkflowAdoption(team, lines),
+                }
+                : {}),
+            yes: args.flags.yes === true,
         }),
+        "linear.automations": onboardAutomationManagementAdapter(),
         "linear.personal": personalAdapter("linear"),
         "github.personal": personalAdapter("github"),
         daemon: {

package/dist/onboard-standalone-copy.js

@@ -0,0 +1,110 @@
+import { setupStepView, SETUP_NUMBERS } from "./setup-onboard-copy.js";
+export const COMPUTER_CHECKS = ["machine", "cli", "skills", "legacy"];
+const PLAN = [
+    ["On this computer", "signin", "you approve once in your browser"],
+    [
+        "On this computer",
+        "housekeeping",
+        "schedule the daily update, where supported",
+    ],
+    [
+        "In Linear and GitHub",
+        "linear.workspace",
+        "an admin connects the workspace",
+    ],
+    [
+        "In Linear and GitHub",
+        "linear.personal",
+        "you connect your own Linear account",
+    ],
+    ["In Linear and GitHub", "linear.team", "you choose the team"],
+    [
+        "In Linear and GitHub",
+        "linear.adopt",
+        "review any states and labels to add",
+    ],
+    [
+        "In Linear and GitHub",
+        "linear.automations",
+        "check how pull requests change issue states",
+    ],
+    [
+        "In Linear and GitHub",
+        "github.install",
+        "an admin chooses access on GitHub",
+    ],
+    [
+        "In Linear and GitHub",
+        "github.personal",
+        "you connect your own GitHub account",
+    ],
+    [
+        "In Linear and GitHub",
+        "github.repos",
+        "you choose where Catalyst can work",
+    ],
+    ["Work", "accounts", "check a coding account"],
+    ["Work", "capacity", "check which runners can take work"],
+    ["Work", "settings", "you review settings before saving them"],
+    ["Work", "first-ticket", "you choose a ticket to start"],
+];
+export function standalonePlan(journal, scope, runnerSelected = false) {
+    const includes = (id) => !scope || scope.includes(id);
+    const steps = new Map(journal.steps.map((step) => [step.id, step]));
+    const rows = [];
+    if (COMPUTER_CHECKS.some((id) => includes(id)))
+        rows.push({
+            group: "On this computer",
+            number: 1,
+            title: "Check this computer",
+            detail: includes("legacy")
+                ? "check the command and skills; remove any earlier Catalyst install and keep its data folders"
+                : "check the selected machine requirements",
+        });
+    for (const [group, id, detail] of PLAN) {
+        if (!includes(id) &&
+            !(id === "capacity" && includes("runner")) &&
+            !(id === "settings" && includes("values")))
+            continue;
+        const reviewedDetail = id === "capacity" && includes("runner") && runnerSelected
+            ? "start a Catalyst runner here with Docker"
+            : id === "capacity" && !includes("capacity")
+                ? "review the optional runner on this machine; start only if selected"
+                : detail;
+        rows.push({
+            group,
+            number: SETUP_NUMBERS[id],
+            title: setupStepView({ id, state: "pending" }).title,
+            detail: steps.get(id)?.state === "done"
+                ? `check again; ${reviewedDetail}`
+                : reviewedDetail,
+        });
+    }
+    return rows;
+}
+export function pendingContinuation(journal) {
+    const unfinished = (...ids) => ids.some((id) => {
+        const step = journal.steps.find((step) => step.id === id);
+        return (step &&
+            step.state !== "done" &&
+            setupStepView(step, journal).mark !== "skip");
+    });
+    const next = [];
+    if (unfinished("github.repos", "projects"))
+        next.push("chooses repositories");
+    if (unfinished("accounts"))
+        next.push("checks a coding account");
+    if (unfinished("capacity", "runner"))
+        next.push("checks runners");
+    if (unfinished("settings", "values"))
+        next.push("reviews repository settings");
+    if (unfinished("first-ticket"))
+        next.push("starts a first ticket");
+    if (!next.length)
+        return null;
+    const last = next.pop();
+    return `Then setup ${next.length ? `${next.join(", ")} and ` : ""}${last}.`;
+}
+export function standalonePlanNotes(localSync) {
+    return `${localSync ? "Local sync is selected." : "Local sync stays off, so Catalyst reads from the cloud."} Checking a coding account sends Claude one short request, which counts toward its usage. Completed steps are checked again before work starts. Codex credentials are not refreshed. Your code, git settings and other skills stay as they are.`;
+}

package/dist/onboard-team-create.js

@@ -0,0 +1,267 @@
+import { loadConfig, normalizeBaseUrl } from "./config.js";
+import { verifyOnboardRoutes } from "./onboard-capabilities.js";
+import { onboardStatePath, writeOnboardJournal, } from "./onboard.js";
+/** The picker's value for "Create a new Linear team…". Never a team ID: those start with a letter or digit. */
+export const CREATE_TEAM_CHOICE = ":create";
+export const TEAM_CREATE_PATH = "/api/v1/agent/linear/team";
+export const MEMBER_CANNOT_CREATE = "Creating a Linear team needs a Catalyst workspace owner or admin.";
+// eslint-disable-next-line no-control-regex -- the point is to find control characters
+const CONTROL = /[\u0000-\u001f\u007f-\u009f]/;
+const KEY = /^[A-Z][A-Z0-9]{0,6}$/;
+/** Why a team name cannot be used, or undefined when it can. */
+export function teamNameProblem(value) {
+    const name = (value ?? "").trim();
+    return !name || name.length > 80 || CONTROL.test(name)
+        ? "Enter a team name of 1 to 80 characters."
+        : undefined;
+}
+/** Why a team key cannot be used, or undefined when it can. Lower case is accepted and upper-cased. */
+export function teamKeyProblem(value) {
+    return KEY.test((value ?? "").trim().toUpperCase())
+        ? undefined
+        : "A key starts with a letter and has up to 7 letters or digits, like MOB.";
+}
+/** A key suggested from the name: the initials of a several-word name, or a one-word name's first three letters. */
+export function suggestTeamKey(name) {
+    const words = name
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toUpperCase()
+        .split(/[^A-Z0-9]+/)
+        .filter(Boolean);
+    const raw = words.length > 1
+        ? words.map((word) => word[0]).join("")
+        : (words[0] ?? "").slice(0, 3);
+    const key = raw.replace(/^[0-9]+/, "").slice(0, 5);
+    return key || "TEAM";
+}
+/** The picker's create option for this person, or undefined when this cloud does not offer it. */
+export async function teamCreateOffer(ctx, journal, signal) {
+    const support = await verifyOnboardRoutes(ctx, journal, [{ method: "POST", path: TEAM_CREATE_PATH }], signal);
+    if ("reason" in support)
+        return undefined;
+    const role = loadConfig(ctx.home)?.user?.role;
+    return role === "owner" || role === "admin"
+        ? { available: true }
+        : { available: false, reason: MEMBER_CANNOT_CREATE };
+}
+const idPattern = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : null;
+// Server text reaches the terminal only without control characters, and bounded.
+const text = (value, fallback) => typeof value === "string" && value.trim()
+    ? value.replace(/[\u0000-\u001f\u007f-\u009f]/g, "").slice(0, 240)
+    : fallback;
+/** POST the new team. Every outcome is named; nothing here selects a team. */
+export async function postNewTeam(ctx, journal, answer, external, uncertainKey) {
+    const cfg = loadConfig(ctx.home);
+    if (!cfg?.user ||
+        cfg.account !== (journal.account ?? journal.tenant) ||
+        cfg.user.id !== journal.membershipId ||
+        !journal.baseUrl ||
+        normalizeBaseUrl(cfg.baseUrl) !== normalizeBaseUrl(journal.baseUrl))
+        return { kind: "failed", reason: "team_create_identity_unverified" };
+    const expiry = cfg.auth
+        ? Date.parse(cfg.auth.expiresAt) - ctx.now().getTime()
+        : 0;
+    const bearer = cfg.key ||
+        (cfg.auth && Number.isFinite(expiry) && expiry > 30_000
+            ? cfg.auth.accessToken
+            : undefined);
+    if (!bearer)
+        return { kind: "failed", reason: "team_read_login_refresh_required" };
+    const key = answer.key.trim().toUpperCase();
+    const previous = journal.steps.find((step) => step.id === "linear.team");
+    const recoveryKey = uncertainKey ??
+        (previous?.reason === "team_create_unverified" &&
+            typeof previous.evidence?.teamKey === "string"
+            ? previous.evidence.teamKey
+            : undefined);
+    // Resolve the outstanding result before allowing a different key to create a second team.
+    if (recoveryKey && recoveryKey !== key)
+        return {
+            kind: "failed",
+            reason: "team_create_unverified",
+            key: recoveryKey,
+        };
+    const owned = new AbortController();
+    const signal = external
+        ? AbortSignal.any([external, owned.signal])
+        : owned.signal;
+    // Creating a team and adopting the workflow on it is several Linear writes; allow longer than a read.
+    const timer = setTimeout(() => owned.abort(), 60_000);
+    let remove = () => { };
+    let sent = false;
+    try {
+        return await new Promise((resolve) => {
+            const stopped = () => resolve({
+                kind: "failed",
+                reason: sent || recoveryKey ? "team_create_unverified" : "interrupted",
+                ...(sent || recoveryKey ? { key: recoveryKey ?? key } : {}),
+            });
+            if (signal.aborted) {
+                stopped();
+                return;
+            }
+            signal.addEventListener("abort", stopped, { once: true });
+            remove = () => signal.removeEventListener("abort", stopped);
+            Promise.resolve()
+                .then(async () => {
+                if (signal.aborted)
+                    return { kind: "failed", reason: "interrupted" };
+                // Save before sending: SIGINT and a killed process must leave the attempted key on disk.
+                const pending = {
+                    id: "linear.team",
+                    state: "waiting",
+                    reason: "team_create_unverified",
+                    evidence: { teamKey: key },
+                    at: ctx.now().toISOString(),
+                };
+                const index = journal.steps.findIndex((step) => step.id === "linear.team");
+                if (index === -1)
+                    journal.steps.push(pending);
+                else
+                    journal.steps[index] = pending;
+                writeOnboardJournal(onboardStatePath(ctx.home, ctx.env), journal);
+                sent = true;
+                const response = await ctx.fetch(`${normalizeBaseUrl(cfg.baseUrl)}${TEAM_CREATE_PATH}`, {
+                    method: "POST",
+                    redirect: "error",
+                    signal,
+                    headers: {
+                        authorization: `Bearer ${bearer}`,
+                        "content-type": "application/json",
+                        accept: "application/json",
+                    },
+                    body: JSON.stringify({
+                        name: answer.name.trim(),
+                        key,
+                    }),
+                });
+                const body = object(await response.json().catch(() => null)) ?? {};
+                const reply = recoveryKey &&
+                    response.status === 409 &&
+                    (body.error === "key-taken" || body.error === "name-taken")
+                    ? {
+                        kind: "failed",
+                        reason: "team_create_unverified",
+                        key,
+                    }
+                    : readReply(response.status, body, key);
+                if (signal.aborted)
+                    return { kind: "failed", reason: "team_create_unverified", key };
+                if (reply.kind === "created") {
+                    // Preserve a confirmed creation too, in case interruption happens during inventory readback.
+                    journal.steps[index === -1 ? journal.steps.length - 1 : index] = {
+                        id: "linear.team",
+                        state: "waiting",
+                        reason: "team_created_not_adopted",
+                        evidence: { team: reply.team.id, teamKey: reply.team.key },
+                        at: ctx.now().toISOString(),
+                    };
+                }
+                else if (!recoveryKey && !(reply.kind === "failed" && reply.key)) {
+                    journal.steps[index === -1 ? journal.steps.length - 1 : index] = {
+                        id: "linear.team",
+                        state: "running",
+                        at: ctx.now().toISOString(),
+                    };
+                }
+                writeOnboardJournal(onboardStatePath(ctx.home, ctx.env), journal);
+                return reply;
+            })
+                .then((reply) => (signal.aborted ? stopped() : resolve(reply)), () => signal.aborted
+                ? stopped()
+                : resolve({
+                    kind: "failed",
+                    reason: "team_create_unverified",
+                    key,
+                }));
+        });
+    }
+    finally {
+        clearTimeout(timer);
+        remove();
+        owned.abort();
+    }
+}
+function readReply(status, body, key) {
+    if (status === 201) {
+        const team = object(body.team);
+        const adoption = object(body.adoption);
+        if (!team ||
+            typeof team.id !== "string" ||
+            !idPattern.test(team.id) ||
+            typeof team.key !== "string" ||
+            !/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(team.key) ||
+            typeof team.name !== "string" ||
+            (adoption?.outcome !== "adopted" && adoption?.outcome !== "not-adopted"))
+            // The team exists but this answer cannot be trusted to say which it is or how far Adopt got.
+            return { kind: "failed", reason: "team_create_unverified", key };
+        return {
+            kind: "created",
+            team: { id: team.id, key: team.key, name: text(team.name, team.key) },
+            adoption: adoption.outcome === "adopted"
+                ? { adopted: true }
+                : {
+                    adopted: false,
+                    reason: text(adoption.reason, "the adoption did not complete"),
+                },
+        };
+    }
+    // Only an answer about the name or key itself asks for another one. Anything else re-asked here
+    // would loop a person through the naming prompt for a problem a new name cannot fix.
+    if ((status === 409 &&
+        (body.error === "key-taken" || body.error === "name-taken")) ||
+        (status === 400 &&
+            (body.error === "invalid-name" || body.error === "invalid-key")) ||
+        (status === 422 && body.error === "linear-rejected"))
+        return {
+            kind: "reask",
+            message: text(body.linearMessage ?? body.message, "Linear did not accept that team. Choose another name or key."),
+        };
+    if (status === 403 && body.error === "linear-refused")
+        return {
+            kind: "refused",
+            message: text(body.message, "Linear did not let you create a team. Ask a workspace admin, or create the team in Linear, then pick it here."),
+            ...(typeof body.linearMessage === "string"
+                ? { linearMessage: text(body.linearMessage, "") }
+                : {}),
+        };
+    if (status === 403 && body.error === "not-an-admin")
+        return { kind: "refused", message: MEMBER_CANNOT_CREATE };
+    // The person's own Linear authorization: missing, unknown or lapsed. Nothing was created.
+    if ((status === 400 || status === 401) &&
+        (body.error === "no-grant" ||
+            body.error === "identity-unknown" ||
+            body.error === "expired"))
+        return {
+            kind: "failed",
+            reason: "team_create_grant_required",
+            message: text(body.reason, ""),
+        };
+    // Linear's answer was lost and the team could not be read back: it may exist.
+    if (status === 502 && body.error === "linear-unconfirmed")
+        return {
+            kind: "failed",
+            reason: "team_create_unverified",
+            message: text(body.message, ""),
+            key,
+        };
+    // Only the route's explicit no-create outcomes permit a fresh attempt. A proxy, timeout or
+    // Worker failure can lose the answer after the mutation, so an unnamed response is uncertain.
+    if ((status === 503 && body.error === "linear-unavailable") ||
+        (status === 404 && body.error === "team-create-unavailable") ||
+        (status === 502 && body.error === "linear-schema-error"))
+        return {
+            kind: "failed",
+            reason: "team_create_unavailable",
+            message: text(body.message ?? body.reason, ""),
+        };
+    return {
+        kind: "failed",
+        reason: "team_create_unverified",
+        key,
+    };
+}