@fastagent-sh/fastagent 0.27.0 → 0.29.0

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";

package/dist/cli/add-feishu.js

@@ -7,9 +7,10 @@ import { isCancel, log as clackLog, password, text as clackText } from "@clack/p
 import { bootstrapFeishuVerificationToken } from "../channels/feishu/bootstrap-token.js";
 import { FEISHU_APP_CONFIG_SCOPE, feishuAppAddons, feishuAppScopes, feishuScopeRequestUrl, scopeSatisfied, } from "../channels/feishu/setup-mode.js";
 import { cloudFor } from "../channels/feishu/cloud.js";
-import { createFeishuApi, isFeishuConfigApiMissing, isTransientFeishuRegistrationError, } from "../channels/feishu/feishu-api.js";
+import { createFeishuApi, isFeishuConfigApiMissing, isFeishuCredentialsRefused, isTransientFeishuRegistrationError, } from "../channels/feishu/feishu-api.js";
 import { registerFeishuApp } from "../channels/feishu/register-app.js";
-import { LARK_CONSOLE_URL, onboardLarkApp } from "../channels/lark/onboard.js";
+import { LarkCredentialsRefused, startLarkCredentialsPage, startLarkVerificationPage, } from "../channels/lark/credentials-page.js";
+import { onboardLarkApp } from "../channels/lark/onboard.js";
 import { dotEnvPath, loadEnvValues, parseEnvContent } from "../value-file.js";
 import { openExternalUrl } from "../open-url.js";
 import { terminalPerson } from "./person.js";
@@ -88,7 +89,7 @@ person = terminalPerson) {
         return undefined;
     }
     // guided-console (lark): the intl cloud cannot complete the bound device flow — collect + validate.
-    const credentials = await onboardLarkApp(person === terminalPerson ? larkAtTerminal : larkThrough(person, env, rerun), {
+    const credentials = await onboardLarkApp(person === terminalPerson ? larkAtTerminal : larkThrough(person, target), {
         existing,
         ingress,
         rerun,
@@ -99,6 +100,17 @@ person = terminalPerson) {
             await createFeishuApi({ kind: "lark", baseUrl: apiBase, appId, appSecret }).verifyCredentials();
             console.error(`[fastagent] Lark App ID / Secret verified`);
         },
+        // The same boundary `add feishu` keeps: a pair given just now is written before any step that can fail, so a
+        // rerun finds it and carries on, instead of asking for it again.
+        keep: async (appId, appSecret) => {
+            const kept = {
+                LARK_APP_ID: appId,
+                LARK_APP_SECRET: appSecret,
+                ...(ingress === "webhook" ? { LARK_VERIFICATION_TOKEN: "" } : {}),
+            };
+            await appendChannelDotEnv(target, "lark", kept, Object.keys(kept), ingress);
+            console.error(`[fastagent] wrote LARK_APP_ID, LARK_APP_SECRET to ${env}`);
+        },
         bootstrapWebhook: async (appId, appSecret) => {
             const api = createFeishuApi({ kind: "lark", baseUrl: apiBase, appId, appSecret });
             console.error(`[fastagent] trying Lark's webhook-mode + Verification-Token bootstrap (temporary tunnel)…`);
@@ -152,16 +164,56 @@ const larkAtTerminal = {
         return isCancel(result) ? undefined : result;
     },
 };
-/**
- * Lark's guided console through a coding agent's person: a page is a step left to them, with what they do there; a
- * value it would ask for is theirs to set in the value file, and the setup continues when run again.
- */
-function larkThrough(person, env, rerun) {
+async function waitForLarkPage(person, page, action) {
+    const port = new URL(page.url).port;
+    try {
+        person.waitsOn(page.url, action +
+            " If the CLI runs remotely, forward this loopback port to the same local port " +
+            `(SSH: ssh -N -L ${port}:127.0.0.1:${port} user@host), then open the same URL in your browser. ` +
+            "Keep the forwarding session open; never paste secrets into the conversation.");
+        const value = await page.credentials;
+        person.carriesOn();
+        return value;
+    }
+    finally {
+        await page.close();
+    }
+}
+function larkThrough(person, target) {
     return {
         note: (message) => console.error(`[fastagent] ${message}`),
         openUrl: (url, action) => person.afterwards(action, url),
-        async prompt(message) {
-            throw new Error(`${message} is needed: ask the user to set it in ${env}, then run \`${rerun}\` again`);
+        async prompt() {
+            throw new Error("Lark setup must collect secrets on its page, not through terminal prompts");
+        },
+        async verificationToken(consoleUrl) {
+            const page = await startLarkVerificationPage({
+                consoleUrl,
+                save: async (token) => {
+                    await appendChannelDotEnv(target, "lark", { LARK_VERIFICATION_TOKEN: token }, ["LARK_VERIFICATION_TOKEN"]);
+                },
+            });
+            return waitForLarkPage(person, page, "Paste the Lark Verification Token on this page.");
+        },
+        async collect({ consoleUrl, check }) {
+            const page = await startLarkCredentialsPage({
+                consoleUrl,
+                check: async ({ appId, appSecret }) => {
+                    try {
+                        await check(appId, appSecret);
+                    }
+                    catch (error) {
+                        // Only a known credential refusal is safe to retry on the form.
+                        if (!isFeishuCredentialsRefused(error))
+                            throw error;
+                        throw new LarkCredentialsRefused("Lark refused that App ID or Secret.", {
+                            fix: "Copy both again from Credentials & Basic Info.",
+                            why: `Lark said: ${error instanceof Error ? error.message : String(error)}`,
+                        });
+                    }
+                },
+            });
+            return waitForLarkPage(person, page, "Create the Lark app, then paste its App ID and App Secret on this page.");
         },
     };
 }
@@ -280,34 +332,6 @@ async function createFeishuAppFlow(target, existing, ingress, rerun, person) {
             person.afterwards(`after the permission work above, ${publish}: ${versionUrl}`);
     }
 }
-/**
- * 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 async function larkCredentialsNeeded(agentDir, again) {
-    const held = await activeDotEnvValues(agentDir, ["LARK_APP_ID", "LARK_APP_SECRET"]);
-    if (held.LARK_APP_ID && held.LARK_APP_SECRET)
-        return undefined;
-    const valueFile = dotEnvPath(agentDir);
-    return {
-        json: {
-            status: "need_user_action",
-            url: LARK_CONSOLE_URL,
-            variables: ["LARK_APP_ID", "LARK_APP_SECRET"],
-            value_file: valueFile,
-            check_command: `${again} --json`,
-            agent_next_steps: "Give the URL to the user so they can create the Lark app there, and ask them to set LARK_APP_ID and " +
-                `LARK_APP_SECRET (from its Credentials & Basic Info) in ${valueFile} themselves, not in this ` +
-                "conversation. Once they say they have, run check_command.",
-        },
-        text: [
-            `need_user_action: create the Lark app at ${LARK_CONSOLE_URL}`,
-            `  and set LARK_APP_ID and LARK_APP_SECRET in ${valueFile}`,
-            `then run: ${again}`,
-        ],
-    };
-}
 /**
  * Active agent `.env` (`.secrets/.env`) values for the requested names — decided by THE .env parser, so this check can
  * never disagree with what `loadDotEnv` reads.

package/dist/cli/commands/add.js

@@ -4,7 +4,7 @@
  */
 import { randomBytes } from "node:crypto";
 import { join, relative, resolve } from "node:path";
-import { assertIndependentFeishuApps, larkCredentialsNeeded, onboardFeishuCloudApp } from "../add-feishu.js";
+import { assertIndependentFeishuApps, onboardFeishuCloudApp } from "../add-feishu.js";
 import { terminalPerson } from "../person.js";
 import { isInteractive, shellArg } from "../shared.js";
 import { checkTicket, printReport, refusedCheck, runTicket, startTicket, ticketExitCode, ticketReport, } from "../ticket.js";
@@ -211,20 +211,13 @@ const SETUP_ACTIONS = {
     lark: "finish setting up the Lark app",
 };
 /**
- * `add slack|feishu|lark` with no one at a terminal to ask, for a coding agent: what the person must provide first is
- * named (Lark's app credentials, in the file the agent reads), never asked for in the agent's conversation; then the
- * app's setup runs in a process of its own (ticket.ts), and the command returns once the person has a step to take, it
- * is done, or it is still working at it.
+ * `add slack|feishu|lark` with no one at a terminal to ask, for a coding agent: the app's setup runs in a process of its
+ * own (ticket.ts), and the command returns once the person has a step to take, it is done, or it is still working at it.
+ * What only the person has (Slack's tokens, Lark's App ID and Secret) is pasted on a page of the setup's own, never asked
+ * for in the agent's conversation and never typed into a file.
  */
 async function setUpUnattended(kind, opts, at) {
     const { target } = at;
-    if (kind === "lark") {
-        const needed = await larkCredentialsNeeded(target, at.rerun).catch(failStartup);
-        if (needed !== undefined) {
-            printReport(opts.json, needed.json, needed.text);
-            process.exit(0);
-        }
-    }
     const timeout = opts.timeout === undefined ? UNATTENDED_TIMEOUT_SECONDS : Number(opts.timeout);
     if (!Number.isInteger(timeout) || timeout <= 0)
         failUsage(`--timeout must be a whole number of seconds`);

package/dist/cli/commands/content.js

@@ -1,5 +1,5 @@
 /**
- * `fastagent content list|add|remove`: what the agent works on and knows, as `context.json` declares it and
+ * `fastagent content list|add|remove`: what the agent works on, as `context.json` declares it and
  * `context.local.json` binds it on this machine.
  */
 import { resolve } from "node:path";

package/dist/cli/commands/deploy.js

@@ -8,7 +8,7 @@ import { FEISHU_INGRESS_SETTINGS } from "../../channels/feishu/setup-mode.js";
 import { assembleSecrets, divergentSettingsGate, missingValuesGate } from "../../deploy/secrets.js";
 import { dotEnvPath, loadEnvValues } from "../../value-file.js";
 import { unmarkDevServe } from "../../serving-command.js";
-import { assertIndependentFeishuApps, feishuAppSecretNames, larkCredentialsNeeded, prepareFeishuApps, unpreparedFeishuApps, } from "../add-feishu.js";
+import { assertIndependentFeishuApps, feishuAppSecretNames, prepareFeishuApps, unpreparedFeishuApps, } from "../add-feishu.js";
 import { displayPath, selectAgentEnvironment } from "../../paths.js";
 import { preflightDeploy } from "../../deploy/preflight.js";
 import { apiReport, deploymentApi, writeApiKey } from "../../deploy/api.js";
@@ -139,13 +139,6 @@ async function deploy(host, dirArg, opts, step) {
     const unprepared = opts.run ? unpreparedFeishuApps(pre.channels, pre.values) : [];
     if (opts.json && step === undefined) {
         // A coding agent's deploy: what this machine can refuse is refused above, at once; the rest runs in a ticket.
-        if (unprepared.some(({ kind }) => kind === "lark")) {
-            const needed = await larkCredentialsNeeded(agentDir, rerun).catch(failStartup);
-            if (needed !== undefined) {
-                printReport(true, needed.json, needed.text);
-                process.exit(0);
-            }
-        }
         const timeout = opts.timeout === undefined ? TICKET_TIMEOUT_SECONDS : Number(opts.timeout);
         if (!Number.isInteger(timeout) || timeout <= 0)
             failUsage("--timeout must be a whole number of seconds");

package/dist/cli/commands/info.js

@@ -8,6 +8,7 @@ import { enterAgentEnv } from "../../env.js";
 import { modelEnvironment } from "../../harnesses/models/environment.js";
 import { buildDefinition, modelSpecFor, prepareDefinition, secretsManifest } from "../../harnesses/pi-durable/open.js";
 import { readCommands } from "../../harnesses/pi-durable/text.js";
+import { inspectMcp } from "../../mcp/host.js";
 import { resolveStateRoot } from "../../paths.js";
 import { nextRun } from "../../schedule/cron.js";
 import { contentLines } from "../content-view.js";
@@ -60,6 +61,7 @@ export async function runInfo(dirArg, opts) {
     const commands = readCommands(agentDir).map(({ name, description }) => ({ name, description: description ?? null }));
     const stateRoot = resolveStateRoot(agentDir);
     const auth = models.auth;
+    const mcp = await inspectMcp(agentDir).catch(failStartup);
     if (opts.json) {
         console.log(JSON.stringify({
             agentDir,
@@ -72,6 +74,7 @@ export async function runInfo(dirArg, opts) {
             modelError: modelError ?? null,
             thinkingLevel: config.thinkingLevel ?? null,
             tools: code?.tools.map(({ name }) => name) ?? null,
+            mcp,
             extensions: code?.extensions.map(({ name }) => name) ?? null,
             channels: code === undefined ? null : channels,
             schedules: code === undefined ? null : schedules,
@@ -102,6 +105,7 @@ export async function runInfo(dirArg, opts) {
     line("tools", code ? code.tools.map(({ name }) => name).join(", ") || "(none)" : unbuilt);
     if (code && code.extensions.length > 0)
         line("extensions", code.extensions.map(({ name }) => name).join(", "));
+    line("mcp", mcp.map((server) => `${server.name} (${server.transport}, ${server.authorization})`).join(", ") || "(none)");
     line("channels", code ? channels.map((c) => `${c.name} (${c.ingress})`).join(", ") || "(none)" : unbuilt);
     line("schedules", code ? schedules.map((s) => `${s.name} (next ${s.next ?? "never"})`).join(", ") || "(none)" : unbuilt);
     line("commands", commands.map(({ name }) => `/${name}`).join(", ") || "(none)");

package/dist/cli/commands/invoke.js

@@ -8,14 +8,12 @@ import { AgentError } from "../../agent-api.js";
 import { enterAgentEnv } from "../../env.js";
 import { dotEnvPath, loadEnvValues } from "../../value-file.js";
 import { installProxyFetch } from "../../proxy.js";
-import { modelRefOf } from "../../harnesses/pi-durable/open.js";
-import { openServing } from "../../harnesses/pi-durable/serve.js";
+import { modelRefOf } from "../../model-ref.js";
 import { connectAgent } from "../../http/client.js";
 import { API_KEY_VARIABLE, apiKeysFrom } from "../../http/server.js";
 import { resolveStateRoot, selectAgentEnvironment } from "../../paths.js";
 import { runInvokeJson, runInvokeStream } from "../invoke-stream.js";
 import { failStartup, failUsage, optionalAgentDirOrExit } from "../fail.js";
-import { enterAgentCommand, reportAuth } from "../shared.js";
 /**
  * `invoke`'s sessions, apart from the instance's storage, so `invoke` runs beside a serve of this directory, which holds
  * that one; one `invoke` at a time holds this one.
@@ -112,6 +110,10 @@ export async function runInvoke(message, dirArg, opts) {
         return runRemoteInvoke(message, dirArg, { ...opts, url: opts.url });
     if (opts.key !== undefined)
         failUsage("--key is the key --url calls with: pass --url too");
+    const [{ openServing }, { enterAgentCommand, reportAuth }] = await Promise.all([
+        import("../../harnesses/pi-durable/serve.js"),
+        import("../shared.js"),
+    ]);
     const { agentDir, modelSpec } = await enterAgentCommand(dirArg, opts);
     const file = invokeStorageFile(resolveStateRoot(agentDir));
     const { agent, models, definition } = await openServing(agentDir, {

package/dist/cli/commands/mcp.d.ts

@@ -0,0 +1,12 @@
+export interface McpCommandOptions {
+    json?: boolean;
+    environment?: string;
+    scopes?: string;
+    timeout?: string;
+    clientId?: string;
+    callbackPort?: string;
+    check?: string;
+    ticket?: string;
+    input?: boolean;
+}
+export declare function runMcp(action: "list" | "login" | "disconnect", server: string | undefined, dir: string, options: McpCommandOptions): Promise<void>;

package/dist/cli/commands/mcp.js

@@ -0,0 +1,156 @@
+/** MCP inspection, explicit sign-in and local binding removal. */
+import { confirm, isCancel } from "@clack/prompts";
+import { inspectMcp, mcpContext, writeMcpBinding, httpServer } from "../../mcp/host.js";
+import { signInMcp } from "../../mcp/sign-in.js";
+import { holdingInstance } from "../../harnesses/pi-durable/serve.js";
+import { resolveMcpServers } from "../../mcp/config.js";
+import { McpError } from "../../mcp-api.js";
+import { selectAgentEnvironment } from "../../paths.js";
+import { enterAgentEnv } from "../../env.js";
+import { openExternalUrl } from "../../open-url.js";
+import { isInteractive, shellArg } from "../shared.js";
+import { agentDirOrExit, failStartup, failUsage } from "../fail.js";
+import { checkTicket, refusedCheck, runTicket, startTicket, ticketExitCode, ticketReport, printReport, } from "../ticket.js";
+const CHECK = "fastagent mcp login --check";
+function report(ticket, json, when) {
+    const result = ticketReport(ticket, when, (value) => ({
+        fields: value,
+        text: ["MCP authorization saved and bound; reopen the agent to use it"],
+        next: "Reopen the agent to use its MCP tools.",
+    }));
+    printReport(json, result.json, result.text);
+}
+export async function runMcp(action, server, dir, options) {
+    if (options.check) {
+        const refusal = refusedCheck(options.check, CHECK);
+        if (refusal)
+            return failUsage(refusal);
+        const ticket = await checkTicket(options.check);
+        if (!ticket)
+            return failUsage("MCP sign-in ticket not found");
+        report(ticket, !!options.json, "checked");
+        process.exit(ticketExitCode(ticket));
+    }
+    const target = agentDirOrExit(dir);
+    const environment = options.environment ?? "dev";
+    if (environment !== "dev" && environment !== "production")
+        return failUsage("--env must be dev or production");
+    selectAgentEnvironment(environment);
+    enterAgentEnv(target);
+    if (action === "list") {
+        const servers = await inspectMcp(target).catch(failStartup);
+        if (options.json)
+            console.log(JSON.stringify(servers));
+        else
+            for (const item of servers)
+                console.log(`${item.name}\t${item.transport}\t${item.authorization}`);
+        return;
+    }
+    if (!server)
+        return failUsage(`mcp ${action} needs a server name from .mcp.json`);
+    const context = mcpContext(target);
+    if (action === "disconnect") {
+        await holdingInstance(context.stateRoot, () => writeMcpBinding(context.stateRoot, server, undefined)).catch(failStartup);
+        printReport(!!options.json, {
+            status: "done",
+            server,
+            grant_revoked: false,
+            agent_next_steps: "The instance binding was removed. The stored grant was not revoked; reauthorize or update .mcp.json before reopening.",
+        }, ["Binding removed; the stored grant was not revoked. Reauthorize or update .mcp.json before reopening."]);
+        return;
+    }
+    httpServer(resolveMcpServers(target, context.environment, server), server);
+    const seconds = options.timeout === undefined ? 900 : Number(options.timeout);
+    if (!Number.isInteger(seconds) || seconds <= 0)
+        return failUsage("--timeout must be a positive whole number of seconds");
+    const scopes = options.scopes
+        ?.split(",")
+        .map((value) => value.trim())
+        .filter(Boolean);
+    const unattended = options.json || options.input === false || !isInteractive();
+    if (unattended && scopes === undefined)
+        return failUsage("mcp login without a terminal needs --scopes <comma-separated-scopes>; consult the MCP service's authorization requirements");
+    const run = async (step) => {
+        const grant = await signInMcp({
+            agentDir: target,
+            server,
+            store: context.auth.store,
+            scopes,
+            clientId: options.clientId,
+            callbackPort: options.callbackPort === undefined ? undefined : Number(options.callbackPort),
+            timeoutSeconds: seconds,
+            interaction: {
+                signal: step?.signal,
+                async confirmAuthorization(request) {
+                    const message = `Authorize ${request.server} at ${request.issuer} for ${request.scopes.join(", ") || "server-defined scopes"}?`;
+                    if (step) {
+                        console.error(`[fastagent] ${message}`);
+                        return true;
+                    }
+                    const choice = await confirm({ message, initialValue: false });
+                    return !isCancel(choice) && choice;
+                },
+                notify(event) {
+                    if (event.type === "auth_url") {
+                        const instructions = `Authorize the MCP server ${server} in your browser; scope: ${scopes?.join(", ") ?? "as approved"}. The callback is on the machine running this command; do not paste codes into chat.`;
+                        if (step)
+                            step.person.waitsOn(event.url, instructions);
+                        else {
+                            console.error(`${instructions}\n${event.url}`);
+                            openExternalUrl(event.url);
+                        }
+                    }
+                    else {
+                        step?.person.carriesOn();
+                        console.error(`[fastagent] ${event.message}`);
+                    }
+                },
+            },
+        });
+        await writeMcpBinding(context.stateRoot, server, grant.id);
+        return { server, grant_id: grant.id, scopes: grant.scopes };
+    };
+    if (options.ticket) {
+        await runTicket(options.ticket, (step) => run(step));
+        process.exit(0);
+    }
+    if (unattended && scopes !== undefined) {
+        const args = [
+            process.argv[1],
+            "mcp",
+            "login",
+            server,
+            target,
+            "--env",
+            environment,
+            "--scopes",
+            scopes.join(","),
+            "--timeout",
+            String(seconds),
+        ];
+        if (options.clientId)
+            args.push("--client-id", options.clientId);
+        if (options.callbackPort)
+            args.push("--callback-port", options.callbackPort);
+        const ticket = await startTicket({
+            subject: `mcp:login:${environment}:${target}:${server}`,
+            action: `authorize MCP server ${server}`,
+            check: CHECK,
+            restart: `fastagent ${args.slice(1).map(shellArg).join(" ")}`,
+            timeoutSeconds: seconds,
+            whenRunning: "replace",
+            waitsFirst: false,
+            command: { file: process.execPath, args: [...process.execArgv, ...args], cwd: process.cwd() },
+        });
+        report(ticket, !!options.json, "started");
+        process.exit(ticketExitCode(ticket));
+    }
+    const result = await run().catch((error) => {
+        if (error instanceof McpError && error.code === "canceled")
+            return failUsage(error.message);
+        return failStartup(error);
+    });
+    printReport(!!options.json, { status: "done", ...result }, [
+        "MCP authorization saved and bound; reopen the agent to use it",
+    ]);
+}

package/dist/cli/content-view.d.ts

@@ -2,7 +2,7 @@
 import type { BoundContent } from "../content/declare.ts";
 import { type ResolvedContent } from "../content/resolve.ts";
 /**
- * The report lines for an agent's content — `works on` / `knows`, one per entry, then a `notice` line for each
+ * The report lines for an agent's content — `works on`, one per entry, then a `notice` line for each
  * thing its resolution has to say, then one for each directory this machine binds that is not here — shared by the
  * startup report, `info` and `content list`, so the three say the same thing.
  */