@fastagent-sh/fastagent 0.15.0 → 0.16.0

package/dist/schedule/wakeups.js

@@ -47,6 +47,18 @@ function isWakeup(e) {
         (w.cron === undefined ||
             (typeof w.cron === "string" && cronError(w.cron, typeof w.tz === "string" ? w.tz : undefined) === undefined)));
 }
+/**
+ * The wake-ALARM sink: notified after EVERY wakeups-store mutation with the new pending set. The
+ * AgentCore deployment registers one (schedule/wake-alarm.ts) that mirrors pending wake-ups into
+ * one-shot EventBridge schedules — the external clock that makes `wake` reliable on a host with no
+ * resident process. Neutral seam: this module knows only "someone wants to observe changes"; a
+ * resident host registers nothing and behaves exactly as before. The sink is fire-and-forget and
+ * must own its errors; a throw is caught here so a broken alarm never corrupts a store write.
+ */
+let wakeupsSink;
+export function setWakeupsSink(sink) {
+    wakeupsSink = sink;
+}
 function load(stateRoot) {
     const v = readScheduleFile(scheduleFile(stateRoot, "wakeups"));
     if (v === undefined)
@@ -68,6 +80,12 @@ function load(stateRoot) {
 }
 function save(stateRoot, wakeups) {
     writeScheduleFile(scheduleFile(stateRoot, "wakeups"), wakeups);
+    try {
+        wakeupsSink?.(stateRoot, wakeups);
+    }
+    catch (e) {
+        log.error(`[schedule] wake-alarm sink failed (store write is unaffected): ${String(e)}`);
+    }
 }
 /** The current pending wake-ups (`fastagent schedule list` uses this). */
 export function listWakeups(stateRoot) {

package/dist/tunnel.d.ts

@@ -25,9 +25,9 @@ type SpawnCloudflared = (port: number) => ChildProcess;
  */
 export declare function startCloudflareTunnel(port: number, spawnFn?: SpawnCloudflared, attemptTimeoutMs?: number): Promise<Tunnel | undefined>;
 /**
- * Print the public URL and wire up first-party webhook channels found under `dir`: 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.
+ * 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.
  */
 export declare function announceWebhooks(dir: string, baseUrl: string, opts?: {
     openUrl?: (url: string) => void;

package/dist/tunnel.js

@@ -12,8 +12,8 @@ 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 { loadDotEnv } from "./env.js";
-import { resolveStateRoot } from "./engines/pi/config.js";
+import { dotEnvPath, loadDotEnv } from "./env.js";
+import { resolveStateRoot } from "./paths.js";
 import { log } from "./log.js";
 // `(?!api\.)`: cloudflared's ERROR lines mention its request endpoint (`https://api.trycloudflare.com/tunnel`,
 // e.g. "failed to request quick Tunnel: Post ... timeout" under a flaky proxy) — without the exclusion a
@@ -118,9 +118,9 @@ function channelBasenames(dir) {
     }
 }
 /**
- * Print the public URL and wire up first-party webhook channels found under `dir`: 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.
+ * 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.
  */
 export async function announceWebhooks(dir, baseUrl, opts = {}) {
     log.info(`[fastagent] public URL: ${baseUrl}`);
@@ -133,10 +133,10 @@ export async function announceWebhooks(dir, baseUrl, opts = {}) {
         // void-called with no unhandledRejection handler, so a throw here would terminate the process. Warn
         // (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`);
+        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 standalone behavior for callers that did not assemble channels first.
+    // helper's behavior for callers that did not assemble channels first.
     const routeChannels = opts.routeChannels ?? channelBasenames(dir);
     if (routeChannels.length === 0)
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastagent-sh/fastagent",
-  "version": "0.15.0",
+  "version": "0.16.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",
@@ -94,6 +94,9 @@
     "lint": "biome check src test && node scripts/check-doc-links.mjs && knip",
     "format": "biome check --write src test",
     "postbuild": "node scripts/copy-scaffold-assets.mjs",
+    "release:patch": "node scripts/release.mjs patch",
+    "release:minor": "node scripts/release.mjs minor",
+    "release:major": "node scripts/release.mjs major",
     "knip": "knip"
   },
   "dependencies": {

package/dist/channels/feishu/owned-threads.d.ts

@@ -1,7 +0,0 @@
-interface OwnedFeishuThreads {
-    has(chatId: string, rootId: string): boolean;
-    /** Idempotent, synchronous, pre-ACK persistence. A failed write throws so the platform redelivers. */
-    add(chatId: string, rootId: string): void;
-}
-export declare function createOwnedFeishuThreads(path: string, label: string, now?: () => number): OwnedFeishuThreads;
-export {};

package/dist/channels/feishu/owned-threads.js

@@ -1,47 +0,0 @@
-/**
- * Durable ownership index for group threads the channel created from a top-level summon. Feishu/Lark
- * deliver an ordinary thread continuation as `thread_id + root_id`; the root is the original user
- * message the channel reply-threaded under. Keeping that root across restarts lets the default route
- * admit unmentioned continuations only inside Agent-managed threads, never across the whole group.
- */
-import { log } from "../../log.js";
-import { loadStateFile, saveStateFile } from "../state.js";
-function isRecord(value) {
-    const record = value;
-    return (typeof record?.rootId === "string" &&
-        typeof record.chatId === "string" &&
-        typeof record.createdAt === "number" &&
-        Number.isFinite(record.createdAt));
-}
-export function createOwnedFeishuThreads(path, label, now = Date.now) {
-    const raw = loadStateFile(path);
-    let records = new Map();
-    if (raw !== undefined) {
-        if (typeof raw === "object" &&
-            raw !== null &&
-            !Array.isArray(raw) &&
-            Object.entries(raw).every(([rootId, record]) => isRecord(record) && record.rootId === rootId)) {
-            records = new Map(Object.entries(raw));
-        }
-        else {
-            log.warn(`${label} unexpected shape in ${path} — starting with no managed group threads`);
-        }
-    }
-    return {
-        has(chatId, rootId) {
-            const record = records.get(rootId);
-            return record?.chatId === chatId;
-        },
-        add(chatId, rootId) {
-            const existing = records.get(rootId);
-            if (existing?.chatId === chatId)
-                return;
-            const next = new Map(records);
-            next.set(rootId, { rootId, chatId, createdAt: now() });
-            // Persist the staged copy first: an IO failure must not leave memory claiming durability the file
-            // does not have. The webhook remains un-ACKed and the platform can redeliver after recovery.
-            saveStateFile(path, Object.fromEntries(next));
-            records = next;
-        },
-    };
-}

package/dist/channels/slack/owned-threads.d.ts

@@ -1,6 +0,0 @@
-interface OwnedSlackThreads {
-    has(teamId: string, channelId: string, rootTs: string): boolean;
-    add(teamId: string, channelId: string, rootTs: string): void;
-}
-export declare function createOwnedSlackThreads(path: string, label?: string, now?: () => number): OwnedSlackThreads;
-export {};

package/dist/channels/slack/owned-threads.js

@@ -1,43 +0,0 @@
-/** Durable roots of Slack group threads entered by an explicit summon. */
-import { log } from "../../log.js";
-import { loadStateFile, saveStateFile } from "../state.js";
-function key(teamId, channelId, rootTs) {
-    return `${teamId}:${channelId}:${rootTs}`;
-}
-function isRecord(value) {
-    const record = value;
-    return (typeof record?.teamId === "string" &&
-        typeof record.channelId === "string" &&
-        typeof record.rootTs === "string" &&
-        typeof record.createdAt === "number" &&
-        Number.isFinite(record.createdAt));
-}
-export function createOwnedSlackThreads(path, label = "[slack]", now = Date.now) {
-    const raw = loadStateFile(path);
-    let records = new Map();
-    if (raw !== undefined) {
-        if (typeof raw === "object" &&
-            raw !== null &&
-            !Array.isArray(raw) &&
-            Object.entries(raw).every(([id, record]) => isRecord(record) && key(record.teamId, record.channelId, record.rootTs) === id)) {
-            records = new Map(Object.entries(raw));
-        }
-        else {
-            log.warn(`${label} unexpected shape in ${path} — starting with no managed Slack threads`);
-        }
-    }
-    return {
-        has(teamId, channelId, rootTs) {
-            return records.has(key(teamId, channelId, rootTs));
-        },
-        add(teamId, channelId, rootTs) {
-            const id = key(teamId, channelId, rootTs);
-            if (records.has(id))
-                return;
-            const next = new Map(records);
-            next.set(id, { teamId, channelId, rootTs, createdAt: now() });
-            saveStateFile(path, Object.fromEntries(next));
-            records = next;
-        },
-    };
-}

package/dist/scaffold/templates/gitignore.agentdir-root

@@ -1,5 +0,0 @@
-# secrets — never commit (kept out of git and any deploy copy)
-.env
-
-# fastagent machine state (dev/start sessions + project-level auth.json credentials)
-.fastagent/

package/dist/scaffold/templates/gitignore.kit

@@ -1,2 +0,0 @@
-# dependencies (reinstalled at deploy)
-node_modules/

package/dist/workspace.d.ts

@@ -1,9 +0,0 @@
-import { type Ignore } from "ignore";
-/**
- * Guard that `<workspaceDir>/<name>` resolves INSIDE the workspace — a symlink that escapes (or an
- * absolute target) is rejected, so discovery/scaffolding never reaches out of the definition directory.
- * A missing target is fine (nothing to guard yet).
- */
-export declare function assertInsideWorkspace(workspaceDir: string, name: string): Promise<void>;
-/** Load `.gitignore` + `.fastagentignore` from `dir` into one matcher (case-sensitive), or undefined if none. */
-export declare function loadRootIgnore(dir: string): Promise<Ignore | undefined>;

package/dist/workspace.js

@@ -1,45 +0,0 @@
-/**
- * Workspace path/ignore utilities — engine-neutral (pure fs/path + the `ignore` matcher). Shared by the
- * scaffold (init/add) and the engine's channel discovery, so they live here, not under engines/pi.
- */
-import { readFile, realpath } from "node:fs/promises";
-import { isAbsolute, join, relative, resolve } from "node:path";
-import ignore, {} from "ignore";
-/**
- * Guard that `<workspaceDir>/<name>` resolves INSIDE the workspace — a symlink that escapes (or an
- * absolute target) is rejected, so discovery/scaffolding never reaches out of the definition directory.
- * A missing target is fine (nothing to guard yet).
- */
-export async function assertInsideWorkspace(workspaceDir, name) {
-    const target = join(workspaceDir, name);
-    const real = await realpath(target).catch((e) => {
-        if (e.code === "ENOENT" || e.code === "not_found")
-            return undefined;
-        throw e;
-    });
-    if (real === undefined)
-        return;
-    const root = await realpath(workspaceDir).catch(() => resolve(workspaceDir));
-    const rel = relative(root, real);
-    if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) {
-        throw new Error(`${target} resolves outside the workspace (${real}) — it must live inside the definition directory; ` +
-            `use a real directory or a symlink that stays within it`);
-    }
-}
-/** Load `.gitignore` + `.fastagentignore` from `dir` into one matcher (case-sensitive), or undefined if none. */
-export async function loadRootIgnore(dir) {
-    let rules = "";
-    for (const name of [".gitignore", ".fastagentignore"]) {
-        try {
-            rules += `\n${await readFile(join(dir, name), "utf8")}`;
-        }
-        catch (error) {
-            if (error.code !== "ENOENT") {
-                throw new Error(`cannot read ${join(dir, name)}: ${error.message}`);
-            }
-        }
-    }
-    // ignorecase:false — the library defaults to case-INSENSITIVE, which would make a rule `README.md`
-    // also drop an authored `readme.md`. Match git on a case-sensitive filesystem, reproducibly.
-    return rules.trim() === "" ? undefined : ignore({ ignorecase: false }).add(rules);
-}