@fastagent-sh/fastagent 0.19.0 → 0.20.0

package/dist/tunnel.js

@@ -7,11 +7,10 @@
  * Process orchestration, not assembly — lives outside the engine, beside dev-supervisor.ts.
  */
 import { spawn } from "node:child_process";
-import { readdirSync } from "node:fs";
-import { join } from "node:path";
 import { registerFeishuWebhook } from "./channels/feishu/register-webhook.js";
 import { registerSlackWebhook } from "./channels/slack/register-webhook.js";
 import { registerTelegramWebhook } from "./channels/telegram/register-webhook.js";
+import { pointChannelsAt } from "./deploy/channel-ingress.js";
 import { dotEnvPath, loadDotEnv } from "./env.js";
 import { resolveStateRoot } from "./paths.js";
 import { log } from "./log.js";
@@ -106,23 +105,23 @@ function lastErrorLine(tail) {
         .filter(Boolean);
     return ([...lines].reverse().find((l) => /err|error|failed/i.test(l)) ?? lines.at(-1) ?? "").slice(0, 200);
 }
-/** Channel basenames present in `<dir>/channels/`. */
-function channelBasenames(dir) {
-    try {
-        return readdirSync(join(dir, "channels"))
-            .filter((n) => /\.(ts|js|mjs)$/.test(n) && !n.endsWith(".d.ts"))
-            .map((n) => n.replace(/\.(ts|js|mjs)$/, ""));
-    }
-    catch {
-        return [];
-    }
-}
 /**
  * Print the public URL and wire up first-party webhook channels found under `dir` (the agent
  * ROOT): Telegram and Feishu/Lark use runtime credentials; onboarded Slack uses its owner-local config
  * token; GitHub and a manually scaffolded Slack app receive explicit console URLs.
+ *
+ * Returns what each registrar ANSWERED, because two kinds of caller need different things from a
+ * failure. `dev`/`start` are long-running: a webhook that did not register is a logged problem, not
+ * a reason to stop serving, and they void this. `deploy … --run` is a command that exits, and an
+ * exit 0 there tells its caller the deployment is reachable — so it feeds these through
+ * `registrationGate`, exactly as the fly/railway/agentcore runners feed their own registrar calls
+ * (docker used to be the one host that could not, because this returned nothing).
  */
-export async function announceWebhooks(dir, baseUrl, opts = {}) {
+export async function announceWebhooks(dir, baseUrl, 
+/** Every declared channel with its ingress. Not a pre-filtered list: this used to accept "the route
+ *  channels" and default to every basename in `channels/`, which pointed a webhook at a
+ *  long-connection channel whenever a caller forgot to filter. {@link pointChannelsAt} filters. */
+channels, opts = {}) {
     log.info(`[fastagent] public URL: ${baseUrl}`);
     try {
         loadDotEnv(dir); // webhook registrars read channel credentials from .env
@@ -135,33 +134,26 @@ export async function announceWebhooks(dir, baseUrl, opts = {}) {
         // missing-credential guidance. loadDotEnv keeps throwing for the synchronous command callers.
         log.warn(`[fastagent] could not read ${dotEnvPath(dir)}: ${error.message} — continuing without it`);
     }
-    // Serving passes the validated route-channel subset. The basename fallback preserves the public
-    // helper's behavior for callers that did not assemble channels first.
-    const routeChannels = opts.routeChannels ?? channelBasenames(dir);
-    if (routeChannels.length === 0)
-        return;
-    // Readiness is the registrar's job now: a fresh quick tunnel returns Cloudflare 530 for ~20-30s before
-    // its origin connects, and the automatic registrars poll /health before configuring the platform (the
-    // same wait the deploy runners rely on). GitHub needs no wait — the operator adds that webhook by hand.
-    if (routeChannels.includes("telegram"))
-        await registerTelegramWebhook(baseUrl);
-    if (routeChannels.includes("github")) {
-        log.info(`[fastagent] github: add a webhook in your repo (Settings → Webhooks): Payload URL = ${baseUrl}/webhook, content type application/json, secret = GITHUB_WEBHOOK_SECRET`);
-    }
-    if (routeChannels.includes("slack")) {
-        await registerSlackWebhook(baseUrl, {
-            stateRoot: opts.stateRoot ?? resolveStateRoot(dir),
-            log: (message) => log.info(message),
-        });
-    }
-    // feishu/lark register programmatically too (application-v7 config PATCH — telegram-setWebhook
-    // parity), once per mounted kind (each kind is its own app with its own credentials); the registrar
-    // owns its own health wait and degrades to the manual console instruction.
+    // Readiness is the registrar's job: a fresh quick tunnel returns Cloudflare 530 for ~20-30s before its
+    // origin connects, and the automatic registrars poll /health before configuring the platform (the same
+    // wait the deploy runners rely on). GitHub needs no wait — the operator adds that webhook by hand.
+    //
+    // The registrars differ from the deploy path's in what they carry, not in which channels they answer
+    // for: this one narrates to the log and opens the console for a manual Feishu step.
     const feishuOptions = {
         onManualRegistration: ({ consoleUrl }) => opts.openUrl?.(consoleUrl),
     };
-    if (routeChannels.includes("feishu"))
-        await registerFeishuWebhook(baseUrl, "feishu", feishuOptions);
-    if (routeChannels.includes("lark"))
-        await registerFeishuWebhook(baseUrl, "lark", feishuOptions);
+    return pointChannelsAt({
+        baseUrl,
+        channels,
+        log: (message) => log.info(`[fastagent] ${message}`),
+        registrars: {
+            telegram: (url) => registerTelegramWebhook(url),
+            slack: (url) => registerSlackWebhook(url, {
+                stateRoot: opts.stateRoot ?? resolveStateRoot(dir),
+                log: (message) => log.info(message),
+            }),
+            feishu: (url, kind) => registerFeishuWebhook(url, kind, feishuOptions),
+        },
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastagent-sh/fastagent",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "description": "Vibe first. Then FastAgent: turn a local agent directory into a live service in your app, on GitHub, Telegram, Slack, or behind any channel.",
   "keywords": [
     "agent",