mergestorm-mcp 0.2.27 → 0.2.29

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

@@ -1,6 +1,6 @@
 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";
+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),
@@ -18,15 +18,76 @@ export function repairSummary(repair) {
 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}`,
+    };
+}
+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) {
-    return withWatchText(envelopeWatch(envelope), `${stackWaitStatusLine(envelope)}${repairSummary(envelope.repair)}`);
+function stackWaitSummary(envelope, hosted = false) {
+    return withWatchText(envelopeWatch(envelope), `${stackWaitStatusLine(envelope, hosted)}${repairSummary(envelope.repair)}`);
 }
-function stackWaitStatusLine(envelope) {
+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;
@@ -36,7 +97,8 @@ function stackWaitStatusLine(envelope) {
         ...(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(", ")}`;
+    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);
@@ -61,7 +123,7 @@ export async function stackWait(input, cfg, deps = {}) {
         if (err instanceof StackWatchError) {
             const envelope = { ...err.lastEnvelope, watch: envelopeWatch(err.lastEnvelope) };
             return {
-                summary: stackWaitSummary(envelope),
+                summary: stackWaitSummary(envelope, deps.hosted),
                 data: {
                     ...envelope,
                     ...(err.retryAfterSeconds !== undefined ? { retry_after_seconds: err.retryAfterSeconds } : {}),
@@ -74,11 +136,11 @@ export async function stackWait(input, cfg, deps = {}) {
         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)
+    const task = deps.chatId && !sealed.watch.done
+        ? await trackInChat(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,
+        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/web.d.ts

@@ -0,0 +1,27 @@
+import { WEB_SEARCH_KINDS, WEB_SEARCH_RECENCIES, readWebPage, searchWeb, type Config } from "mergestorm/client";
+import { z } from "zod";
+import type { ToolPayload } from "./types.js";
+export declare const webSearchSchema: {
+    query: z.ZodString;
+    kind: z.ZodOptional<z.ZodEnum<["web", "news"]>>;
+    recency: z.ZodOptional<z.ZodEnum<["day", "week", "month", "year"]>>;
+    page: z.ZodOptional<z.ZodNumber>;
+};
+export declare const readWebPageSchema: {
+    url: z.ZodString;
+};
+export type WebApi = {
+    searchWeb: typeof searchWeb;
+    readWebPage: typeof readWebPage;
+};
+export declare function createWebToolHandlers(cfg: Config | undefined, api?: WebApi): {
+    search: (input: {
+        query: string;
+        kind?: (typeof WEB_SEARCH_KINDS)[number];
+        recency?: (typeof WEB_SEARCH_RECENCIES)[number];
+        page?: number;
+    }) => Promise<ToolPayload>;
+    read: (input: {
+        url: string;
+    }) => Promise<ToolPayload>;
+};

package/dist/lib/tools/web.js

@@ -0,0 +1,36 @@
+import { CommandError, WEB_SEARCH_KINDS, WEB_SEARCH_PAGE_MAX, WEB_SEARCH_RECENCIES, readWebPage, searchWeb } from "mergestorm/client";
+import { z } from "zod";
+export const webSearchSchema = {
+    query: z.string().trim().min(1).max(400),
+    kind: z.enum(WEB_SEARCH_KINDS).optional(),
+    recency: z.enum(WEB_SEARCH_RECENCIES).optional(),
+    page: z.number().int().min(1).max(WEB_SEARCH_PAGE_MAX).optional(),
+};
+export const readWebPageSchema = { url: z.string().trim().url().max(2000) };
+const liveApi = { searchWeb, readWebPage };
+async function guarded(run) {
+    try {
+        return await run();
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const code = err instanceof CommandError ? err.code ?? "web_failed" : "web_failed";
+        return {
+            summary: message,
+            data: { error: { code, message, ...(err instanceof CommandError && err.retryAfterSeconds !== undefined ? { retry_after_seconds: err.retryAfterSeconds } : {}) } },
+            isError: true,
+        };
+    }
+}
+export function createWebToolHandlers(cfg, api = liveApi) {
+    return {
+        search: (input) => guarded(async () => {
+            const found = await api.searchWeb(input, cfg);
+            return { summary: found.text, data: { query: input.query } };
+        }),
+        read: (input) => guarded(async () => {
+            const page = await api.readWebPage(input.url, cfg);
+            return { summary: page.text, data: { url: input.url } };
+        }),
+    };
+}

package/dist/lib/tools/whoami.js

@@ -1,4 +1,4 @@
-import { CommandError, apiBase, configPath, getMe, loadConfig, resolveApiKey, } from "mergestorm/client";
+import { CommandError, accountLabel, apiBase, configPath, getMe, loadConfig, resolveApiKey, } from "mergestorm/client";
 export async function whoami(cfg, serverVersion) {
     const resolved = cfg ?? (await loadConfig());
     const key = resolveApiKey(resolved);
@@ -9,7 +9,11 @@ export async function whoami(cfg, serverVersion) {
     if (!me) {
         throw new CommandError("Live account details unavailable. Could not verify account with /me.");
     }
+    const account = accountLabel(me.account);
     const data = {
+        account,
+        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,
@@ -21,7 +25,7 @@ export async function whoami(cfg, serverVersion) {
     };
     const plan = data.plan_label_key ?? data.plan_key ?? "unknown plan";
     return {
-        summary: `${data.key_prefix} · ${plan}${serverVersion ? ` · mergestorm-mcp ${serverVersion}` : ""}`,
+        summary: `${account ? `${account} · ` : ""}${data.key_prefix} · ${plan}${serverVersion ? ` · mergestorm-mcp ${serverVersion}` : ""}`,
         data,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mergestorm-mcp",
-  "version": "0.2.27",
+  "version": "0.2.29",
   "description": "Mergestorm MCP server — identity, review, and read-only stack tools over stdio",
   "license": "MIT",
   "type": "module",
@@ -23,6 +23,8 @@
   },
   "files": [
     "dist",
+    "!dist/.tsbuildinfo",
+    "!dist/.build-inputs",
     "README.md",
     "LICENSE"
   ],
@@ -37,7 +39,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "mergestorm": "0.3.63",
+    "mergestorm": "0.3.66",
     "zod": "^3.24.2"
   },
   "devDependencies": {

package/dist/lib/tools/chat-wake.d.ts

@@ -1,21 +0,0 @@
-import { type Config } from "mergestorm/client";
-export type ChatWakeTarget = {
-    kind: "vortex";
-    owner: string;
-    repo: string;
-    prNumber: number;
-    headSha: string | null;
-    minPass: number | null;
-} | {
-    kind: "stack";
-    stackId: string;
-};
-export declare function breezeChatId(value: string | null | undefined): string | null;
-export type ChatWake = {
-    id: string;
-    result: "waiting" | "existing" | "finished";
-};
-export declare const CHAT_WAKE_REVIEW_NOTE = "Keep waiting: call review_wait_pr again until the review finishes, then tell the user its verdict and findings. If your reply ends first, this chat is woken with the review's result.";
-export declare const REVIEW_START_WAIT_NOTE = "Wait for it now: call review_wait_pr for this pull request until the review finishes, then tell the user its verdict and findings. If your reply ends first, this chat is woken with the review's result.";
-export declare const CHAT_WAKE_STACK_NOTE = "If your reply ends before the stack is done, this chat is woken when the stack lands, is bounced out of the merge queue, or is archived.";
-export declare function registerChatWake(cfg: Config, chatId: string, target: ChatWakeTarget, signal?: AbortSignal): Promise<ChatWake | null>;

package/dist/lib/tools/chat-wake.js

@@ -1,26 +0,0 @@
-import { apiFetch } from "mergestorm/client";
-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 breezeChatId(value) {
-    const trimmed = value?.trim() ?? "";
-    return CHAT_ID.test(trimmed) ? trimmed.toLowerCase() : null;
-}
-export const CHAT_WAKE_REVIEW_NOTE = "Keep waiting: call review_wait_pr again until the review finishes, then tell the user its verdict and findings. If your reply ends first, this chat is woken with the review's result.";
-export const REVIEW_START_WAIT_NOTE = "Wait for it now: call review_wait_pr for this pull request until the review finishes, then tell the user its verdict and findings. If your reply ends first, this chat is woken with the review's result.";
-export const CHAT_WAKE_STACK_NOTE = "If your reply ends before the stack is done, this chat is woken when the stack lands, is bounced out of the merge queue, or is archived.";
-export async function registerChatWake(cfg, chatId, target, signal) {
-    const json = target.kind === "vortex"
-        ? { chat_id: chatId, kind: "vortex", owner: target.owner, repo: target.repo, pr_number: target.prNumber, head_sha: target.headSha, min_pass: target.headSha ? target.minPass : null }
-        : { chat_id: chatId, kind: "stack", stack_id: target.stackId };
-    try {
-        const response = await apiFetch(cfg, "/api/v1/stacks/chat-waits", { method: "POST", json, signal, timeoutMs: 10_000 });
-        const body = response.body;
-        if (response.status !== 200 || !body || typeof body.id !== "string")
-            return null;
-        if (body.result !== "waiting" && body.result !== "existing" && body.result !== "finished")
-            return null;
-        return { id: body.id, result: body.result };
-    }
-    catch {
-        return null;
-    }
-}