mergestorm 0.3.63 → 0.3.66

package/dist/commands/stack.d.ts

@@ -1,6 +1,6 @@
-import { type StackHeldBlocker, type StackRepairHint } from "../stack-blockers.js";
+import { type StackRepairHint } from "../stack-blockers.js";
 import { type StackWatchObligation } from "../stack-watch-obligation.js";
-import { adoptStack, ensureUpperPark, findStackPull, getEnrichedStack, getStackPublication, listMergeQueueEntries, listStacks, openStackPull, claimStackPulls, setStackPolicy, type StackDto, type StackPolicyPatch } from "../api.js";
+import { adoptStack, ensureUpperPark, findStackPull, getEnrichedStack, getIssueReview, getStackPublication, listMergeQueueEntries, listStacks, openStackPull, claimStackPulls, setStackPolicy, type StackDto, type StackPolicyPatch } from "../api.js";
 import { loadConfig } from "../config.js";
 import { createPrs, findOpenPrNumber } from "../gh.js";
 import { parseGithubOriginRepo } from "../git.js";
@@ -11,9 +11,7 @@ import { gitTopLevel } from "../repo-identity.js";
 import { loadStackMeta, saveStackMeta } from "../stack-meta.js";
 import { pollStackWatch } from "../stack-watch.js";
 import { runStackWatch } from "../stack-watch-loop.js";
-export declare function stackHeldLine(held: StackHeldBlocker | null | undefined): string[];
 export declare function stackRepairLine(repair: StackRepairHint | null | undefined): string[];
-export declare function stackWatchTextLines(watch: StackWatchObligation | null | undefined): string[];
 export declare function openStackWatch(stackId: string, opts?: {
     unread?: boolean;
 }): StackWatchObligation;
@@ -128,6 +126,22 @@ export type StackCreateDeps = {
 };
 export declare function cmdStackCreate(args: string[], deps?: StackCreateDeps): Promise<void>;
 /** Injectable seams for unit tests (STRUCT-04). Production callers omit deps. */
+export declare function issueReviewsEnabledFor(cfg: Awaited<ReturnType<typeof loadConfig>>, owner: string, repo: string): Promise<boolean>;
+export type IssueGateLayer = {
+    branch: string;
+    texts: string[];
+};
+export type IssueGateDeps = {
+    getIssueReview?: typeof getIssueReview;
+    issueReviewsEnabled?: typeof issueReviewsEnabledFor;
+};
+export declare function assertLinkedIssuesApproved(input: {
+    cfg: Awaited<ReturnType<typeof loadConfig>>;
+    owner: string;
+    repo: string;
+    layers: readonly IssueGateLayer[];
+    warn: (line: string) => void;
+}, deps?: IssueGateDeps): Promise<void>;
 export type StackSubmitDeps = {
     cwd?: string;
     gitTopLevel?: (cwd?: string) => string;
@@ -155,7 +169,7 @@ export type StackSubmitDeps = {
     adoptStack?: typeof adoptStack;
     ensureUpperPark?: typeof ensureUpperPark;
     env?: NodeJS.ProcessEnv;
-};
+} & IssueGateDeps;
 export declare function cmdStackSubmit(args: string[], deps?: StackSubmitDeps): Promise<void>;
 export declare function parseStackPublishArgs(args: string[]): {
     branch?: string;
@@ -180,6 +194,7 @@ export declare function cmdStackWatch(args: string[], deps?: {
     loadConfig?: typeof loadConfig;
     runStackWatch?: typeof runStackWatch;
     signal?: AbortSignal;
+    writeMarker?: (line: string) => void;
 }): Promise<void>;
 export declare function cmdStackStatus(args: string[], deps?: {
     loadConfig?: typeof loadConfig;

package/dist/commands/stack.js

@@ -1,17 +1,17 @@
 import { cycloneStatusWords, stackBlockers, stackBlockersSummary } from "../stack-blockers.js";
 import { STACK_WATCH_NOT_DONE_SENTENCE, STACK_WATCH_NOTIFY_PATTERN, stackTerminalReason, stackWatchObligation, } from "../stack-watch-obligation.js";
-import { adoptStack, ensureUpperPark, findStackPull, getEnrichedStack, getStackPublication, landNextStack, listMergeQueueEntries, listStacks, openStackPull, claimStackPulls, restackStack, setStackPolicy, } from "../api.js";
+import { adoptStack, ensureUpperPark, findStackPull, getEnrichedStack, getIssueReview, getSettings, getStackPublication, issueNotApprovedError, landNextStack, listRepoSettings, listMergeQueueEntries, listStacks, openStackPull, claimStackPulls, restackStack, setStackPolicy, } from "../api.js";
 import { loadConfig } from "../config.js";
 import { rateLimitedMessage, REVIEW_EXIT, CommandError } from "../errors.js";
 import { createPrs, findOpenPrNumber, ghReady, githubApiFromEnv, } from "../gh.js";
 import { parseGithubOriginRepo } from "../git.js";
 import { branchExists, commitsAheadOf, createBranchFrom, createBranchFromHead, trunkStartRef, currentBranch, defaultLayerBranchName, deleteBranch, discoverTrunk, fetchRemoteBranch, pushBranch, tipCommitMessage, tipCommitSubject, worktreeDirty, } from "../git-stack.js";
-import { buildPrBodyFromCommit } from "../pr-body.js";
+import { buildPrBodyFromCommit, linkedIssueNumbers } from "../pr-body.js";
 import { publishBranchServerSide, assertExplicitStacking, publishWorkingBranch, workingBranchPublication, } from "../server-publish.js";
 import { gitTopLevel } from "../repo-identity.js";
 import { activeLayers, appendLayer, emptyStackMeta, loadStackMeta, removeActiveStack, resetStackMeta, saveStackMeta, selectStackForCreate, setActivePolicy, } from "../stack-meta.js";
 import { pollStackWatch, StackWatchError, StackWatchTimeoutError, } from "../stack-watch.js";
-import { runStackWatch, STACK_WATCH_EXIT } from "../stack-watch-loop.js";
+import { runStackWatch, STACK_WATCH_EXIT, stackWatchFailedLine } from "../stack-watch-loop.js";
 import { isMgParkBranch, planSubmitLayerBases } from "../submit-pr-base.js";
 import { ansi } from "../ui/ansi.js";
 import { runLineTabsBrowser } from "../ui/line-tabs.js";
@@ -19,7 +19,7 @@ import { present } from "../ui/present.js";
 import { canBrowse } from "./browse.js";
 import { isTransientReviewPollError } from "./review-client.js";
 import { openHelpBrowser } from "./help.js";
-export function stackHeldLine(held) {
+function stackHeldLine(held) {
     if (!held)
         return [];
     const agents = held.waitingOn.map((agent) => agent === "cyclone" ? "Cyclone" : "Vortex").join(" and ");
@@ -32,7 +32,7 @@ export function stackRepairLine(repair) {
     const note = "note" in repair && repair.note ? ` ${repair.note}` : "";
     return [`Repair #${repair.prNumber} ${repair.kind}${files}: ${repair.steps}${note}`];
 }
-export function stackWatchTextLines(watch) {
+function stackWatchTextLines(watch) {
     if (!watch)
         return [];
     if (watch.done)
@@ -62,7 +62,8 @@ const STACK_USAGE = `usage:
   mergestorm stack watch <stack-id> [--until attention|landed] [--ignore <blocker-substring>] [--max <minutes>] [--head <sha>] [--bounce-id <id>] [--after-finished-at <iso>] [--json]
     Loops stack wait with the cursor and stays silent while the stack is waiting or in progress.
     Prints one MS-WATCH ATTENTION line and exits 3 on attention or on reads that keep failing (a permanent
-    error twice, or 15 minutes of timeouts and 5xx, which it retries with backoff); prints MS-WATCH LANDED
+    error twice, or 15 minutes with no stack read: timeouts, 5xx and rate limits, which it retries with backoff).
+    It also prints MS-WATCH ATTENTION failed when it cannot start (bad flags, no config), so it never exits without an MS-WATCH line unless you stop it; prints MS-WATCH LANDED
     and exits 0 only for a confirmed landing, including a stack Mergestorm deleted after its queue entry landed. Other terminal reasons exit 3 with ATTENTION. Run it as a background command.
     An ATTENTION line for a merge queue bounce ends with restart="mg stack watch <id> --bounce-id <id> --after-finished-at <iso>":
     restart with that command (plus --head <sha> after a push) so a bounce you already handled is not reported again.
@@ -679,6 +680,65 @@ export async function cmdStackCreate(args, deps = {}) {
     created.push(ansi.dim("  authoring state: managed automatically outside the repository"));
     await present("Stack", created);
 }
+/** Injectable seams for unit tests (STRUCT-04). Production callers omit deps. */
+export async function issueReviewsEnabledFor(cfg, owner, repo) {
+    const repos = await listRepoSettings(cfg, { timeoutMs: STACK_GUARD_TIMEOUT_MS });
+    const row = repos.find((r) => r.owner.toLowerCase() === owner.toLowerCase() && r.repo.toLowerCase() === repo.toLowerCase());
+    if (typeof row?.issue_review_enabled === "boolean")
+        return row.issue_review_enabled;
+    const settings = await getSettings(cfg, { timeoutMs: STACK_GUARD_TIMEOUT_MS });
+    if (!settings)
+        throw new CommandError("Could not read the account settings");
+    return settings.issue_review_enabled === true;
+}
+export async function assertLinkedIssuesApproved(input, deps = {}) {
+    const { cfg, owner, repo, layers, warn } = input;
+    if (layers.length === 0)
+        return;
+    const getIssueReviewFn = deps.getIssueReview ?? getIssueReview;
+    const unverified = (err) => {
+        if (err instanceof CommandError && (err.code === "auth_invalid" || err.code === "missing_api_key" || err.code === "rate_limited"))
+            return err;
+        return new CommandError(`Could not verify the Vortex reviews of the linked issues (${err instanceof Error ? err.message : String(err)}); ` +
+            "refusing to submit. Retry when the API is reachable.");
+    };
+    const linked = layers.map((layer) => ({ branch: layer.branch, numbers: linkedIssueNumbers({ owner, repo }, ...layer.texts) }));
+    const statuses = [];
+    for (const number of [...new Set(linked.flatMap((layer) => layer.numbers))].sort((a, b) => a - b)) {
+        let status;
+        try {
+            status = await getIssueReviewFn(cfg, { owner, repo, number }, { timeoutMs: STACK_GUARD_TIMEOUT_MS });
+        }
+        catch (err) {
+            throw unverified(err);
+        }
+        if (!status) {
+            warn(ansi.dim("  This Mergestorm server does not check issue reviews yet; submitting without the issue gate."));
+            continue;
+        }
+        statuses.push(status);
+    }
+    const unlinked = linked.filter((layer) => layer.numbers.length === 0);
+    if (unlinked.length > 0) {
+        let enabled;
+        try {
+            enabled = await (deps.issueReviewsEnabled ?? issueReviewsEnabledFor)(cfg, owner, repo);
+        }
+        catch (err) {
+            throw unverified(err);
+        }
+        if (enabled) {
+            throw new CommandError([
+                `Issue reviews are on for ${owner}/${repo}, and ${unlinked.map((layer) => layer.branch).join(", ")} links no issue.`,
+                "Open one with `mergestorm issue create --title <problem> --wait`, answer the Vortex review until it is approved,",
+                "then add `Fixes #N` to the tip commit message and submit again.",
+            ].join("\n"), REVIEW_EXIT.failed, "issue_not_approved");
+        }
+    }
+    const blocking = statuses.filter((status) => status.state !== "approved" && status.state !== "off");
+    if (blocking.length > 0)
+        throw issueNotApprovedError(blocking);
+}
 export async function cmdStackSubmit(args, deps = {}) {
     const { extend, autoLand, autoReview, autoPatch, autoResolveConflicts, autoFixCi, rest, serverSide, asJson } = parseStackSubmitArgs(args);
     const api = rest ? "rest" : githubApiFromEnv(deps.env ?? process.env);
@@ -802,6 +862,21 @@ export async function cmdStackSubmit(args, deps = {}) {
     for (const plan of plans) {
         existingPrs.set(plan.branch, await opener.findOpen(plan.branch));
     }
+    await assertLinkedIssuesApproved({
+        cfg: await loadConfigFn(),
+        owner,
+        repo,
+        layers: plans
+            .filter((plan) => existingPrs.get(plan.branch) == null)
+            .map((plan) => {
+            if (!branchExistsFn(plan.branch, cwd)) {
+                throw new CommandError(`Stack layer branch missing locally: ${plan.branch}`);
+            }
+            const message = tipCommitMessageFn(plan.branch, cwd);
+            return { branch: plan.branch, texts: [message, buildPrBodyFn(message)] };
+        }),
+        warn: progress,
+    }, deps);
     const newHeads = plans
         .filter((plan) => existingPrs.get(plan.branch) == null)
         .map((plan) => plan.branch);
@@ -1213,7 +1288,7 @@ export async function cmdStackWait(args, deps = {}) {
         throw new CommandError(err.message, REVIEW_EXIT.timeout, "review_timeout");
     }
 }
-export async function cmdStackWatch(args, deps = {}) {
+async function startStackWatch(args, deps) {
     const usage = "usage: mergestorm stack watch <stack-id> [--until attention|landed] [--ignore <blocker-substring>] [--max <minutes>] [--head <sha>] [--bounce-id <id>] [--after-finished-at <iso>] [--json]";
     const fail = (detail) => new CommandError(detail ? `${usage}\n${detail}` : usage, REVIEW_EXIT.usage, "usage");
     const positional = [];
@@ -1286,6 +1361,30 @@ export async function cmdStackWatch(args, deps = {}) {
                 ...(afterFinishedAt ? { afterFinishedAt } : {}),
             } } : {}),
     });
+    return { stackId, result };
+}
+export async function cmdStackWatch(args, deps = {}) {
+    let started;
+    try {
+        started = await startStackWatch(args, deps);
+    }
+    catch (err) {
+        const valueFlags = new Set(["--until", "--ignore", "--max", "--head", "--bounce-id", "--after-finished-at"]);
+        let json = false;
+        for (let i = 0; i < args.length; i++) {
+            if (args[i] === "--json")
+                json = true;
+            else if (valueFlags.has(args[i]))
+                i++;
+        }
+        const marker = deps.writeMarker ?? (json ? console.error : console.log);
+        const stackId = args.find((arg, i) => UUID_RE.test(arg.trim()) && !valueFlags.has(args[i - 1]))?.trim() ?? "none";
+        marker(stackWatchFailedLine(stackId, err instanceof Error ? err.message : String(err)));
+        if (json)
+            console.log(JSON.stringify({ stackId, outcome: "failed" }));
+        throw err;
+    }
+    const { stackId, result } = started;
     if (result.exitCode === STACK_WATCH_EXIT.landed)
         return;
     const reason = result.outcome === "timeout"

package/dist/commands/whoami.js

@@ -1,9 +1,8 @@
-import { getMe } from "../api.js";
-import { apiBase, configPath, loadConfig, resolveApiKey } from "../config.js";
+import { accountLabel, getMe } from "../api.js";
+import { apiBase, configPath, listAccounts, loadConfig, resolveApiKey, settleAccountName } from "../config.js";
 import { CommandError } from "../errors.js";
 import { ansi } from "../ui/ansi.js";
 import { present } from "../ui/present.js";
-import { canBrowse, openTabsBrowser } from "./browse.js";
 export async function cmdWhoami(args, opts = {}) {
     const asJson = args.includes("--json");
     const cfg = await loadConfig();
@@ -11,15 +10,17 @@ export async function cmdWhoami(args, opts = {}) {
     if (!key) {
         throw new CommandError("Not logged in. Run `mergestorm login` (agents: `mergestorm login --start`, then `--finish`).");
     }
-    if (!asJson && canBrowse()) {
-        await openTabsBrowser("status");
-        return;
-    }
     const me = await getMe(cfg);
     if (!me) {
         throw new CommandError("Live account details unavailable. Could not verify account with /me.");
     }
+    const account = (await settleAccountName(cfg, me)) ?? accountLabel(me.account);
+    const accounts = (await listAccounts()).map((a) => a.name);
     const payload = {
+        account,
+        accounts,
+        github_login: me.account?.github_login ?? null,
+        email: me.account?.email ?? null,
         key_prefix: me.key.prefix,
         key_name: me.key.name ?? null,
         plan_key: me.plan_key ?? null,
@@ -37,9 +38,12 @@ export async function cmdWhoami(args, opts = {}) {
         console.log(text);
         return;
     }
-    const lines = [
-        `  Key      ${ansi.bold(String(payload.key_prefix))}${payload.key_name ? ` (${payload.key_name})` : ""}`,
-    ];
+    const lines = [`  Account  ${account ? ansi.bold(account) : "unknown (API too old to say)"}`];
+    lines.push(`  Key      ${ansi.bold(String(payload.key_prefix))}${payload.key_name ? ` (${payload.key_name})` : ""}`);
+    const others = accounts.filter((name) => name !== account);
+    if (others.length > 0) {
+        lines.push(`  Others   ${others.join(", ")} ${ansi.dim("· mergestorm account use <name>")}`);
+    }
     if (payload.plan_key) {
         lines.push(`  Plan     ${payload.plan_label_key ?? payload.plan_key}`);
     }

package/dist/config.d.ts

@@ -1,15 +1,69 @@
 export declare const DEFAULT_API = "https://api.mergestorm.ai";
+export declare const ACCOUNT_LIMIT = 3;
 export type Config = {
     apiKey?: string;
     apiBase?: string;
     ignoreEnv?: boolean;
+    account?: string;
+};
+export type StoredAccount = {
+    apiKey: string;
+    apiBase?: string;
+};
+export type AccountStore = {
+    accounts: Record<string, StoredAccount>;
+    activeAccount?: string;
+    apiBase?: string;
+    ignoreEnv?: boolean;
+};
+type StoreFile = AccountStore & {
+    apiKey?: string;
+};
+export type AccountSummary = {
+    name: string;
+    active: boolean;
+    keyPrefix: string;
+    apiBase: string;
+};
+export type NamedMe = {
+    account?: {
+        github_login?: string | null;
+        email?: string | null;
+    } | null;
 };
 export declare function mergestormHome(env?: NodeJS.ProcessEnv): string;
 export declare function configPath(): string;
+export declare function provisionalAccountName(apiKey: string): string;
+export declare function accountNameFromMe(me: NamedMe | null | undefined): string | null;
+export declare function serializeStore(store: AccountStore): StoreFile;
+export declare function migrateStore(raw: unknown): {
+    store: AccountStore;
+    migrated: boolean;
+};
+export declare function writeStore(store: AccountStore): Promise<void>;
+export declare function readStore(): Promise<AccountStore>;
+export declare function withAccount<T>(name: string | undefined, fn: () => Promise<T>): Promise<T>;
+export declare function requestedAccount(store: AccountStore, env?: NodeJS.ProcessEnv): string | undefined;
+export declare function selectAccountName(store: AccountStore, requested: string | undefined): string | undefined;
+export declare function configFor(store: AccountStore, name: string | undefined): Config;
 export declare function loadConfig(): Promise<Config>;
-export declare function saveConfig(cfg: Config): Promise<void>;
-export declare function clearConfig(): Promise<void>;
+export declare function accountLimitMessage(store: AccountStore): string;
+export declare function saveAccount(name: string, account: StoredAccount, opts?: {
+    activate?: boolean;
+}): Promise<AccountStore>;
+export declare function useAccount(name: string): Promise<AccountStore>;
+export declare function removeAccount(name: string): Promise<AccountStore>;
+export declare function renameAccount(from: string, to: string): Promise<AccountStore>;
+export declare function summarizeAccounts(store: AccountStore): AccountSummary[];
+export declare function listAccounts(): Promise<AccountSummary[]>;
+export declare function settleAccountName(cfg: Config, me: NamedMe | null | undefined): Promise<string | undefined>;
+export declare function splitAccountFlag(args: readonly string[]): {
+    account?: string;
+    args: string[];
+};
 export declare function apiBase(cfg: Config): string;
+export declare function resolveChatId(cfg: Config): string | undefined;
 export declare function resolveApiKey(cfg: Config): string | undefined;
 /** Short display form of a stored key (prefix only). */
 export declare function keyDisplay(key: string | undefined): string | null;
+export {};

package/dist/config.js

@@ -1,7 +1,10 @@
-import { mkdir, readFile, writeFile, rm } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
+import { CommandError } from "./errors.js";
 export const DEFAULT_API = "https://api.mergestorm.ai";
+export const ACCOUNT_LIMIT = 3;
+const KEY_PREFIX_LENGTH = "msk_live_".length + 4;
 export function mergestormHome(env = process.env) {
     const override = env.MERGESTORM_HOME?.trim();
     return override ? path.resolve(override) : path.join(homedir(), ".mergestorm");
@@ -9,30 +12,285 @@ export function mergestormHome(env = process.env) {
 export function configPath() {
     return path.join(mergestormHome(), "config.json");
 }
-export async function loadConfig() {
-    try {
-        const raw = await readFile(configPath(), "utf8");
-        return JSON.parse(raw);
+export function provisionalAccountName(apiKey) {
+    return apiKey.slice(0, KEY_PREFIX_LENGTH);
+}
+export function accountNameFromMe(me) {
+    const login = me?.account?.github_login?.trim();
+    if (login)
+        return login;
+    const email = me?.account?.email?.trim();
+    return email || null;
+}
+function cleanString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function compact(store) {
+    const out = { accounts: store.accounts };
+    if (store.activeAccount && store.accounts[store.activeAccount])
+        out.activeAccount = store.activeAccount;
+    if (store.apiBase)
+        out.apiBase = store.apiBase;
+    if (store.ignoreEnv)
+        out.ignoreEnv = true;
+    return out;
+}
+function storedAccount(apiKey, apiBase) {
+    return apiBase ? { apiKey, apiBase } : { apiKey };
+}
+export function serializeStore(store) {
+    const out = compact(store);
+    const active = out.activeAccount ? out.accounts[out.activeAccount] : undefined;
+    if (!active)
+        return out;
+    out.apiKey = active.apiKey;
+    if (active.apiBase)
+        out.apiBase = active.apiBase;
+    else
+        delete out.apiBase;
+    return out;
+}
+export function migrateStore(raw) {
+    const obj = raw && typeof raw === "object" ? raw : {};
+    const ignoreEnv = obj.ignoreEnv === true ? true : undefined;
+    const apiBase = cleanString(obj.apiBase);
+    const apiKey = cleanString(obj.apiKey);
+    if (obj.accounts && typeof obj.accounts === "object") {
+        const accounts = {};
+        for (const [name, value] of Object.entries(obj.accounts)) {
+            const entry = value && typeof value === "object" ? value : {};
+            const key = cleanString(entry.apiKey);
+            if (!key)
+                continue;
+            accounts[name] = storedAccount(key, cleanString(entry.apiBase));
+        }
+        const requested = cleanString(obj.activeAccount);
+        let activeAccount = requested && Object.hasOwn(accounts, requested) ? requested : Object.keys(accounts)[0];
+        let migrated = false;
+        if (apiKey) {
+            const owner = Object.keys(accounts).find((name) => accounts[name].apiKey === apiKey);
+            if (!owner) {
+                if (Object.keys(accounts).length < ACCOUNT_LIMIT) {
+                    const name = provisionalAccountName(apiKey);
+                    accounts[name] = storedAccount(apiKey, apiBase);
+                    activeAccount = name;
+                    migrated = true;
+                }
+            }
+            else if (owner !== activeAccount) {
+                activeAccount = owner;
+                migrated = true;
+            }
+        }
+        else if (activeAccount) {
+            migrated = true;
+        }
+        const store = compact({ accounts, activeAccount, apiBase: activeAccount ? undefined : apiBase, ignoreEnv });
+        return { store, migrated };
     }
-    catch {
-        return {};
+    if (!apiKey) {
+        return { store: compact({ accounts: {}, apiBase, ignoreEnv }), migrated: Object.keys(obj).length > 0 };
     }
+    const name = provisionalAccountName(apiKey);
+    return {
+        store: compact({ accounts: { [name]: storedAccount(apiKey, apiBase) }, activeAccount: name, ignoreEnv }),
+        migrated: true,
+    };
 }
-export async function saveConfig(cfg) {
-    const dir = path.dirname(configPath());
-    await mkdir(dir, { recursive: true });
-    await writeFile(configPath(), JSON.stringify(cfg, null, 2) + "\n", {
+export async function writeStore(store) {
+    const file = configPath();
+    await mkdir(path.dirname(file), { recursive: true });
+    await writeFile(file, JSON.stringify(serializeStore(store), null, 2) + "\n", {
         encoding: "utf8",
         mode: 0o600,
     });
 }
-export async function clearConfig() {
-    await rm(configPath(), { force: true });
+export async function readStore() {
+    let raw;
+    try {
+        raw = JSON.parse(await readFile(configPath(), "utf8"));
+    }
+    catch {
+        return { accounts: {} };
+    }
+    const { store, migrated } = migrateStore(raw);
+    if (migrated) {
+        try {
+            await writeStore(store);
+        }
+        catch {
+            return store;
+        }
+    }
+    return store;
+}
+function accountNames(store) {
+    return Object.keys(store.accounts);
+}
+function unknownAccountMessage(name, store) {
+    const names = accountNames(store);
+    if (names.length === 0) {
+        return `No account named "${name}". Nobody is logged in; run \`mergestorm login\`.`;
+    }
+    return `No account named "${name}". Accounts: ${names.join(", ")}.`;
+}
+let accountOverride;
+export async function withAccount(name, fn) {
+    if (!name)
+        return fn();
+    const previous = accountOverride;
+    accountOverride = name;
+    try {
+        return await fn();
+    }
+    finally {
+        accountOverride = previous;
+    }
+}
+export function requestedAccount(store, env = process.env) {
+    if (accountOverride)
+        return accountOverride;
+    if (store.ignoreEnv)
+        return undefined;
+    return env.MERGESTORM_ACCOUNT?.trim() || undefined;
+}
+export function selectAccountName(store, requested) {
+    if (!requested)
+        return store.activeAccount;
+    if (Object.hasOwn(store.accounts, requested))
+        return requested;
+    throw new CommandError(unknownAccountMessage(requested, store));
+}
+export function configFor(store, name) {
+    const account = name ? store.accounts[name] : undefined;
+    const cfg = {};
+    if (account && name) {
+        cfg.apiKey = account.apiKey;
+        cfg.account = name;
+    }
+    const base = account?.apiBase ?? store.apiBase;
+    if (base)
+        cfg.apiBase = base;
+    if (store.ignoreEnv)
+        cfg.ignoreEnv = true;
+    return cfg;
+}
+export async function loadConfig() {
+    const store = await readStore();
+    return configFor(store, selectAccountName(store, requestedAccount(store)));
+}
+export function accountLimitMessage(store) {
+    return `Already ${ACCOUNT_LIMIT} accounts: ${accountNames(store).join(", ")}. Remove one with \`mergestorm account remove <name>\` first.`;
+}
+export async function saveAccount(name, account, opts = {}) {
+    const store = await readStore();
+    if (!Object.hasOwn(store.accounts, name) && accountNames(store).length >= ACCOUNT_LIMIT) {
+        throw new CommandError(accountLimitMessage(store), 1, "account_limit");
+    }
+    store.accounts[name] = storedAccount(account.apiKey, account.apiBase);
+    if (opts.activate || !store.activeAccount)
+        store.activeAccount = name;
+    await writeStore(store);
+    return store;
+}
+export async function useAccount(name) {
+    const store = await readStore();
+    if (!Object.hasOwn(store.accounts, name))
+        throw new CommandError(unknownAccountMessage(name, store));
+    store.activeAccount = name;
+    await writeStore(store);
+    return store;
+}
+export async function removeAccount(name) {
+    const store = await readStore();
+    if (!Object.hasOwn(store.accounts, name))
+        throw new CommandError(unknownAccountMessage(name, store));
+    delete store.accounts[name];
+    if (store.activeAccount === name)
+        store.activeAccount = accountNames(store)[0];
+    await writeStore(store);
+    return store;
+}
+export async function renameAccount(from, to) {
+    const store = await readStore();
+    const account = store.accounts[from];
+    if (!account || from === to)
+        return store;
+    if (Object.hasOwn(store.accounts, to)) {
+        throw new CommandError(`An account named "${to}" already exists, so ${from} keeps its name.`);
+    }
+    delete store.accounts[from];
+    store.accounts[to] = account;
+    if (store.activeAccount === from)
+        store.activeAccount = to;
+    await writeStore(store);
+    return store;
+}
+export function summarizeAccounts(store) {
+    return Object.entries(store.accounts).map(([name, account]) => ({
+        name,
+        active: name === store.activeAccount,
+        keyPrefix: provisionalAccountName(account.apiKey),
+        apiBase: (account.apiBase ?? store.apiBase ?? DEFAULT_API).replace(/\/$/, ""),
+    }));
+}
+export async function listAccounts() {
+    return summarizeAccounts(await readStore());
+}
+export async function settleAccountName(cfg, me) {
+    if (!cfg.account || !cfg.apiKey || resolveApiKey(cfg) !== cfg.apiKey)
+        return cfg.account;
+    if (cfg.account !== provisionalAccountName(cfg.apiKey))
+        return cfg.account;
+    const name = accountNameFromMe(me);
+    if (!name || name === cfg.account)
+        return cfg.account;
+    try {
+        await renameAccount(cfg.account, name);
+    }
+    catch {
+        return cfg.account;
+    }
+    return name;
+}
+export function splitAccountFlag(args) {
+    const rest = [];
+    let account;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        let value;
+        if (arg === "--account") {
+            value = args[i + 1];
+            if (value === undefined || value.startsWith("-"))
+                value = "";
+            else
+                i += 1;
+        }
+        else if (arg.startsWith("--account=")) {
+            value = arg.slice("--account=".length);
+        }
+        else {
+            rest.push(arg);
+            continue;
+        }
+        if (!value.trim()) {
+            throw new CommandError("--account needs an account name. `mergestorm account list` shows them.", 1, "usage");
+        }
+        account = value.trim();
+    }
+    return account ? { account, args: rest } : { args: rest };
 }
 export function apiBase(cfg) {
     const fromEnv = cfg.ignoreEnv ? undefined : process.env.MERGESTORM_API_URL?.trim();
     return (fromEnv || cfg.apiBase || DEFAULT_API).replace(/\/$/, "");
 }
+const CHAT_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function resolveChatId(cfg) {
+    if (cfg.ignoreEnv)
+        return undefined;
+    const chatId = process.env.MERGESTORM_CHAT_ID?.trim() ?? "";
+    return CHAT_ID.test(chatId) ? chatId.toLowerCase() : undefined;
+}
 export function resolveApiKey(cfg) {
     if (cfg.ignoreEnv)
         return cfg.apiKey;

package/dist/errors.d.ts

@@ -2,7 +2,7 @@
  * Stable machine codes for CommandError control flow.
  * UX copy in `message` may change freely; match on `code`, never on message text.
  */
-export type CommandErrorCode = "auth_invalid" | "api_timeout" | "not_a_repo" | "not_found" | "missing_api_key" | "registered_parent" | "implicit_stack" | "usage" | "review_quota" | "review_failed" | "review_timeout" | "rate_limited" | "cyclone_not_installed" | "pr_merged" | "pr_closed" | "not_stacked" | "draft" | "reserved_branch" | "supabase_unconfigured" | "cyclone_not_connected" | "cyclone_permission_missing" | "busy" | "adopt_failed" | "github_unreadable" | "stack_attention" | "head_changed" | "base_changed" | "tree_mismatch" | "protected_branch" | "payload_too_large" | "unsupported_publication" | "publication_failed" | "unknown_label";
+export type CommandErrorCode = "auth_invalid" | "api_timeout" | "not_a_repo" | "not_found" | "missing_api_key" | "registered_parent" | "implicit_stack" | "usage" | "review_quota" | "review_failed" | "review_timeout" | "rate_limited" | "cyclone_not_installed" | "pr_merged" | "pr_closed" | "not_stacked" | "draft" | "reserved_branch" | "supabase_unconfigured" | "cyclone_not_connected" | "account_limit" | "surge_other_account" | "cyclone_permission_missing" | "busy" | "adopt_failed" | "github_unreadable" | "stack_attention" | "head_changed" | "base_changed" | "tree_mismatch" | "protected_branch" | "payload_too_large" | "unsupported_publication" | "publication_failed" | "git_failed" | "unknown_label" | "invalid_input" | "memory_off" | "memory_full" | "memory_similar" | "memory_unavailable" | "web_unavailable" | "issue_not_approved" | "issue_review_unavailable";
 /** Stable one-shot exit codes for machine callers of `mergestorm review`. */
 export declare const REVIEW_EXIT: {
     readonly success: 0;