mergestorm-mcp 0.2.26 → 0.2.28

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

@@ -0,0 +1,44 @@
+import { pollStackWatch, type Config, type StackRepairHint, type StackWatchObligation, type StackWatchNextArgs } 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 type HostedStackWatch = Omit<StackWatchObligation, "next"> & {
+    next: {
+        tool: "stack_wait";
+        args: StackWatchNextArgs;
+    } | null;
+};
+export declare function hostedStackWatch(watch: StackWatchObligation): HostedStackWatch;
+type McpTextResult = {
+    isError?: boolean;
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent?: Record<string, unknown>;
+};
+export type HostedStackRepair = Omit<StackRepairHint, "steps" | "note">;
+export declare function hostedStackRepair(repair: StackRepairHint): HostedStackRepair;
+export declare function hostedToolResult<T extends McpTextResult>(result: T): T;
+export declare function stackWait(input: StackWaitInput, cfg?: Config, deps?: {
+    pollStackWatch?: typeof pollStackWatch;
+    signal?: AbortSignal;
+    chatId?: string;
+    hosted?: boolean;
+}): Promise<ToolPayload>;
+export {};

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

@@ -0,0 +1,146 @@
+import { loadConfig, stackBlockersSummary, pollStackWatch, StackWatchError, StackWatchTimeoutError, stackWatchBackgroundCommand, stackWatchObligation, } from "mergestorm/client";
+import { z } from "zod";
+import { chatTaskNote, trackInChat } from "./chat-task.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}`;
+}
+const KEEP_EARLIER_CURSOR = "If you already hold a cursor from an earlier stack_wait on this stack, keep passing that cursor instead.";
+export function hostedStackWatch(watch) {
+    if (watch.done) {
+        return {
+            ...watch,
+            next: null,
+            message: watch.reason === "not_found"
+                ? "No stack with this id exists for this account. Mergestorm deletes a stack once none of its layers is open, which can mean merged or closed, so landing is unconfirmed: check on GitHub that each PR is merged before reporting it landed. The watch is done."
+                : watch.message,
+        };
+    }
+    const args = watch.next?.args;
+    const attention = watch.reason === "attention";
+    const retry = watch.reason === "rate_limited" ? " Wait retry_after_seconds first." : "";
+    const failed = watch.reason === "failed" ? " This read failed; if the next one fails too, tell the human the stack is no longer watched." : "";
+    const keep = watch.message.includes(KEEP_EARLIER_CURSOR) ? ` ${KEEP_EARLIER_CURSOR}` : "";
+    const resume = args
+        ? attention
+            ? ` After the blocker is handled, call stack_wait ${JSON.stringify(args)}.`
+            : ` Next call: stack_wait ${JSON.stringify(args)}.`
+        : "";
+    return {
+        ...watch,
+        next: args && !attention ? { tool: "stack_wait", args } : null,
+        message: `This stack is not landed and the watch is not done.${retry}${failed}${resume}${keep}`,
+    };
+}
+export function hostedStackRepair(repair) {
+    const { steps: _steps, note: _note, findings: _findings, ...facts } = repair;
+    return facts;
+}
+function hostedRepairSummary(repair) {
+    const files = "files" in repair && repair.files.length ? ` Files: ${repair.files.join(", ")}.` : "";
+    const breeze = "publishedBy" in repair && repair.publishedBy === "breeze"
+        ? ` ${repair.branch} is a Breeze branch${repair.liveParent ? ` on ${repair.liveParent}` : ""}: open_pull_request publishes it with single-parent commits only, so a merge commit cannot be published.`
+        : "";
+    return `\nRepair #${repair.prNumber} (${repair.kind}).${files}${breeze}`;
+}
+export function hostedToolResult(result) {
+    const data = result.structuredContent;
+    const watch = data?.watch;
+    const repair = data?.repair;
+    const hasWatch = !!watch && typeof watch.message === "string";
+    const hasRepair = !!repair && typeof repair.steps === "string";
+    if (!data || (!hasWatch && !hasRepair))
+        return result;
+    let text = result.content[0]?.text ?? "";
+    const structured = { ...data };
+    if (hasWatch) {
+        const hosted = hostedStackWatch(watch);
+        structured.watch = hosted;
+        if (text.startsWith(watch.message))
+            text = `${hosted.message}${text.slice(watch.message.length)}`;
+    }
+    if (hasRepair) {
+        const hosted = hostedStackRepair(repair);
+        structured.repair = hosted;
+        text = text.replace(repairSummary(repair), hostedRepairSummary(repair));
+    }
+    return { ...result, content: [{ type: "text", text }, { type: "text", text: JSON.stringify(structured) }], structuredContent: structured };
+}
+function envelopeWatch(envelope) {
+    return envelope.watch ?? stackWatchObligation({
+        stackId: envelope.stackId, terminal: null, cursor: envelope.cursor, status: envelope.status,
+    });
+}
+function stackWaitSummary(envelope, hosted = false) {
+    return withWatchText(envelopeWatch(envelope), `${stackWaitStatusLine(envelope, hosted)}${repairSummary(envelope.repair)}`);
+}
+function stackWaitStatusLine(envelope, hosted) {
+    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)}`] : []),
+    ];
+    const background = hosted ? "" : `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 `;
+    return `${base} · watch not finished: ${background}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, deps.hosted),
+                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 task = deps.chatId && !sealed.watch.done
+        ? await trackInChat(config, deps.chatId, { kind: "stack", stackId: sealed.stackId }, deps.signal)
+        : null;
+    return {
+        summary: task ? `${stackWaitSummary(sealed, deps.hosted)}\n\n${chatTaskNote(task)}` : stackWaitSummary(sealed, deps.hosted),
+        data: task ? { ...sealed, background_task: task } : 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.26",
+  "version": "0.2.28",
   "description": "Mergestorm MCP server — identity, review, and read-only stack tools over stdio",
   "license": "MIT",
   "type": "module",
@@ -13,13 +13,23 @@
   "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",
+    "!dist/.tsbuildinfo",
+    "!dist/.build-inputs",
     "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 +39,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "mergestorm": "0.3.62",
+    "mergestorm": "0.3.64",
     "zod": "^3.24.2"
   },
   "devDependencies": {