@fastagent-sh/fastagent 0.12.1 → 0.14.0

package/dist/tunnel.js

@@ -1,14 +1,15 @@
 /**
  * `--tunnel`: expose the local dev server on a public HTTPS URL via a Cloudflare quick tunnel, then
- * auto-register the first-party webhook channels against it (telegram setWebhook; github prints the
- * URL to paste into repo settings). This closes the "local dev → public URL" gap webhooks need.
+ * auto-register the first-party webhook channels against it (Telegram setWebhook; Feishu/Lark
+ * application-config PATCH; GitHub prints the URL to paste into repo settings). This closes the
+ * "local dev → public URL" gap webhooks need.
  *
  * 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 { setTimeout as sleep } from "node:timers/promises";
+import { registerFeishuWebhook } from "./channels/feishu/register-webhook.js";
 import { registerTelegramWebhook } from "./channels/telegram/register-webhook.js";
 import { loadDotEnv } from "./env.js";
 import { log } from "./log.js";
@@ -21,8 +22,12 @@ const TUNNEL_URL_RE = /https:\/\/(?!api\.)[a-z0-9-]+\.trycloudflare\.com/i;
 export function parseTunnelUrl(chunk) {
     return chunk.match(TUNNEL_URL_RE)?.[0];
 }
+/** Global timer (rather than timers/promises) so timeout/retry behavior is deterministic under fake timers. */
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const TUNNEL_ATTEMPTS = 3;
 const TUNNEL_RETRY_MS = 2000;
+/** cloudflared can stay alive without ever receiving/printing an assigned quick-tunnel URL. */
+const TUNNEL_START_TIMEOUT_MS = 30_000;
 const spawnCloudflared = (port) => spawn("cloudflared", ["tunnel", "--url", `http://localhost:${port}`], { stdio: ["ignore", "pipe", "pipe"] });
 /**
  * Start a Cloudflare quick tunnel to localhost:`port`, resolving once its public URL appears.
@@ -32,9 +37,9 @@ const spawnCloudflared = (port) => spawn("cloudflared", ["tunnel", "--url", `htt
  * (Edge warmup AFTER the URL appears is handled downstream: the telegram registrar polls /health before
  * it calls setWebhook, so a not-yet-routable tunnel just delays registration rather than failing it.)
  */
-export async function startCloudflareTunnel(port, spawnFn = spawnCloudflared) {
+export async function startCloudflareTunnel(port, spawnFn = spawnCloudflared, attemptTimeoutMs = TUNNEL_START_TIMEOUT_MS) {
     for (let attempt = 1; attempt <= TUNNEL_ATTEMPTS; attempt++) {
-        const r = await spawnTunnelOnce(port, spawnFn);
+        const r = await spawnTunnelOnce(port, spawnFn, attemptTimeoutMs);
         if (r.tunnel)
             return r.tunnel;
         if (r.fatal) {
@@ -50,43 +55,45 @@ export async function startCloudflareTunnel(port, spawnFn = spawnCloudflared) {
     return undefined;
 }
 /** One cloudflared launch: a Tunnel on the first URL, or a failure (missing binary / exit before a URL). */
-function spawnTunnelOnce(port, spawnFn) {
+function spawnTunnelOnce(port, spawnFn, timeoutMs) {
     return new Promise((resolve) => {
         const child = spawnFn(port);
         let settled = false;
+        let timer;
         let tail = ""; // recent output, surfaced as the failure reason
-        const onChunk = (buf) => {
-            tail = (tail + String(buf)).slice(-600);
+        const finish = (result) => {
             if (settled)
                 return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            resolve(result);
+        };
+        const onChunk = (buf) => {
+            tail = (tail + String(buf)).slice(-600);
             const url = parseTunnelUrl(String(buf));
-            if (url) {
-                settled = true;
-                resolve({ tunnel: { url, close: () => child.kill("SIGTERM") } });
-            }
+            if (url)
+                finish({ tunnel: { url, close: () => child.kill("SIGTERM") } });
         };
         child.stdout?.on("data", onChunk);
         child.stderr?.on("data", onChunk); // cloudflared prints the URL (and its errors) on stderr
         child.on("error", (e) => {
-            if (settled)
-                return;
-            settled = true;
             if (e.code === "ENOENT") {
-                resolve({
+                finish({
                     fatal: true,
                     message: "[fastagent] --tunnel needs cloudflared — install it (e.g. `brew install cloudflared`), then re-run. Serving without a tunnel.",
                 });
             }
             else {
-                resolve({ fatal: false, detail: e.message });
+                finish({ fatal: false, detail: e.message });
             }
         });
-        child.on("exit", () => {
-            if (settled)
-                return;
-            settled = true;
-            resolve({ fatal: false, detail: lastErrorLine(tail) });
-        });
+        child.on("exit", () => finish({ fatal: false, detail: lastErrorLine(tail) }));
+        timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            finish({ fatal: false, detail: `timed out after ${Math.round(timeoutMs / 1000)}s waiting for a public URL` });
+        }, timeoutMs);
+        timer.unref();
     });
 }
 /** The most informative line of cloudflared's output tail (prefer an error line) for a failure log. */
@@ -109,31 +116,41 @@ function channelBasenames(dir) {
     }
 }
 /**
- * Print the public URL and wire up the first-party webhook channels found under `dir`: telegram is
- * auto-registered via setWebhook (using .env tokens); github prints the URL to add in repo settings.
+ * Print the public URL and wire up the first-party webhook channels found under `dir`: Telegram and
+ * Feishu/Lark auto-register using credentials from .env; GitHub prints the URL to add in repo settings.
  */
-export async function announceWebhooks(dir, baseUrl) {
+export async function announceWebhooks(dir, baseUrl, opts = {}) {
     log.info(`[fastagent] public URL: ${baseUrl}`);
     try {
-        loadDotEnv(dir); // telegram registration reads tokens from .env
+        loadDotEnv(dir); // webhook registrars read channel credentials from .env
     }
     catch (error) {
         // best-effort boundary: a MISSING .env is already tolerated by loadDotEnv; an unreadable one (EACCES,
         // or .env is a directory) must NOT crash the long-running dev/start server — announceWebhooks is
         // void-called with no unhandledRejection handler, so a throw here would terminate the process. Warn
-        // (surface it, rule 8) and continue best-effort; telegram registration then degrades to its manual
-        // instruction if the token is absent. loadDotEnv keeps throwing for the synchronous command callers.
+        // (surface it, rule 8) and continue best-effort; each registrar then surfaces its own
+        // missing-credential guidance. loadDotEnv keeps throwing for the synchronous command callers.
         log.warn(`[fastagent] could not read ${join(dir, ".env")}: ${error.message} — continuing without it`);
     }
     const channels = channelBasenames(dir);
     if (channels.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 registerTelegramWebhook polls /health until it serves before setWebhook (the
-    // same wait the deploy runners rely on). github needs no wait — the operator adds that webhook by hand.
+    // 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 (channels.includes("telegram"))
         await registerTelegramWebhook(baseUrl);
     if (channels.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`);
     }
+    // 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.
+    const feishuOptions = {
+        onManualRegistration: ({ consoleUrl }) => opts.openUrl?.(consoleUrl),
+    };
+    if (channels.includes("feishu"))
+        await registerFeishuWebhook(baseUrl, "feishu", feishuOptions);
+    if (channels.includes("lark"))
+        await registerFeishuWebhook(baseUrl, "lark", feishuOptions);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastagent-sh/fastagent",
-  "version": "0.12.1",
+  "version": "0.14.0",
   "description": "Vibe first. Then FastAgent: turn a local agent directory into a live service in your app, on GitHub, in Telegram, or behind any channel.",
   "keywords": [
     "agent",
@@ -9,6 +9,9 @@
     "agents.md",
     "agent-skills",
     "agent-serving",
+    "telegram",
+    "github",
+    "webhook",
     "sse",
     "pi",
     "fastagent"
@@ -51,6 +54,14 @@
       "types": "./dist/telegram.d.ts",
       "default": "./dist/telegram.js"
     },
+    "./feishu": {
+      "types": "./dist/feishu.d.ts",
+      "default": "./dist/feishu.js"
+    },
+    "./lark": {
+      "types": "./dist/lark.d.ts",
+      "default": "./dist/lark.js"
+    },
     "./package.json": "./package.json"
   },
   "bin": {
@@ -77,20 +88,23 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.6.0",
-    "@earendil-works/pi-agent-core": "^0.80.3",
-    "@earendil-works/pi-ai": "^0.80.3",
-    "@earendil-works/pi-coding-agent": "^0.80.3",
+    "@earendil-works/pi-agent-core": "^0.80.10",
+    "@earendil-works/pi-ai": "^0.80.10",
+    "@earendil-works/pi-coding-agent": "^0.80.10",
     "@octokit/webhooks-methods": "^6.0.0",
     "@octokit/webhooks-types": "^7.6.1",
     "chokidar": "^5.0.0",
+    "commander": "^15.0.0",
     "croner": "^10.0.1",
     "giget": "^3.3.0",
     "ignore": "^7.0.5",
+    "proper-lockfile": "^4.1.2",
     "undici": "^8.6.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.2",
+    "@types/proper-lockfile": "^4.1.4",
     "typescript": "^7.0.2",
     "vitest": "^4.1.9"
   }