@fastagent-sh/fastagent 0.24.4 → 0.25.0

package/dist/cli/add-slack.js

@@ -8,7 +8,8 @@ import { newSlackOnboardingState, onboardSlackApp } from "../channels/slack/onbo
 import { configTokenExpiry, readSlackOnboardingState, writeSlackOnboardingState, } from "../channels/slack/onboarding-state.js";
 import { startSlackSetupServer } from "../channels/slack/setup-server.js";
 import { startCloudflareTunnel } from "../tunnel.js";
-const CONFIG_TOKEN_URL = "https://api.slack.com/apps";
+/** Where an App Configuration token pair is generated. */
+const SLACK_CONFIG_TOKEN_URL = "https://api.slack.com/apps";
 async function promptValue(message, hidden = false, initialValue) {
     const result = hidden ? await password({ message }) : await clackText({ message, initialValue });
     if (isCancel(result))
@@ -20,10 +21,14 @@ async function promptValue(message, hidden = false, initialValue) {
 }
 /** The one place an App Configuration token pair is asked for and validated. */
 async function promptConfigTokens() {
-    console.error(`[fastagent] generate an App Configuration Token pair at ${CONFIG_TOKEN_URL}`);
-    openExternalUrl(CONFIG_TOKEN_URL);
+    console.error(`[fastagent] generate an App Configuration Token pair at ${SLACK_CONFIG_TOKEN_URL}`);
+    openExternalUrl(SLACK_CONFIG_TOKEN_URL);
     const configToken = await promptValue("Slack configuration access token (xoxe.xoxp-…)", true);
     const configRefreshToken = await promptValue("Slack configuration refresh token (xoxe-…)", true);
+    return checkedConfigTokens(configToken, configRefreshToken);
+}
+/** An App Configuration token pair, refused unless each is the kind Slack issues. */
+function checkedConfigTokens(configToken, configRefreshToken) {
     if (!configToken.startsWith("xoxe.") || !configRefreshToken.startsWith("xoxe-")) {
         throw new Error("invalid Slack configuration token prefix (expected xoxe. access + xoxe- refresh)");
     }
@@ -33,6 +38,8 @@ async function promptConfigTokens() {
 async function chooseTokenAction(prompt) {
     if (prompt.forced)
         return "replace-config";
+    if (!prompt.asks)
+        return "keep";
     const answer = await select({
         message: prompt.message,
         initialValue: "keep",
@@ -49,18 +56,69 @@ async function chooseTokenAction(prompt) {
         throw new Error("Slack onboarding cancelled");
     return answer;
 }
-/** Interactive single-workspace internal-app creation + installation. */
+const nothingToReplace = () => new Error("--replace-config found no local Slack onboarding state on this machine — nothing to replace. " +
+    "Run `fastagent add slack` to onboard, or update the Request URL manually in the Slack console");
+/** The temporary setup server and the tunnel to it, started once something needs them. */
+function setupEndpoint() {
+    let started;
+    return {
+        get: () => {
+            started ??= (async () => {
+                const server = await startSlackSetupServer();
+                const tunnel = await startCloudflareTunnel(server.port);
+                if (!tunnel) {
+                    await server.close();
+                    throw new Error("Slack onboarding needs a temporary HTTPS tunnel — install cloudflared and re-run");
+                }
+                console.error(`[fastagent] temporary Slack setup tunnel ready → ${tunnel.url}`);
+                return { server, tunnelUrl: tunnel.url, closeTunnel: () => tunnel.close() };
+            })();
+            return started;
+        },
+        /** The endpoint if something started it, never starting one. */
+        ifStarted: () => started?.catch(() => undefined),
+        async close() {
+            const endpoint = await started?.catch(() => undefined);
+            if (endpoint === undefined)
+                return;
+            endpoint.closeTunnel();
+            await endpoint.server.close().catch(() => { });
+        },
+    };
+}
+/** Single-workspace internal-app creation + installation. */
 export async function onboardSlackInternalApp(input) {
-    if (!(process.stdin.isTTY && process.stdout.isTTY)) {
-        throw new Error("`add slack` needs an interactive terminal for internal-app creation and OAuth — " +
-            "re-run in a terminal, or pass --no-onboard to scaffold only");
+    const { person } = input;
+    const endpoint = setupEndpoint();
+    /** A fresh pair: at the terminal, or on the setup server's page. */
+    const freshTokens = async () => {
+        if (person === undefined)
+            return promptConfigTokens();
+        const { server, tunnelUrl } = await endpoint.get();
+        person.waitsOn(`${tunnelUrl}${server.tokensPath}`, `generate a Slack App Configuration Token at ${SLACK_CONFIG_TOKEN_URL} and paste it on this page`);
+        const tokens = await server.waitForTokens(({ access, refresh }) => checkedConfigTokens(access, refresh));
+        person.carriesOn();
+        return tokens;
+    };
+    try {
+        await onboard(input, freshTokens, endpoint);
+    }
+    catch (error) {
+        // The browser that pasted the pair waits on the next page: it says why, as the ticket does.
+        await (await endpoint.ifStarted())?.server.failed(error.message);
+        throw error;
+    }
+    finally {
+        await endpoint.close();
     }
+}
+async function onboard(input, freshTokens, endpoint) {
+    const { person } = input;
+    const asks = person === undefined;
     let state = readSlackOnboardingState(input.stateRoot);
     const resumed = state !== undefined;
-    if (input.replaceConfig && !state) {
-        throw new Error("--replace-config found no local Slack onboarding state on this machine — nothing to replace. " +
-            "Run `fastagent add slack` to onboard, or update the Request URL manually in the Slack console");
-    }
+    if (input.replaceConfig && !state)
+        throw nothingToReplace();
     if (state?.installedAt) {
         const env = await readFile(dotEnvPath(input.target), "utf8")
             .then(parseEnvContent)
@@ -75,20 +133,19 @@ export async function onboardSlackInternalApp(input) {
                 `${missingRuntime.join(", ")} — ` +
                 "restore them from the Slack app console, or delete the app + onboarding state and create a new one");
         }
-        if (input.groupBehavior.explicit && state.groupBehavior !== input.groupBehavior.behavior) {
-            throw new Error(`the onboarded Slack app uses group behavior ${state.groupBehavior}; changing an installed app's ` +
-                "OAuth scopes is a migration. Keep the existing choice, or remove the app + Slack onboarding state and create a new app");
-        }
         const action = await chooseTokenAction({
             forced: input.replaceConfig === true,
+            asks,
             message: `Slack app ${state.appId ?? "(unknown)"} is already installed${state.teamName ? ` in ${state.teamName}` : ""}`,
             keepLabel: "Keep the installed app",
             replaceLabel: "Replace App Configuration tokens",
             replaceHint: "repair automatic dev/deploy Request URL updates",
         });
         if (action === "replace-config") {
-            writeSlackOnboardingState(input.stateRoot, { ...state, ...(await promptConfigTokens()) });
+            writeSlackOnboardingState(input.stateRoot, { ...state, ...(await freshTokens()) });
             console.error("[fastagent] replaced local Slack App Configuration tokens; runtime app credentials are unchanged");
+            // A browser that pasted the pair waits on the page after it: this is where the setup ends.
+            await (await endpoint.ifStarted())?.server.done("Slack App Configuration tokens replaced: you can close this page.");
         }
         else {
             console.error("[fastagent] keeping the installed Slack app and local configuration tokens");
@@ -96,69 +153,64 @@ export async function onboardSlackInternalApp(input) {
         return;
     }
     if (!state) {
-        const appName = await promptValue("Slack app name", false, `FastAgent ${basename(input.target)}`);
-        clackLog.info("Slack's configuration refresh token can manage apps owned by your user in this workspace. " +
-            "FastAgent stores it only in owner-readable local state; it is never deployed.");
-        state = newSlackOnboardingState({
-            appName,
-            groupBehavior: input.groupBehavior.behavior,
-            ...(await promptConfigTokens()),
-        });
-        writeSlackOnboardingState(input.stateRoot, state);
-    }
-    else if (input.groupBehavior.explicit && !state.appId) {
-        state = { ...state, groupBehavior: input.groupBehavior.behavior };
+        const appName = asks
+            ? await promptValue("Slack app name", false, `FastAgent ${basename(input.target)}`)
+            : `FastAgent ${basename(input.target)}`;
+        if (asks) {
+            clackLog.info("Slack's configuration refresh token can manage apps owned by your user in this workspace. " +
+                "FastAgent stores it only in owner-readable local state; it is never deployed.");
+        }
+        state = newSlackOnboardingState({ appName, ...(await freshTokens()) });
         writeSlackOnboardingState(input.stateRoot, state);
     }
     if (state.createAttemptedAt && !state.appId) {
         throw new Error(`a prior Slack app creation attempt at ${state.createAttemptedAt} returned no app ID — ` +
-            `inspect ${CONFIG_TOKEN_URL}; delete any incomplete app and ${input.stateRoot}/channels/slack/onboarding.json before retrying`);
+            `inspect ${SLACK_CONFIG_TOKEN_URL}; delete any incomplete app and ${input.stateRoot}/channels/slack/onboarding.json before retrying`);
     }
     // `--replace-config` also covers the created-but-not-installed state, where a revoked token would otherwise strand
     // the resume (rotation fails and no menu offers replacement).
     if (resumed && (!state.appId || input.replaceConfig)) {
         const action = await chooseTokenAction({
             forced: input.replaceConfig === true,
+            asks,
             message: "Resume Slack onboarding with which App Configuration tokens?",
             keepLabel: "Use the saved token pair",
             replaceLabel: "Paste a fresh token pair",
         });
         if (action === "replace-config") {
-            state = { ...state, ...(await promptConfigTokens()) };
+            state = { ...state, ...(await freshTokens()) };
             writeSlackOnboardingState(input.stateRoot, state);
         }
     }
-    const server = await startSlackSetupServer();
-    const tunnel = await startCloudflareTunnel(server.port);
-    if (!tunnel) {
-        await server.close();
-        throw new Error("Slack onboarding needs a temporary HTTPS tunnel — install cloudflared and re-run");
-    }
-    const requestUrl = `${tunnel.url}${server.requestPath}`;
-    const redirectUrl = `${tunnel.url}${server.redirectPath}`;
-    console.error(`[fastagent] temporary Slack setup tunnel ready → ${tunnel.url}`);
-    try {
-        // No local readiness probe: Slack challenges requestUrl from ITS network during app creation, and that is the
-        // reachability that matters (#421).
-        await onboardSlackApp({ stateRoot: input.stateRoot, state, requestUrl, redirectUrl }, {
-            note: (message) => clackLog.info(message),
-            openUrl: openExternalUrl,
-            waitForOAuth: () => server.waitForOAuth(),
-            writeRuntimeSecrets: async ({ botToken, signingSecret }) => {
-                const values = {
-                    ...(botToken ? { SLACK_BOT_TOKEN: botToken } : {}),
-                    ...(signingSecret ? { SLACK_SIGNING_SECRET: signingSecret } : {}),
-                };
-                if (Object.keys(values).length > 0) {
-                    await appendChannelDotEnv(input.target, "slack", values, Object.keys(values));
-                }
-            },
-        });
-        // What happened, once. What to do next is `add`'s "next steps" block.
-        console.error(`[fastagent] Slack app installed; credentials written to ${dotEnvPath(input.target)}`);
-    }
-    finally {
-        tunnel.close();
-        await server.close().catch(() => { });
-    }
+    const { server, tunnelUrl } = await endpoint.get();
+    const requestUrl = `${tunnelUrl}${server.requestPath}`;
+    const redirectUrl = `${tunnelUrl}${server.redirectPath}`;
+    // No local readiness probe: Slack challenges requestUrl from ITS network during app creation, and that is the
+    // reachability that matters (#421).
+    await onboardSlackApp({ stateRoot: input.stateRoot, state, requestUrl, redirectUrl }, {
+        note: (message) => (asks ? clackLog.info(message) : console.error(`[fastagent] ${message}`)),
+        openUrl: (url) => {
+            if (person === undefined)
+                return openExternalUrl(url);
+            // A browser that pasted the pair goes straight on; the ticket names the page for one that did not.
+            server.next(url);
+            person.waitsOn(url, "click Allow to install the Slack app in their workspace");
+        },
+        waitForOAuth: async () => {
+            const callback = await server.waitForOAuth();
+            person?.carriesOn();
+            return callback;
+        },
+        writeRuntimeSecrets: async ({ botToken, signingSecret }) => {
+            const values = {
+                ...(botToken ? { SLACK_BOT_TOKEN: botToken } : {}),
+                ...(signingSecret ? { SLACK_SIGNING_SECRET: signingSecret } : {}),
+            };
+            if (Object.keys(values).length > 0) {
+                await appendChannelDotEnv(input.target, "slack", values, Object.keys(values));
+            }
+        },
+    });
+    // What happened, once. What to do next is `add`'s "next steps" block.
+    console.error(`[fastagent] Slack app installed; credentials written to ${dotEnvPath(input.target)}`);
 }

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

@@ -1,8 +1,9 @@
 /** CLI presenter for the auth-status line `reportAuth` prints (invoke/dev/start). */
+import type { DeployHost } from "../deploy/hosts.ts";
 /**
  * Format the auth status for a provider, from `AgentModels.authStatus`'s answer. `deployed`: this process is a
- * deployed box, which logs in from the owner's workspace (`fastagent login --deployment`), never by a login run on it
- * by hand.
+ * deployed box, which logs in from the owner's agent directory (`fastagent login --deployment <host>`), never by a
+ * login run on it by hand; `host` is which one, when the box can tell (`deployedHost`).
  */
 export declare function formatAuthReport(status: {
     provider: string;
@@ -12,7 +13,13 @@ export declare function formatAuthReport(status: {
     error?: string;
     stored?: string;
     shadowed?: string;
-    deployed?: boolean;
+    deployed?: {
+        host: DeployHost | undefined;
+    };
+    local?: {
+        authPath: string;
+        valueFile: string;
+    };
 }): {
     line: string;
     warn?: string;

package/dist/cli/auth-view.js

@@ -1,13 +1,15 @@
-/** CLI presenter for the auth-status line `reportAuth` prints (invoke/dev/start). */
 /**
  * Format the auth status for a provider, from `AgentModels.authStatus`'s answer. `deployed`: this process is a
- * deployed box, which logs in from the owner's workspace (`fastagent login --deployment`), never by a login run on it
- * by hand.
+ * deployed box, which logs in from the owner's agent directory (`fastagent login --deployment <host>`), never by a
+ * login run on it by hand; `host` is which one, when the box can tell (`deployedHost`).
  */
 export function formatAuthReport(status) {
-    const { provider, path, source, error, stored, shadowed, deployed = false } = status;
+    const { provider, path, source, error, stored, shadowed, deployed, local } = status;
     const because = error === undefined ? "" : ` (${error})`;
-    const login = (name) => deployed ? `\`${name} --deployment\` from the workspace this was deployed from` : `\`${name}\``;
+    const authOverride = local ? `FASTAGENT_AUTH_PATH='${local.authPath.replaceAll("'", "'\\''")}' ` : "";
+    const login = (name) => deployed
+        ? `\`${name} --deployment ${deployed.host ?? "<host>"}\` from the agent directory this was deployed from`
+        : `\`${authOverride}${name}\``;
     if (source !== undefined) {
         const line = `auth:   ${source} (${provider}) — ${path}`;
         if (shadowed === undefined)
@@ -27,6 +29,6 @@ export function formatAuthReport(status) {
     }
     return {
         line: `auth:   (none found) — ${path}`,
-        warn: `no credentials for "${provider}"${because} — run ${login("fastagent login")}, or set the provider's API key in ${deployed ? "the deployment's value file" : ".env"}; invokes will fail until then`,
+        warn: `no credentials for "${provider}"${because} — run ${login("fastagent login")}, or set the provider's API key in ${deployed ? "the deployment's value file" : (local?.valueFile ?? ".env")}; invokes will fail until then`,
     };
 }

package/dist/cli/box-login.d.ts

@@ -1,32 +1,42 @@
 import { type BoxShell } from "../deploy/box-shell.ts";
 import type { DeployHost } from "../deploy/hosts.ts";
-import type { LoginIO } from "../engines/pi/login.ts";
-import type { ResolvedPlacement } from "../paths.ts";
+import type { LoginIO, LoginMethod } from "../harnesses/models/login.ts";
+import type { TicketStep } from "./ticket.ts";
 export interface BoxLoginRequest {
     host: DeployHost;
     shell: BoxShell;
-    placement: ResolvedPlacement;
     /** Skip the provider menu. */
     provider?: string;
+    /** Skip the method menu. */
+    method?: LoginMethod;
     /** Keep a credential the box already holds for `provider` (a redeploy), instead of replacing it. */
     ifMissing?: boolean;
     /** false: never ask; a box without the credential is a failure naming the command to run in a terminal. */
     input: boolean;
+    /** Who answers what the box asks: this terminal by default, or a ticket's process ({@link ticketLoginIO}). */
+    io?: LoginIO;
 }
 /**
  * Run the login on the box and report its outcome. Resolves `undefined` once the box reports a credential for the
  * provider (logged in now, or kept), else with the one line saying why not and what to run.
  */
 export declare function loginOnBox(request: BoxLoginRequest): Promise<string | undefined>;
+/**
+ * A box's sign-in answered by a ticket's process, with no one at a terminal: what the person does is the ticket's
+ * (`need_user_action`), and what the box asks is answered as {@link signInInteraction} answers a local sign-in. A choice
+ * takes its first option, pi's default; a text question is left blank; the address the browser ended on comes from
+ * `login --check --code` (or the redirect {@link catchingRedirect} catches first); a secret it cannot take, and
+ * `refusal` says so, since the box only hears that the question was backed out of.
+ */
+export declare function ticketLoginIO(step: TicketStep, retry: string): LoginIO & {
+    refusal(): string | undefined;
+};
 /**
  * A browser OAuth flow sends the owner's browser back to its `redirect_uri`: a localhost address, which on the owner's
  * machine has nothing of the box behind it. So catch it here. While an authorization URL naming such a redirect is
  * open, listen on that address (the port the provider fixed, loopback only, as pi's own flows do), and answer the
- * next text prompt with the URL the browser brought back, exactly what the person would paste. The terminal prompt
+ * prompt for that address with the URL the browser brought back, exactly what the person would paste. The prompt
  * stays up meanwhile: a taken port, or a browser on another machine, still leaves pasting.
- *
- * ponytail: "the next text prompt" is the one after the URL. pi's browser flows (Anthropic, Codex) ask exactly one,
- * the paste; a flow that asked something else in between would get the URL as that answer and reject it.
  */
 export declare function catchingRedirect(io: LoginIO): LoginIO & {
     close(): void;

package/dist/cli/box-login.js

@@ -5,7 +5,6 @@
  * copied from this machine.
  */
 import { createServer } from "node:http";
-import { basename } from "node:path";
 import { deploymentLoginCommand } from "../deploy/box-shell.js";
 import { boxLoginCommand } from "../deploy/container.js";
 import { relayLogin } from "./login-relay.js";
@@ -15,16 +14,17 @@ import { terminalLoginIO } from "./shared.js";
  * provider (logged in now, or kept), else with the one line saying why not and what to run.
  */
 export async function loginOnBox(request) {
-    const { host, shell, placement, provider } = request;
+    const { host, shell, provider } = request;
     const retry = deploymentLoginCommand(host, provider);
     const args = [
         ...(provider ? [provider] : []),
+        ...(request.method ? ["--method", request.method === "oauth" ? "account" : "api-key"] : []),
         ...(request.ifMissing ? ["--if-missing"] : []),
         ...(request.input ? [] : ["--no-input"]),
     ];
     let command;
     try {
-        command = boxLoginCommand(basename(placement.agentDir), args, shell.storage);
+        command = boxLoginCommand(args, shell.storage);
     }
     catch (error) {
         return error.message;
@@ -36,7 +36,7 @@ export async function loginOnBox(request) {
     const channel = await shell.open(command).catch((error) => error);
     if (channel instanceof Error)
         return channel.message;
-    const io = catchingRedirect(terminalLoginIO());
+    const io = catchingRedirect(request.io ?? terminalLoginIO());
     const result = await relayLogin(channel.output, channel.input, io, (line) => console.error(line)).finally(io.close);
     const closed = await channel.closed;
     if (!closed.opened)
@@ -51,23 +51,55 @@ export async function loginOnBox(request) {
             : `[fastagent] logged in to ${result.provider} (${result.method}) on the deployment — saved to ${result.path} there`);
         return undefined;
     }
-    if (result.reason === "missing")
-        return `not logged in: ${result.message} — run \`${retry}\` in a terminal`;
+    if (result.reason === "missing") {
+        const forAgent = provider
+            ? `fastagent login ${provider} --method account --deployment ${host} --json`
+            : `${retry} --json`;
+        return (`not logged in: ${result.message} — run \`${retry}\` in a terminal, or \`${forAgent}\` from a coding agent, ` +
+            `which hands the sign-in to its user`);
+    }
     if (result.reason === "cancelled")
         return `login on the deployment cancelled — run \`${retry}\` to log it in`;
     return `login on the deployment failed: ${result.message}`;
 }
 const CAUGHT_PAGE = "<!doctype html><meta charset=utf-8><title>fastagent</title>" +
     "<p>fastagent received the sign-in and sent it to your deployment. Return to your terminal.</p>";
+/**
+ * A box's sign-in answered by a ticket's process, with no one at a terminal: what the person does is the ticket's
+ * (`need_user_action`), and what the box asks is answered as {@link signInInteraction} answers a local sign-in. A choice
+ * takes its first option, pi's default; a text question is left blank; the address the browser ended on comes from
+ * `login --check --code` (or the redirect {@link catchingRedirect} catches first); a secret it cannot take, and
+ * `refusal` says so, since the box only hears that the question was backed out of.
+ */
+export function ticketLoginIO(step, retry) {
+    let refusal;
+    return {
+        refusal: () => refusal,
+        select: async (_message, options) => options[0]?.value,
+        async prompt(message, opts) {
+            if (opts?.hidden) {
+                refusal = `the sign-in asks "${message}", which only a terminal can answer: run \`${retry}\` in one`;
+                return undefined;
+            }
+            if (!opts?.redirect)
+                return "";
+            const address = await step
+                .address(opts.signal ? AbortSignal.any([opts.signal, step.signal]) : step.signal)
+                .catch(() => undefined);
+            if (address !== undefined)
+                step.person.carriesOn();
+            return address;
+        },
+        note: (message) => console.error(`[fastagent] ${message}`),
+        openUrl: (url, userCode) => step.waits(userCode ? { url, code: userCode } : { url, takesAddress: true }),
+    };
+}
 /**
  * A browser OAuth flow sends the owner's browser back to its `redirect_uri`: a localhost address, which on the owner's
  * machine has nothing of the box behind it. So catch it here. While an authorization URL naming such a redirect is
  * open, listen on that address (the port the provider fixed, loopback only, as pi's own flows do), and answer the
- * next text prompt with the URL the browser brought back, exactly what the person would paste. The terminal prompt
+ * prompt for that address with the URL the browser brought back, exactly what the person would paste. The prompt
  * stays up meanwhile: a taken port, or a browser on another machine, still leaves pasting.
- *
- * ponytail: "the next text prompt" is the one after the URL. pi's browser flows (Anthropic, Codex) ask exactly one,
- * the paste; a flow that asked something else in between would get the URL as that answer and reject it.
  */
 export function catchingRedirect(io) {
     let server;
@@ -125,11 +157,13 @@ export function catchingRedirect(io) {
         select: io.select,
         note: io.note,
         close,
-        openUrl(url) {
+        openUrl(url, userCode) {
             listen(url);
-            io.openUrl(url);
+            io.openUrl(url, userCode);
         },
         async prompt(message, opts) {
+            if (!opts?.redirect)
+                return io.prompt(message, opts);
             if (caught !== undefined) {
                 const url = caught;
                 caught = undefined;

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

@@ -1,11 +1,22 @@
 import { type ChannelKind } from "../../scaffold/add-channel.ts";
-/** `fastagent add <kind> [dir]`: scaffold `channels/<kind>.ts` — the adapter import plus a starter `on()`. */
-export declare function runAddChannel(channelKind: ChannelKind, dirArg: string, opts: {
+export interface AddChannelOptions {
     ingress?: string;
-    groupBehavior?: string;
     onboard?: boolean;
     replaceConfig?: boolean;
-}): Promise<void>;
+    environment?: string;
+    /** false ⇔ `--no-input`. */
+    input?: boolean;
+    /** `--json`: the outcome as one JSON object on stdout. */
+    json?: boolean;
+    /** `--check <ticket>`: where an app's setup started without a terminal stands. */
+    check?: string;
+    /** `--timeout <seconds>`: how long a setup started without a terminal stays open. */
+    timeout?: string;
+    /** `--ticket <id>`: the process that runs a ticket's setup. */
+    ticket?: string;
+}
+/** `fastagent add <kind> [dir]`: scaffold `src/channels/<kind>.ts`, the adapter configured with a starter policy. */
+export declare function runAddChannel(channelKind: ChannelKind, dirArg: string, opts: AddChannelOptions): Promise<void>;
 /** `fastagent add skill <source> [dir]`: vendor an Agent Skills skill into <dir>/skills/<name>/. */
 export declare function runAddSkill(source: string | undefined, dirArg: string, opts: {
     update?: boolean;