mergestorm-mcp 0.2.25 → 0.2.27

package/dist/lib/tools/stack-publish.d.ts

@@ -0,0 +1,78 @@
+import { publishWorkingBranch, workingBranchPublication, type Config } from "mergestorm/client";
+import { z } from "zod";
+import type { ToolPayload } from "./types.js";
+export declare const stackPublishSchema: {
+    base: z.ZodOptional<z.ZodString>;
+    extend: z.ZodOptional<z.ZodBoolean>;
+    title: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodString>;
+    replace_head: z.ZodOptional<z.ZodString>;
+    auto_land: z.ZodOptional<z.ZodBoolean>;
+    cwd: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    repo: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+};
+export declare const stackPublishStatusSchema: {
+    cwd: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    repo: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+};
+declare const publishInput: z.ZodObject<{
+    base: z.ZodOptional<z.ZodString>;
+    extend: z.ZodOptional<z.ZodBoolean>;
+    title: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodString>;
+    replace_head: z.ZodOptional<z.ZodString>;
+    auto_land: z.ZodOptional<z.ZodBoolean>;
+    cwd: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    repo: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    owner?: string | undefined;
+    title?: string | undefined;
+    body?: string | undefined;
+    repo?: string | undefined;
+    cwd?: string | undefined;
+    branch?: string | undefined;
+    auto_land?: boolean | undefined;
+    base?: string | undefined;
+    extend?: boolean | undefined;
+    replace_head?: string | undefined;
+}, {
+    owner?: string | undefined;
+    title?: string | undefined;
+    body?: string | undefined;
+    repo?: string | undefined;
+    cwd?: string | undefined;
+    branch?: string | undefined;
+    auto_land?: boolean | undefined;
+    base?: string | undefined;
+    extend?: boolean | undefined;
+    replace_head?: string | undefined;
+}>;
+declare const statusInput: z.ZodObject<{
+    cwd: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    repo: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    owner?: string | undefined;
+    repo?: string | undefined;
+    cwd?: string | undefined;
+    branch?: string | undefined;
+}, {
+    owner?: string | undefined;
+    repo?: string | undefined;
+    cwd?: string | undefined;
+    branch?: string | undefined;
+}>;
+export type StackPublishInput = z.infer<typeof publishInput>;
+export type StackPublishStatusInput = z.infer<typeof statusInput>;
+type PublishDeps = Parameters<typeof publishWorkingBranch>[1];
+type StatusDeps = Parameters<typeof workingBranchPublication>[1];
+export declare function stackPublish(input: StackPublishInput, cfg?: Config, deps?: PublishDeps): Promise<ToolPayload>;
+export declare function stackPublishStatus(input: StackPublishStatusInput, cfg?: Config, deps?: StatusDeps): Promise<ToolPayload>;
+export {};

package/dist/lib/tools/stack-publish.js

@@ -0,0 +1,89 @@
+import { CommandError, publishWorkingBranch, stackWatchObligation, workingBranchPublication, } from "mergestorm/client";
+import { z } from "zod";
+import { withWatchText } from "./stack-wait.js";
+const target = {
+    cwd: z.string().trim().min(1).optional(),
+    owner: z.string().trim().min(1).optional(),
+    repo: z.string().trim().min(1).optional(),
+    branch: z.string().trim().min(1).optional(),
+};
+export const stackPublishSchema = {
+    ...target,
+    base: z.string().trim().min(1).optional(),
+    extend: z.boolean().optional(),
+    title: z.string().trim().min(1).max(256).optional(),
+    body: z.string().max(60_000).optional(),
+    replace_head: z.string().regex(/^[0-9a-f]{40}$/).optional(),
+    auto_land: z.boolean().optional(),
+};
+export const stackPublishStatusSchema = target;
+const publishInput = z.object(stackPublishSchema);
+const statusInput = z.object(stackPublishStatusSchema);
+function failure(err, fallback) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+        summary: message,
+        data: {
+            error: {
+                code: err instanceof CommandError ? err.code ?? fallback : fallback,
+                message,
+                ...(err instanceof CommandError && err.retryAfterSeconds !== undefined
+                    ? { retry_after_seconds: err.retryAfterSeconds } : {}),
+            },
+        },
+        isError: true,
+    };
+}
+function targetOf(input, cfg) {
+    return {
+        ...(input.cwd ? { cwd: input.cwd } : {}),
+        ...(input.owner ? { owner: input.owner } : {}),
+        ...(input.repo ? { repo: input.repo } : {}),
+        ...(input.branch ? { branch: input.branch } : {}),
+        ...(cfg ? { cfg } : {}),
+    };
+}
+export async function stackPublish(input, cfg, deps) {
+    const parsed = publishInput.safeParse(input);
+    if (!parsed.success || Boolean(parsed.data.owner) !== Boolean(parsed.data.repo)) {
+        const message = "stack_publish takes owner and repo together, and replace_head as a full 40-character commit SHA";
+        return { summary: message, data: { error: { code: "invalid_input", message } }, isError: true };
+    }
+    try {
+        const result = await publishWorkingBranch({
+            ...targetOf(parsed.data, cfg),
+            ...(parsed.data.base ? { base: parsed.data.base } : {}),
+            ...(parsed.data.extend ? { extend: true } : {}),
+            ...(parsed.data.title ? { title: parsed.data.title } : {}),
+            ...(parsed.data.body !== undefined ? { body: parsed.data.body } : {}),
+            ...(parsed.data.replace_head ? { replaceHead: parsed.data.replace_head } : {}),
+            ...(typeof parsed.data.auto_land === "boolean" ? { autoLand: parsed.data.auto_land } : {}),
+        }, deps);
+        const watch = stackWatchObligation({ stackId: result.stack.id, terminal: null, unread: true, freshCursor: true });
+        const moved = result.branchCreated ? "created" : result.branchUpdated ? "updated" : "already current";
+        return {
+            summary: withWatchText(watch, `Published ${result.owner}/${result.repo} ${result.branch} (${moved}) at ${result.head.sha}, PR #${result.pr.number} (${result.stacked ? `a layer stacked on ${result.baseBranch}` : `a single PR onto ${result.baseBranch}`}), stack ${result.stack.id}`),
+            data: { result, watch },
+        };
+    }
+    catch (err) {
+        return failure(err, "stack_publish_failed");
+    }
+}
+export async function stackPublishStatus(input, cfg, deps) {
+    const parsed = statusInput.safeParse(input);
+    if (!parsed.success || Boolean(parsed.data.owner) !== Boolean(parsed.data.repo)) {
+        const message = "stack_publish_status takes owner and repo together";
+        return { summary: message, data: { error: { code: "invalid_input", message } }, isError: true };
+    }
+    try {
+        const status = await workingBranchPublication(targetOf(parsed.data, cfg), deps);
+        return {
+            summary: `${status.owner}/${status.repo} ${status.branch}: ${status.state}${status.head ? ` at ${status.head.sha}` : ""}${status.pr ? `, PR #${status.pr.number}` : ""}${status.stack ? `, stack ${status.stack.id}` : ""}`,
+            data: { status },
+        };
+    }
+    catch (err) {
+        return failure(err, "stack_publish_status_failed");
+    }
+}

package/dist/lib/tools/stack-set.d.ts

@@ -0,0 +1,16 @@
+import { type Config, type StackPolicyPatch } from "mergestorm/client";
+import type { ToolPayload } from "./types.js";
+/**
+ * `stack_set` input. Every key is optional but at least one must be present.
+ * `auto_land` is boolean; `auto_review` / `auto_patch` are tri-state where
+ * `null` clears the per-stack override back to the account setting.
+ */
+export type StackSetInput = {
+    auto_land?: boolean;
+    auto_review?: boolean | null;
+    auto_patch?: boolean | null;
+    auto_resolve_conflicts?: boolean | null;
+    auto_fix_ci?: boolean | null;
+};
+export declare function stackSetPatch(input: StackSetInput): StackPolicyPatch;
+export declare function stackSet(stackId: string, input: StackSetInput, cfg?: Config): Promise<ToolPayload>;

package/dist/lib/tools/stack-set.js

@@ -0,0 +1,69 @@
+import { setStackPolicy, stackWatchObligation } from "mergestorm/client";
+import { withWatchText } from "./stack-wait.js";
+function triWord(value) {
+    return value === null ? "default" : value ? "on" : "off";
+}
+export function stackSetPatch(input) {
+    const patch = {};
+    if (typeof input.auto_land === "boolean")
+        patch.autoEnqueueWhenReady = input.auto_land;
+    if (input.auto_review !== undefined)
+        patch.autoReviewOverride = input.auto_review;
+    if (input.auto_patch !== undefined)
+        patch.autoPatchOverride = input.auto_patch;
+    if (input.auto_resolve_conflicts !== undefined) {
+        patch.autoResolveConflictsOverride = input.auto_resolve_conflicts;
+    }
+    if (input.auto_fix_ci !== undefined)
+        patch.autoFixCiOverride = input.auto_fix_ci;
+    return patch;
+}
+export async function stackSet(stackId, input, cfg) {
+    const patch = stackSetPatch(input);
+    if (Object.keys(patch).length === 0) {
+        return {
+            summary: "stack_set needs at least one of auto_land, auto_review, auto_patch, auto_resolve_conflicts, auto_fix_ci",
+            isError: true,
+            data: {
+                error: {
+                    code: "invalid_input",
+                    message: "Pass at least one of auto_land, auto_review, auto_patch, auto_resolve_conflicts, auto_fix_ci.",
+                    stack_id: stackId,
+                },
+            },
+        };
+    }
+    const result = await setStackPolicy(stackId, patch, cfg);
+    const parts = [];
+    if (typeof input.auto_land === "boolean") {
+        parts.push(`Auto land ${input.auto_land ? "on" : "off"}`);
+    }
+    if (input.auto_review !== undefined) {
+        parts.push(`auto-review ${triWord(input.auto_review)}`);
+    }
+    if (input.auto_patch !== undefined) {
+        parts.push(`auto-patch ${triWord(input.auto_patch)}`);
+    }
+    if (input.auto_resolve_conflicts !== undefined) {
+        parts.push(`auto-resolve-conflicts ${triWord(input.auto_resolve_conflicts)}`);
+    }
+    if (input.auto_fix_ci !== undefined) {
+        parts.push(`auto-fix-ci ${triWord(input.auto_fix_ci)}`);
+    }
+    const watch = stackWatchObligation({ stackId, terminal: null, unread: true, freshCursor: true });
+    return {
+        summary: withWatchText(watch, `${parts.join(", ")} for stack ${stackId}`),
+        data: {
+            stack_id: stackId,
+            ...(typeof input.auto_land === "boolean" ? { auto_land: input.auto_land } : {}),
+            ...(input.auto_review !== undefined ? { auto_review: input.auto_review } : {}),
+            ...(input.auto_patch !== undefined ? { auto_patch: input.auto_patch } : {}),
+            ...(input.auto_resolve_conflicts !== undefined
+                ? { auto_resolve_conflicts: input.auto_resolve_conflicts }
+                : {}),
+            ...(input.auto_fix_ci !== undefined ? { auto_fix_ci: input.auto_fix_ci } : {}),
+            result,
+            watch,
+        },
+    };
+}

package/dist/lib/tools/stack-status.d.ts

@@ -0,0 +1,3 @@
+import { type Config } from "mergestorm/client";
+import type { ToolPayload } from "./types.js";
+export declare function stackStatus(stackId: string, cfg?: Config): Promise<ToolPayload>;

package/dist/lib/tools/stack-status.js

@@ -0,0 +1,57 @@
+import { getEnrichedStack, listMergeQueueEntries, isCommandErrorCode, stackBlockers, stackTerminalReason, stackWatchObligation, } from "mergestorm/client";
+import { repairSummary, withWatchText } from "./stack-wait.js";
+import { stackSummary } from "./stack-summary.js";
+export async function stackStatus(stackId, cfg) {
+    try {
+        const stack = await getEnrichedStack(stackId, cfg);
+        if (!stack) {
+            const message = `Stack not found or not owned by the current user: ${stackId}`;
+            const watch = stackWatchObligation({ stackId, terminal: "not_found" });
+            return {
+                summary: withWatchText(watch, message),
+                data: {
+                    error: {
+                        code: "stack_not_found",
+                        message,
+                        stack_id: stackId,
+                    },
+                    watch,
+                },
+                isError: true,
+            };
+        }
+        const entries = await listMergeQueueEntries(cfg, { stackId: stack.id });
+        const { attention, held, issues, currentCandidate, busy, agents, repair, landGatePending, queueWait } = stackBlockers(stack, entries);
+        const watch = stackWatchObligation({
+            stackId: stack.id,
+            terminal: stackTerminalReason(stack),
+            cursor: { enrolledHeadSha: currentCandidate?.headSha ?? null },
+            attention: attention ? { prNumber: attention.prNumber, blocker: attention.blocker } : null,
+            freshCursor: true,
+        });
+        return {
+            summary: withWatchText(watch, `${stackSummary(stack, entries)}${repairSummary(repair)}`),
+            data: { stack, attention, held, issues, currentCandidate, busy, agents, repair, landGatePending, queueWait, watch },
+        };
+    }
+    catch (err) {
+        if (isCommandErrorCode(err, "rate_limited")) {
+            const watch = stackWatchObligation({
+                stackId, terminal: null, status: "rate_limited", retryAfterSeconds: err.retryAfterSeconds, freshCursor: true,
+            });
+            return {
+                summary: withWatchText(watch, err.message),
+                data: {
+                    error: {
+                        code: "rate_limited",
+                        message: err.message,
+                        retry_after_seconds: err.retryAfterSeconds,
+                    },
+                    watch,
+                },
+                isError: true,
+            };
+        }
+        throw err;
+    }
+}

package/dist/lib/tools/stack-summary.d.ts

@@ -0,0 +1,2 @@
+import { type MergeQueueEntryDto, type StackDto } from "mergestorm/client";
+export declare function stackSummary(stack: StackDto, entries?: MergeQueueEntryDto[]): string;

package/dist/lib/tools/stack-summary.js

@@ -0,0 +1,29 @@
+import { stackBlockers, stackBlockersSummary } from "mergestorm/client";
+export function stackSummary(stack, entries = []) {
+    const count = stack.layers.length;
+    const layerLabel = `${count} layer${count === 1 ? "" : "s"}`;
+    const states = [...new Set(stack.layers.map((layer) => layer.state))];
+    const currentState = states.length > 0
+        ? `restack: ${states.join(", ")}`
+        : stack.unit
+            ? `unit: ${stack.unit.state}`
+            : "no open layers";
+    const overrides = [];
+    if (typeof stack.autoReviewOverride === "boolean") {
+        overrides.push(`auto-review ${stack.autoReviewOverride ? "on" : "off"}`);
+    }
+    if (typeof stack.autoPatchOverride === "boolean") {
+        overrides.push(`auto-patch ${stack.autoPatchOverride ? "on" : "off"}`);
+    }
+    if (typeof stack.autoResolveConflictsOverride === "boolean") {
+        overrides.push(`auto-resolve-conflicts ${stack.autoResolveConflictsOverride ? "on" : "off"}`);
+    }
+    if (typeof stack.autoFixCiOverride === "boolean") {
+        overrides.push(`auto-fix-ci ${stack.autoFixCiOverride ? "on" : "off"}`);
+    }
+    if (stack.cycloneOwnerMatch) {
+        overrides.push(`cyclone-owner ${stack.cycloneOwnerMatch}`);
+    }
+    const { attention, held, issues, busy, landGatePending, queueWait } = stackBlockers(stack, entries);
+    return `${stack.owner}/${stack.repo} · ${layerLabel} · ${currentState} · auto-land ${stack.autoEnqueueWhenReady ? "on" : "off"}${overrides.map((label) => ` · ${label}`).join("")}${stackBlockersSummary(attention ?? held, issues, busy, landGatePending, attention ? null : held?.actAfter ?? null, queueWait)}`;
+}

package/dist/lib/tools/stack-wait.d.ts

@@ -0,0 +1,24 @@
+import { pollStackWatch, type Config, type StackRepairHint, type StackWatchObligation } from "mergestorm/client";
+import { z } from "zod";
+import type { ToolPayload } from "./types.js";
+export declare const stackWaitSchema: {
+    stack_id: z.ZodString;
+    timeout_s: z.ZodDefault<z.ZodNumber>;
+    enrolled_head_sha: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    after_finished_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    bounce_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+};
+export type StackWaitInput = {
+    stack_id: string;
+    timeout_s?: number;
+    enrolled_head_sha?: string | null;
+    after_finished_at?: string | null;
+    bounce_id?: string | null;
+};
+export declare function repairSummary(repair: StackRepairHint | null | undefined): string;
+export declare function withWatchText(watch: StackWatchObligation, body: string): string;
+export declare function stackWait(input: StackWaitInput, cfg?: Config, deps?: {
+    pollStackWatch?: typeof pollStackWatch;
+    signal?: AbortSignal;
+    chatId?: string;
+}): Promise<ToolPayload>;

package/dist/lib/tools/stack-wait.js

@@ -0,0 +1,84 @@
+import { loadConfig, stackBlockersSummary, pollStackWatch, StackWatchError, StackWatchTimeoutError, stackWatchBackgroundCommand, stackWatchObligation, } from "mergestorm/client";
+import { z } from "zod";
+import { CHAT_WAKE_STACK_NOTE, registerChatWake } from "./chat-wake.js";
+export const stackWaitSchema = {
+    stack_id: z.string().trim().min(1),
+    timeout_s: z.number().finite().min(0).max(45).default(45),
+    enrolled_head_sha: z.string().nullable().optional(),
+    after_finished_at: z.string().nullable().optional(),
+    bounce_id: z.string().nullable().optional(),
+};
+export function repairSummary(repair) {
+    if (!repair)
+        return "";
+    const files = "files" in repair && repair.files.length ? ` Files: ${repair.files.join(", ")}.` : "";
+    const note = "note" in repair && repair.note ? ` ${repair.note}` : "";
+    return `\nRepair #${repair.prNumber} (${repair.kind}).${files} ${repair.steps}${note}`;
+}
+export function withWatchText(watch, body) {
+    return `${watch.message}\n\n${body}`;
+}
+function envelopeWatch(envelope) {
+    return envelope.watch ?? stackWatchObligation({
+        stackId: envelope.stackId, terminal: null, cursor: envelope.cursor, status: envelope.status,
+    });
+}
+function stackWaitSummary(envelope) {
+    return withWatchText(envelopeWatch(envelope), `${stackWaitStatusLine(envelope)}${repairSummary(envelope.repair)}`);
+}
+function stackWaitStatusLine(envelope) {
+    const base = `Stack ${envelope.stackId} · ${envelope.status}${stackBlockersSummary(envelope.blocker && envelope.prNumber != null ? { prNumber: envelope.prNumber, blocker: envelope.blocker } : null, envelope.issues, envelope.busy, envelope.landGatePending, envelope.actAfter ?? null, envelope.queueWait ?? null)}${envelope.assessment === "unavailable" ? " · assessment unavailable" : ""}`;
+    if (envelopeWatch(envelope).done || (envelope.status !== "waiting" && envelope.status !== "in_progress"))
+        return base;
+    const selectors = [
+        `stack_id ${JSON.stringify(envelope.cursor.stackId)}`,
+        `enrolled_head_sha ${JSON.stringify(envelope.cursor.enrolledHeadSha)}`,
+        ...(envelope.cursor.afterFinishedAt !== undefined ? [`after_finished_at ${JSON.stringify(envelope.cursor.afterFinishedAt)}`] : []),
+        ...(envelope.cursor.bounceId !== undefined ? [`bounce_id ${JSON.stringify(envelope.cursor.bounceId)}`] : []),
+    ];
+    return `${base} · watch not finished: only with a confirmed host notification that resumes this task, run ${stackWatchBackgroundCommand(envelope.stackId, envelope.cursor)} as a background command and end your turn; otherwise call stack_wait again with timeout_s 45 and the same cursor: ${selectors.join(", ")}`;
+}
+export async function stackWait(input, cfg, deps = {}) {
+    const args = z.object(stackWaitSchema).parse(input);
+    const config = cfg ?? await loadConfig();
+    const cursor = args.enrolled_head_sha !== undefined || args.after_finished_at !== undefined || args.bounce_id !== undefined
+        ? {
+            stackId: args.stack_id,
+            enrolledHeadSha: args.enrolled_head_sha ?? null,
+            ...(args.after_finished_at !== undefined ? { afterFinishedAt: args.after_finished_at } : {}),
+            ...(args.bounce_id !== undefined ? { bounceId: args.bounce_id } : {}),
+        }
+        : undefined;
+    let envelope;
+    try {
+        envelope = await (deps.pollStackWatch ?? pollStackWatch)(config, args.stack_id, {
+            timeoutMs: args.timeout_s * 1000,
+            cursor,
+            signal: deps.signal,
+        });
+    }
+    catch (err) {
+        if (err instanceof StackWatchError) {
+            const envelope = { ...err.lastEnvelope, watch: envelopeWatch(err.lastEnvelope) };
+            return {
+                summary: stackWaitSummary(envelope),
+                data: {
+                    ...envelope,
+                    ...(err.retryAfterSeconds !== undefined ? { retry_after_seconds: err.retryAfterSeconds } : {}),
+                },
+                isError: !envelope.watch.done,
+            };
+        }
+        if (!(err instanceof StackWatchTimeoutError))
+            throw err;
+        envelope = err.lastEnvelope;
+    }
+    const sealed = { ...envelope, watch: envelopeWatch(envelope) };
+    const wake = deps.chatId && !sealed.watch.done
+        ? await registerChatWake(config, deps.chatId, { kind: "stack", stackId: sealed.stackId }, deps.signal)
+        : null;
+    return {
+        summary: wake ? `${stackWaitSummary(sealed)}\n\n${CHAT_WAKE_STACK_NOTE}` : stackWaitSummary(sealed),
+        data: wake ? { ...sealed, chat_wake: wake } : sealed,
+    };
+}

package/dist/lib/tools/surge-setup.d.ts

@@ -0,0 +1,6 @@
+import type { Config } from "mergestorm/client";
+import type { ToolPayload } from "./types.js";
+export declare function surgeSetup(input: {
+    owner: string;
+    repo: string;
+}, cfg?: Config): Promise<ToolPayload>;

package/dist/lib/tools/surge-setup.js

@@ -0,0 +1,4 @@
+import { agentRequest } from "./agent-request.js";
+export async function surgeSetup(input, cfg) {
+    return agentRequest("/api/v1/agents/surge/setup", { method: "POST", json: { owner: input.owner, repo: input.repo } }, cfg);
+}

package/dist/lib/tools/types.d.ts

@@ -0,0 +1,5 @@
+export type ToolPayload = {
+    summary: string;
+    data: Record<string, unknown>;
+    isError?: boolean;
+};

package/dist/lib/tools/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/tools/whoami.d.ts

@@ -0,0 +1,3 @@
+import { type Config } from "mergestorm/client";
+import type { ToolPayload } from "./types.js";
+export declare function whoami(cfg?: Config, serverVersion?: string): Promise<ToolPayload>;

package/dist/lib/tools/whoami.js

@@ -0,0 +1,27 @@
+import { CommandError, apiBase, configPath, getMe, loadConfig, resolveApiKey, } from "mergestorm/client";
+export async function whoami(cfg, serverVersion) {
+    const resolved = cfg ?? (await loadConfig());
+    const key = resolveApiKey(resolved);
+    if (!key) {
+        throw new CommandError("No API key. Run `mergestorm login` (agents: `mergestorm login --start`, then `--finish`) or set MERGESTORM_API_KEY.", 1, "missing_api_key");
+    }
+    const me = await getMe(resolved);
+    if (!me) {
+        throw new CommandError("Live account details unavailable. Could not verify account with /me.");
+    }
+    const data = {
+        key_prefix: me.key.prefix,
+        key_name: me.key.name ?? null,
+        plan_key: me.plan_key ?? null,
+        plan_label_key: me.plan_label_key ?? null,
+        api_base: apiBase(resolved),
+        config_path: resolved.ignoreEnv ? null : configPath(),
+        usage: me.usage ?? null,
+        mcp_server_version: serverVersion ?? null,
+    };
+    const plan = data.plan_label_key ?? data.plan_key ?? "unknown plan";
+    return {
+        summary: `${data.key_prefix} · ${plan}${serverVersion ? ` · mergestorm-mcp ${serverVersion}` : ""}`,
+        data,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mergestorm-mcp",
-  "version": "0.2.25",
+  "version": "0.2.27",
   "description": "Mergestorm MCP server — identity, review, and read-only stack tools over stdio",
   "license": "MIT",
   "type": "module",
@@ -13,13 +13,21 @@
   "bin": {
     "mergestorm-mcp": "./dist/index.js"
   },
+  "exports": {
+    "./hosted": {
+      "mergestorm-source": "./src/hosted.ts",
+      "types": "./dist/lib/hosted.d.ts",
+      "default": "./dist/lib/hosted.js"
+    },
+    "./package.json": "./package.json"
+  },
   "files": [
     "dist",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
-    "build": "esbuild src/index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --packages=external --banner:js=\"#!/usr/bin/env node\"",
+    "build": "esbuild src/index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --packages=external --banner:js=\"#!/usr/bin/env node\" && tsc -p tsconfig.build.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "tsx --test src/*.test.ts src/**/*.test.ts",
     "start": "node dist/index.js"
@@ -29,7 +37,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "mergestorm": "0.3.60",
+    "mergestorm": "0.3.63",
     "zod": "^3.24.2"
   },
   "devDependencies": {