@fastagent-sh/fastagent 0.28.0 → 0.29.0

package/README.md

@@ -153,6 +153,7 @@ The package exports the supported surface only, from one entry per kind of user,
 | Directory → agent → service | `openAgent`, `LocalAgent`, `serve()`'s `Service` (`fetch`, `listen`) | Usable now, may tighten before 1.0 |
 | Over HTTP | `connectAgent` (`/client`), the `/v1` routes ([Agent API](docs/SPEC.md) §9) | Stable within its version |
 | A host embedding agents | `createAgent`, `addContent`, `removeContent`, `listContent`, `CredentialStore`, `credentialFile`, `signIn`, `signInOptions`, `providerAuth` ([embedding](docs/embedding.md#6-a-desktop-host)) | Usable now, may tighten before 1.0 |
+| MCP tools and authorization | `inspectMcp`, `signInMcp`, `mcpGrantFile`, `McpGrantStore` ([MCP servers](docs/mcp.md)) | Usable now, may tighten before 1.0 |
 | Authoring | `defineAgent`, `defineChannel`, `defineSchedule`, `needs`, `sessionIdOf`, `readBodyCapped`, `text`, `secretEquals` | Usable now, may tighten before 1.0 |
 | Not exported | The assembly's parts (`router`, `createScheduler`), the environment's edit (`writeEnvironment`), the model environment, harness internals | No compatibility promise |
 
@@ -189,7 +190,7 @@ The Agent API leaves room for capabilities that are not complete product feature
 - **Scale-out**: one process holds an instance's storage today; spreading one instance over several processes is future work.
 - **Sandboxed execution** — the coding tools, channels, and author-written code reach the local process directly; a sandbox around the complete agent process is future work.
 - **Observability export** — leveled logs exist today; an OpenTelemetry exporter does not.
-- **More channels and connectors** — community channels can use the channel kit; MCP servers as connectors are planned.
+- **More channels** — community channels can use the channel kit. External tools can also use [MCP servers](docs/mcp.md).
 - **More deploy targets** — local Docker, Fly, Railway, and AWS Bedrock AgentCore ship today; the generated container is the portable path for other hosts.
 
 See [Contributing](https://github.com/fastagent-sh/fastagent/blob/main/CONTRIBUTING.md) if one of these is the problem you want to work on.

package/dist/channels/feishu/feishu-api.d.ts

@@ -19,6 +19,7 @@ export interface DownloadedFile {
  *  streaming once when it sees this. A plain code check on the typed error, exported instead of the
  *  class so no caller can construct/throw one. */
 export declare function isCardStreamingClosed(e: unknown): boolean;
+export declare function isFeishuCredentialsRefused(e: unknown): boolean;
 /** Whether the platform origin has no application-config route at all. Onboarding uses this narrow
  * signal to fall back to a manual token/mode setup; auth/scope/network failures must remain visible. */
 export declare function isFeishuConfigApiMissing(e: unknown): boolean;

package/dist/channels/feishu/feishu-api.js

@@ -61,6 +61,10 @@ class FeishuApiError extends Error {
 export function isCardStreamingClosed(e) {
     return e instanceof FeishuApiError && (e.code === 200850 || e.code === 300309);
 }
+// Lark's credential endpoint returns code 10003 for invalid app credentials; other errors remain fatal.
+export function isFeishuCredentialsRefused(e) {
+    return e instanceof FeishuApiError && e.call === "tenant_access_token" && e.status === 200 && e.code === 10003;
+}
 /** Whether the platform origin has no application-config route at all. Onboarding uses this narrow
  * signal to fall back to a manual token/mode setup; auth/scope/network failures must remain visible. */
 export function isFeishuConfigApiMissing(e) {

package/dist/channels/feishu/register-app.d.ts

@@ -24,6 +24,8 @@ interface FeishuAppAddons {
         items?: string[];
     };
 }
+/** JSON → gzip → base64url — the platform's fixed addons encoding. */
+export declare function encodeAddons(addons: FeishuAppAddons): string;
 export interface RegisterFeishuAppOptions {
     /** Pre-filled app name shown on the confirm page (`{user}` expands to the scanning user's name). */
     name?: string;

package/dist/channels/feishu/register-app.js

@@ -13,7 +13,7 @@ const ENDPOINT = "/oauth/v1/app/registration";
 /** Per-attempt timeout for one registration POST — small form/JSON round-trips. */
 const REQUEST_TIMEOUT_MS = 30_000;
 /** JSON → gzip → base64url — the platform's fixed addons encoding. */
-function encodeAddons(addons) {
+export function encodeAddons(addons) {
     return gzipSync(Buffer.from(JSON.stringify(addons), "utf8"))
         .toString("base64")
         .replace(/\+/g, "-")

package/dist/channels/lark/credentials-page.d.ts

@@ -0,0 +1,25 @@
+export interface LarkCredentials {
+    appId: string;
+    appSecret: string;
+}
+export declare class LarkCredentialsRefused extends Error {
+    readonly fix: string | undefined;
+    readonly why: string | undefined;
+    constructor(headline: string, options?: {
+        fix?: string;
+        why?: string;
+    });
+}
+export interface LarkCredentialsPage<T = LarkCredentials> {
+    url: string;
+    credentials: Promise<T>;
+    close(): Promise<void>;
+}
+export declare function startLarkCredentialsPage(input: {
+    consoleUrl: string;
+    check(credentials: LarkCredentials): Promise<void>;
+}): Promise<LarkCredentialsPage>;
+export declare function startLarkVerificationPage(input: {
+    consoleUrl: string;
+    save(token: string): Promise<void>;
+}): Promise<LarkCredentialsPage<string>>;

package/dist/channels/lark/credentials-page.js

@@ -0,0 +1,206 @@
+/** Loopback-only, single-use forms for Lark setup secrets; values never pass through the agent's conversation. */
+import { randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { field, formCard, openButton, privacy, prose, refusal, sendPage, setupRequestUrl, statusCard, step, submit, } from "../../setup-page.js";
+export class LarkCredentialsRefused extends Error {
+    fix;
+    why;
+    constructor(headline, options = {}) {
+        super(headline);
+        this.name = "LarkCredentialsRefused";
+        this.fix = options.fix;
+        this.why = options.why;
+    }
+}
+function readBody(request) {
+    return new Promise((resolve) => {
+        let body = "";
+        let tooLarge = false;
+        request.on("data", (chunk) => {
+            if (tooLarge)
+                return;
+            body += String(chunk);
+            if (Buffer.byteLength(body) > 16 * 1024)
+                tooLarge = true;
+        });
+        request.on("end", () => resolve(tooLarge ? undefined : body));
+        request.on("error", () => resolve(undefined));
+    });
+}
+export function startLarkCredentialsPage(input) {
+    return startPage({
+        heading: "Lark credentials verified",
+        form: (pasted, problem) => formCard("Connect Lark", [
+            step(1, "Create the app in Lark", prose("It opens with the permissions and event your agent needs already set.") +
+                openButton("Open Lark", input.consoleUrl)),
+            step(2, "Paste its credentials", (problem
+                ? refusal(problem.message, problem.fix, problem.why)
+                : prose("Find them under <b>Credentials &amp; Basic Info</b>.")) +
+                field({
+                    id: "app_id",
+                    label: "App ID",
+                    placeholder: "cli_…",
+                    value: pasted.get("app_id") ?? "",
+                    invalid: !!problem,
+                }) +
+                field({ id: "app_secret", label: "App Secret", secret: true, invalid: !!problem, autofocus: !!problem }) +
+                submit("Save and check") +
+                privacy()),
+        ].join("")),
+        accept: async (pasted) => {
+            const pair = { appId: (pasted.get("app_id") ?? "").trim(), appSecret: (pasted.get("app_secret") ?? "").trim() };
+            if (!pair.appId || !pair.appSecret) {
+                throw new LarkCredentialsRefused("Both values are needed.", {
+                    fix: "Copy the App ID and the App Secret from Credentials & Basic Info.",
+                });
+            }
+            await input.check(pair);
+            return pair;
+        },
+    });
+}
+export function startLarkVerificationPage(input) {
+    return startPage({
+        heading: "Verification Token saved",
+        form: (_pasted, problem) => formCard("Finish Lark webhook setup", [
+            step(1, "Copy the Verification Token", prose("Find it under <b>Events &amp; Callbacks</b> → Encryption Strategy. Choose webhook mode when setting the Request URL.") + openButton("Open Lark", input.consoleUrl)),
+            step(2, "Paste the token here", (problem ? refusal(problem.message, problem.fix) : "") +
+                field({
+                    id: "verification_token",
+                    label: "Verification Token",
+                    secret: true,
+                    invalid: !!problem,
+                    autofocus: !!problem,
+                }) +
+                submit("Save token") +
+                privacy()),
+        ].join("")),
+        accept: async (pasted) => {
+            const token = (pasted.get("verification_token") ?? "").trim();
+            if (!token)
+                throw new LarkCredentialsRefused("Verification Token is required.");
+            await input.save(token);
+            return token;
+        },
+    });
+}
+// A browser can leave during validation, before either response event can be subscribed to.
+function afterResponse(response, complete) {
+    if (response.destroyed || response.writableFinished)
+        complete();
+    else
+        response.once("close", complete);
+}
+async function startPage(input) {
+    const path = `/lark/credentials/${randomBytes(24).toString("hex")}`;
+    const { promise: credentials, resolve, reject } = Promise.withResolvers();
+    let checking = false;
+    let used = false;
+    let port = 0;
+    const server = createServer(async (request, response) => {
+        const url = setupRequestUrl(request, response);
+        if (url === undefined)
+            return;
+        const host = request.headers.host ?? "";
+        if (host !== `127.0.0.1:${port}` && host !== `localhost:${port}`) {
+            response.writeHead(421).end("misdirected request\n");
+            return;
+        }
+        if (url.pathname !== path || (request.method !== "GET" && request.method !== "POST")) {
+            response.writeHead(404).end("not found\n");
+            return;
+        }
+        const expired = () => sendPage(response, 404, {
+            title: "FastAgent setup",
+            card: statusCard({
+                state: "failed",
+                heading: "This page is no longer in use",
+                next: "Go back to your coding agent.",
+            }),
+        });
+        if (used) {
+            expired();
+            return;
+        }
+        if (request.method === "GET") {
+            sendPage(response, 200, { title: "Connect Lark — FastAgent", card: input.form(new URLSearchParams()) });
+            return;
+        }
+        const site = request.headers["sec-fetch-site"];
+        if (site !== undefined && site !== "same-origin") {
+            response.writeHead(403).end("forbidden\n");
+            return;
+        }
+        const body = await readBody(request);
+        if (body === undefined) {
+            response.writeHead(413).end("payload too large\n");
+            return;
+        }
+        if (used) {
+            expired();
+            return;
+        }
+        if (checking) {
+            response.writeHead(409).end("another submission is being checked\n");
+            return;
+        }
+        checking = true;
+        const pasted = new URLSearchParams(body);
+        let accepted;
+        try {
+            accepted = await input.accept(pasted);
+        }
+        catch (error) {
+            checking = false;
+            // Only explicit input refusals stay on the form. Infrastructure and persistence errors fail the ticket.
+            if (error instanceof LarkCredentialsRefused) {
+                sendPage(response, 200, { title: "Connect Lark — FastAgent", card: input.form(pasted, error) });
+                return;
+            }
+            used = true;
+            afterResponse(response, () => reject(error));
+            sendPage(response, 200, {
+                title: "Setup stopped — FastAgent",
+                card: statusCard({
+                    state: "failed",
+                    heading: "Setup stopped",
+                    lede: error instanceof Error ? error.message : String(error),
+                    next: "Go back to your coding agent.",
+                }),
+            });
+            return;
+        }
+        used = true;
+        afterResponse(response, () => resolve(accepted));
+        sendPage(response, 200, {
+            title: `${input.heading} — FastAgent`,
+            card: statusCard({
+                state: "done",
+                heading: input.heading,
+                lede: "Your coding agent will say if anything is left to do in Lark.",
+                next: "Go back to your coding agent.",
+            }),
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        server.close();
+        throw new Error("the Lark credentials page did not receive a local TCP port");
+    }
+    port = address.port;
+    return {
+        url: `http://127.0.0.1:${port}${path}`,
+        credentials,
+        close: () => new Promise((resolve) => {
+            server.close(() => resolve());
+            server.closeAllConnections();
+        }),
+    };
+}

package/dist/channels/lark/onboard.d.ts

@@ -1,6 +1,12 @@
-import type { FeishuSubscriptionMode } from "../feishu/setup-mode.ts";
+import { type FeishuSubscriptionMode } from "../feishu/setup-mode.ts";
 /** Guided Lark-international onboarding. */
-export declare const LARK_CONSOLE_URL = "https://open.larksuite.com/page/launcher?from=backend_oneclick";
+/**
+ * Lark's one-click launcher, where the person creates the app. The launcher is unbound (the bound confirm page is broken
+ * on the international cloud), but it merges the `addons` query parameter onto the app it creates, as Feishu's does: the
+ * scopes and the event the channel needs arrive with the app, so nothing is ticked in the console afterwards. A tenant
+ * may still withhold a scope; the permission check that follows creation names it.
+ */
+export declare function larkConsoleUrl(ingress: FeishuSubscriptionMode): string;
 /** Directly where the fallback token lives (and where the successful automatic mode change is visible). */
 export declare function larkEventSecurityUrl(appId: string): string;
 export interface LarkOnboardIO {
@@ -10,6 +16,15 @@ export interface LarkOnboardIO {
     prompt(message: string, opts?: {
         hidden?: boolean;
     }): Promise<string | undefined>;
+    verificationToken?(consoleUrl: string): Promise<string>;
+    collect?(input: {
+        /** Lark's launcher, with what the channel needs set on the app it creates. */
+        consoleUrl: string;
+        check(appId: string, appSecret: string): Promise<void>;
+    }): Promise<{
+        appId: string;
+        appSecret: string;
+    }>;
 }
 interface LarkBootstrapResult {
     /** Challenge-captured token: the PATCH also switched Subscription mode to webhook. */
@@ -22,6 +37,7 @@ export interface LarkOnboardOptions {
     existing?: Readonly<Record<string, string | undefined>>;
     ingress?: FeishuSubscriptionMode;
     verifyCredentials(appId: string, appSecret: string): Promise<void>;
+    keep?(appId: string, appSecret: string): Promise<void>;
     bootstrapWebhook?(appId: string, appSecret: string): Promise<LarkBootstrapResult>;
     /** The command that continues an interrupted setup: the one that started it (`add lark`, `deploy <host> --run`). */
     rerun?: string;

package/dist/channels/lark/onboard.js

@@ -1,5 +1,18 @@
+import { encodeAddons } from "../feishu/register-app.js";
+import { feishuAppAddons } from "../feishu/setup-mode.js";
 /** Guided Lark-international onboarding. */
-export const LARK_CONSOLE_URL = "https://open.larksuite.com/page/launcher?from=backend_oneclick";
+/**
+ * Lark's one-click launcher, where the person creates the app. The launcher is unbound (the bound confirm page is broken
+ * on the international cloud), but it merges the `addons` query parameter onto the app it creates, as Feishu's does: the
+ * scopes and the event the channel needs arrive with the app, so nothing is ticked in the console afterwards. A tenant
+ * may still withhold a scope; the permission check that follows creation names it.
+ */
+export function larkConsoleUrl(ingress) {
+    const url = new URL("https://open.larksuite.com/page/launcher");
+    url.searchParams.set("from", "backend_oneclick");
+    url.searchParams.set("addons", encodeAddons(feishuAppAddons(ingress)));
+    return url.toString();
+}
 /** Directly where the fallback token lives (and where the successful automatic mode change is visible). */
 export function larkEventSecurityUrl(appId) {
     return `https://open.larksuite.com/app/${encodeURIComponent(appId)}/event?tab=safe`;
@@ -17,15 +30,30 @@ export async function onboardLarkApp(io, opts) {
     const existingSecret = opts.existing?.LARK_APP_SECRET?.trim();
     const reuseExistingApp = Boolean(existingId && existingSecret);
     // Credentials are one App-scoped set.
+    // No ingress named is the webhook path below (a deploy's production app).
+    const consoleUrl = larkConsoleUrl(opts.ingress ?? "webhook");
+    let appId;
+    let appSecret;
+    const verify = async (appId, appSecret) => {
+        await opts.verifyCredentials(appId, appSecret);
+        if (!reuseExistingApp)
+            await opts.keep?.(appId, appSecret);
+    };
     if (reuseExistingApp) {
         io.note(`Reusing Lark app ${existingId}.`);
+        appId = required(existingId, "LARK_APP_ID", rerun);
+        appSecret = required(existingSecret, "LARK_APP_SECRET", rerun);
+        await verify(appId, appSecret);
+    }
+    else if (io.collect) {
+        ({ appId, appSecret } = await io.collect({ consoleUrl, check: verify }));
     }
     else {
-        io.openUrl(LARK_CONSOLE_URL, "create the app on Lark's one-click launcher; LARK_APP_ID and LARK_APP_SECRET are under Credentials & Basic Info");
+        io.openUrl(consoleUrl, "create the app on Lark's one-click launcher; LARK_APP_ID and LARK_APP_SECRET are under Credentials & Basic Info");
+        appId = required(await io.prompt("LARK_APP_ID (Credentials & Basic Info)", { hidden: false }), "LARK_APP_ID", rerun);
+        appSecret = required(await io.prompt("LARK_APP_SECRET (Credentials & Basic Info)", { hidden: true }), "LARK_APP_SECRET", rerun);
+        await verify(appId, appSecret);
     }
-    const appId = required(reuseExistingApp ? existingId : await io.prompt("LARK_APP_ID (Credentials & Basic Info)", { hidden: false }), "LARK_APP_ID", rerun);
-    const appSecret = required(reuseExistingApp ? existingSecret : await io.prompt("LARK_APP_SECRET (Credentials & Basic Info)", { hidden: true }), "LARK_APP_SECRET", rerun);
-    await opts.verifyCredentials(appId, appSecret);
     const eventSecurityUrl = larkEventSecurityUrl(appId);
     io.note("App ID / Secret verified.");
     if (opts.ingress === "websocket") {
@@ -47,7 +75,9 @@ export async function onboardLarkApp(io, opts) {
     }
     const verificationToken = required(bootstrap.token ||
         (reuseExistingApp ? opts.existing?.LARK_VERIFICATION_TOKEN?.trim() : undefined) ||
-        (await io.prompt("LARK_VERIFICATION_TOKEN (Events & Callbacks → Encryption Strategy)", { hidden: true })), "LARK_VERIFICATION_TOKEN", rerun);
+        (io.verificationToken
+            ? await io.verificationToken(eventSecurityUrl)
+            : await io.prompt("LARK_VERIFICATION_TOKEN (Events & Callbacks → Encryption Strategy)", { hidden: true })), "LARK_VERIFICATION_TOKEN", rerun);
     return {
         LARK_APP_ID: appId,
         LARK_APP_SECRET: appSecret,

package/dist/channels/slack/setup-server.js

@@ -1,21 +1,41 @@
 import { randomBytes } from "node:crypto";
 import { createServer } from "node:http";
-const escapeHtml = (text) => text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
-const page = (body, head = "") => `<!doctype html><meta charset=utf-8><meta name=viewport content="width=device-width">${head}` +
-    `<title>FastAgent Slack setup</title><body style="font:16px system-ui;max-width:40em;margin:3em auto;padding:0 1em">${body}`;
+import { field, formCard, openButton, privacy, prose, refusal, sendPage, setupRequestUrl, statusCard, step, submit, } from "../../setup-page.js";
+/** Where Slack's App Configuration tokens are generated: the page names the section, and links to the page it is on. */
+const SLACK_APPS_URL = "https://api.slack.com/apps";
+const TITLE = "Connect Slack — FastAgent";
 function tokensForm(error) {
-    return page(`<h1>Slack App Configuration token</h1>` +
-        `<ol><li>Open <a href="https://api.slack.com/apps" target=_blank rel=noopener>api.slack.com/apps</a>, then ` +
-        `<b>Your App Configuration Tokens</b> → <b>Generate Token</b> for the workspace the agent joins.</li>` +
-        `<li>Paste both tokens here.</li></ol>` +
-        `<p>FastAgent keeps them on this machine only (owner-readable), uses them to create the app and update its ` +
-        `Request URL, and never deploys them.</p>` +
-        (error ? `<p style="color:#b00"><b>${escapeHtml(error)}</b></p>` : "") +
-        `<form method=post><p><label>Access token<br><input name=access type=password required ` +
-        `placeholder="xoxe.xoxp-…" style="width:100%"></label></p><p><label>Refresh token<br><input name=refresh ` +
-        `type=password required placeholder="xoxe-…" style="width:100%"></label></p>` +
-        `<p><button>Create the Slack app</button></p></form>`);
+    return {
+        title: TITLE,
+        card: formCard("Connect Slack", [
+            step(1, "Generate two tokens in Slack", prose("Under <b>Your App Configuration Tokens</b>, choose <b>Generate Token</b> for your workspace.") +
+                openButton("Open Slack", SLACK_APPS_URL)),
+            step(2, "Paste them here", (error ? refusal("Those tokens were not accepted.", ` ${error}`) : "") +
+                field({
+                    id: "access",
+                    label: "Access Token",
+                    placeholder: "xoxe.xoxp-…",
+                    secret: true,
+                    invalid: error !== undefined,
+                    autofocus: error !== undefined,
+                }) +
+                field({
+                    id: "refresh",
+                    label: "Refresh Token",
+                    placeholder: "xoxe-…",
+                    secret: true,
+                    invalid: error !== undefined,
+                }) +
+                submit("Create Slack app") +
+                privacy(), { bare: error === undefined }),
+        ].join("")),
+    };
 }
+/** A page that says where the setup stands. */
+const status = (input, title = "FastAgent setup") => ({
+    title,
+    card: statusCard(input),
+});
 /** Temporary onboarding-only responder. */
 export async function startSlackSetupServer() {
     const nonce = randomBytes(24).toString("hex");
@@ -45,39 +65,53 @@ export async function startSlackSetupServer() {
         settleOAuth = resolve;
     });
     const server = createServer((request, response) => {
-        const url = new URL(request.url ?? "/", "http://127.0.0.1");
+        const url = setupRequestUrl(request, response);
+        if (url === undefined)
+            return;
         if (request.method === "GET" && url.pathname === "/health") {
             response.end("ok\n");
             return;
         }
         if (request.method === "GET" && url.pathname === redirectPath) {
-            settleOAuth?.({
+            const callback = {
                 code: url.searchParams.get("code") ?? undefined,
                 state: url.searchParams.get("state") ?? undefined,
                 error: url.searchParams.get("error") ?? undefined,
-            });
+            };
+            settleOAuth?.(callback);
             settleOAuth = undefined;
-            response.statusCode = 200;
-            response.setHeader("content-type", "text/html; charset=utf-8");
-            response.end(page("<p>Slack authorization received: FastAgent is finishing the install. You can close this page.</p>"));
+            // The onboarding flow still has to validate state and exchange the code.
+            sendPage(response, 200, status(callback.error !== undefined
+                ? {
+                    state: "failed",
+                    heading: "Slack authorization was not approved",
+                    lede: callback.error
+                        ? `OAuth error: ${callback.error}`
+                        : "The callback reported an authorization error.",
+                    next: "Go back to your coding agent to restart setup.",
+                }
+                : {
+                    state: "working",
+                    heading: "OAuth response received",
+                    lede: "FastAgent still needs to verify this response and finish the installation.",
+                    next: "Go back to your coding agent to check the result. You can close this tab.",
+                }));
             return;
         }
         if (url.pathname === tokensPath && (request.method === "GET" || request.method === "POST")) {
-            response.setHeader("content-type", "text/html; charset=utf-8");
             if (takeTokens === undefined) {
                 // Taken already, or not asked for: the page is one-time.
-                response.statusCode = 404;
-                response.end(page("<p>This page is no longer in use.</p>"));
+                sendPage(response, 404, status({ state: "failed", heading: "This page is no longer in use", next: "Go back to your coding agent." }));
                 return;
             }
             if (request.method === "GET") {
-                response.end(tokensForm());
+                sendPage(response, 200, tokensForm());
                 return;
             }
             readBody(request, (body) => {
                 if (body === undefined) {
                     response.statusCode = 413;
-                    response.end(page("<p>Too large.</p>"));
+                    response.end("payload too large\n");
                     return;
                 }
                 const form = new URLSearchParams(body);
@@ -85,7 +119,7 @@ export async function startSlackSetupServer() {
                     takeTokens?.({ access: (form.get("access") ?? "").trim(), refresh: (form.get("refresh") ?? "").trim() });
                 }
                 catch (error) {
-                    response.end(tokensForm(error.message));
+                    sendPage(response, 200, tokensForm(error.message));
                     return;
                 }
                 response.statusCode = 303;
@@ -95,9 +129,16 @@ export async function startSlackSetupServer() {
             return;
         }
         if (request.method === "GET" && url.pathname === nextPath) {
-            response.setHeader("content-type", "text/html; charset=utf-8");
             if (after === undefined) {
-                response.end(page("<p>Creating the Slack app…</p>", '<meta http-equiv="refresh" content="2">'));
+                // Says what comes next, so the redirect to Slack's page is no surprise.
+                sendPage(response, 200, {
+                    ...status({
+                        state: "working",
+                        heading: "Creating your Slack app",
+                        lede: "In a moment Slack will ask you to click Allow.",
+                    }),
+                    head: '<meta http-equiv="refresh" content="2">',
+                });
             }
             else if ("url" in after) {
                 response.statusCode = 303;
@@ -105,8 +146,12 @@ export async function startSlackSetupServer() {
                 response.end();
             }
             else {
-                const style = after.failed ? ' style="color:#b00"' : "";
-                response.end(page(`<p${style}><b>${escapeHtml(after.said)}</b></p><p>Return to your agent.</p>`));
+                sendPage(response, 200, status({
+                    state: after.failed ? "failed" : "done",
+                    heading: after.failed ? "Setup stopped" : "Done",
+                    lede: after.said,
+                    next: "Go back to your coding agent.",
+                }));
                 lastShown?.();
             }
             return;

package/dist/channels/wait-health.js

@@ -1,6 +1,6 @@
 /**
  * Readiness probe for a server THIS process can reach over HTTP — the local port `deploy docker --run` just
- * published, the live probes' own origins, and the public URL a host deploy must clear before it registers a webhook
+ * published, and the public URL a host deploy must clear before it registers a webhook
  * (`publicHealthGate` in deploy/channel-ingress.ts).
  */
 import { setTimeout as sleep } from "node:timers/promises";

package/dist/cli/add-feishu.d.ts

@@ -30,15 +30,6 @@ export declare function onboardFeishuCloudApp(target: string, kind: "feishu" | "
 rerun?: string, 
 /** Who takes the steps only a person can: at this terminal, or a coding agent's person through a ticket. */
 person?: Person): Promise<Record<string, string> | undefined>;
-/**
- * Lark's app credentials, which only the person can get, from the app they create in Lark's console: with no one at a
- * terminal to type them, the report naming where they set them (the selected environment's file), when either is
- * absent. `again` is the command that continues once they have.
- */
-export declare function larkCredentialsNeeded(agentDir: string, again: string): Promise<{
-    json: Record<string, unknown>;
-    text: string[];
-} | undefined>;
 export declare function feishuAppSecretNames(kind: "feishu" | "lark", ingress: FeishuSubscriptionMode): string[];
 interface FeishuAppSetup {
     kind: "feishu" | "lark";