@nettee/beacon 0.3.6 → 0.4.1

package/dist/{runtime → daemon/runtime}/pi-rpc.js

@@ -1,7 +1,6 @@
 import { spawn } from "node:child_process";
 import { chmod, mkdir } from "node:fs/promises";
 import { isAbsolute } from "node:path";
-import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
 import { assertRuntimeEnvironmentKey } from "../config/runtime-environment.js";
 export class PiRuntimeError extends Error {
@@ -83,7 +82,9 @@ function buildArguments(request) {
     if (request.systemPrompt)
         args.push("--system-prompt", request.systemPrompt);
     if (request.outcome) {
-        args.push("--extension", fileURLToPath(new URL("../../dist/runtime/pi-outcome-extension.js", import.meta.url)));
+        args.push("--extension", fileURLToPath(new URL(import.meta.url.endsWith(".ts")
+            ? "../../dist/runtime/pi-outcome-extension.js"
+            : "./pi-outcome-extension.js", import.meta.url)));
     }
     return args;
 }
@@ -153,6 +154,81 @@ async function stopProcess(child, terminateGraceMs) {
         });
     });
 }
+/**
+ * Read NDJSON frames from Pi stdout with a hard per-frame byte cap.
+ *
+ * Oversized frames (for example tool events carrying multi-MB stdout) are
+ * discarded through the next newline instead of failing the whole Run. Beacon
+ * only needs prompt responses, `message_end`, and `agent_settled`; intermediate
+ * tool frames are ignored anyway, and Pi already truncates tool output for the
+ * model. The cap still bounds parse/buffer memory — we never raise it here.
+ */
+export function createCappedNdjsonReader(maxFrameBytes, onFrame) {
+    if (!Number.isSafeInteger(maxFrameBytes) || maxFrameBytes <= 0) {
+        throw new Error("Pi RPC frame limit must be a positive integer");
+    }
+    const chunks = [];
+    let bufferedBytes = 0;
+    let discarding = false;
+    let closed = false;
+    let skippedOversizedFrames = 0;
+    const resetBuffer = () => {
+        chunks.length = 0;
+        bufferedBytes = 0;
+    };
+    const emitFrame = () => {
+        const line = Buffer.concat(chunks, bufferedBytes).toString("utf8");
+        resetBuffer();
+        onFrame(line);
+    };
+    const push = (chunk) => {
+        if (closed || chunk.length === 0)
+            return;
+        let offset = 0;
+        while (offset < chunk.length) {
+            if (discarding) {
+                const nl = chunk.indexOf(10, offset);
+                if (nl === -1)
+                    return;
+                discarding = false;
+                offset = nl + 1;
+                continue;
+            }
+            const nl = chunk.indexOf(10, offset);
+            const end = nl === -1 ? chunk.length : nl;
+            const pieceLen = end - offset;
+            if (bufferedBytes + pieceLen > maxFrameBytes) {
+                skippedOversizedFrames += 1;
+                resetBuffer();
+                if (nl === -1) {
+                    discarding = true;
+                    return;
+                }
+                offset = nl + 1;
+                continue;
+            }
+            if (pieceLen > 0) {
+                chunks.push(chunk.subarray(offset, end));
+                bufferedBytes += pieceLen;
+            }
+            if (nl === -1)
+                return;
+            emitFrame();
+            offset = nl + 1;
+        }
+    };
+    return {
+        push,
+        close: () => {
+            closed = true;
+            resetBuffer();
+            discarding = false;
+        },
+        get skippedOversizedFrames() {
+            return skippedOversizedFrames;
+        },
+    };
+}
 export async function runPiAgent(request, options = {}) {
     if (!request.prompt.trim())
         throw new Error("Pi Run prompt must not be empty");
@@ -197,11 +273,11 @@ export async function runPiAgent(request, options = {}) {
         env: buildPiEnvironment(request.outcome, options.environment, options.runtimeEnvironment),
         stdio: ["pipe", "pipe", "pipe"],
     });
-    const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
     let stderr = "";
     let finalMessage;
     let promptAccepted = false;
     let finished = false;
+    let frames;
     child.stderr.setEncoding("utf8");
     child.stderr.on("data", (chunk) => {
         stderr = (stderr + chunk).slice(-64 * 1024);
@@ -216,27 +292,7 @@ export async function runPiAgent(request, options = {}) {
                 reject(error);
             };
             const timer = setTimeout(() => fail(new PiRuntimeError("runtime_timeout", `Pi Run timed out after ${timeoutMs}ms${stderr.trim() ? `: ${stderr.trim()}` : ""}`)), timeoutMs);
-            let frameBytes = 0;
-            child.stdout.on("data", (chunk) => {
-                for (const byte of chunk) {
-                    if (byte === 10)
-                        frameBytes = 0;
-                    else
-                        frameBytes += 1;
-                    if (frameBytes > maxFrameBytes) {
-                        fail(new PiRuntimeError("runtime_protocol_error", `Pi RPC frame exceeds ${maxFrameBytes} bytes`));
-                        return;
-                    }
-                }
-            });
-            child.once("error", (error) => fail(new PiRuntimeError("runtime_spawn_failed", `Failed to start Pi: ${error.message}`, {
-                cause: error,
-            })));
-            child.once("exit", (code, signal) => {
-                if (!finished)
-                    fail(describeExit(code, signal, stderr));
-            });
-            lines.on("line", (line) => {
+            const handleFrame = (line) => {
                 if (finished)
                     return;
                 let value;
@@ -293,13 +349,24 @@ export async function runPiAgent(request, options = {}) {
                 catch (error) {
                     fail(error instanceof Error ? error : new Error(String(error)));
                 }
+            };
+            frames = createCappedNdjsonReader(maxFrameBytes, handleFrame);
+            child.stdout.on("data", (chunk) => {
+                frames?.push(chunk);
+            });
+            child.once("error", (error) => fail(new PiRuntimeError("runtime_spawn_failed", `Failed to start Pi: ${error.message}`, {
+                cause: error,
+            })));
+            child.once("exit", (code, signal) => {
+                if (!finished)
+                    fail(describeExit(code, signal, stderr));
             });
             child.stdin.on("error", (error) => fail(new PiRuntimeError("runtime_protocol_error", `Failed to write Pi RPC command: ${error.message}`, { cause: error })));
             child.stdin.write(`${JSON.stringify({ id: "run-prompt", type: "prompt", message: request.prompt })}\n`);
         });
     }
     finally {
-        lines.close();
+        frames?.close();
         await stopProcess(child, terminateGraceMs);
     }
 }

package/dist/daemon/runtime/system-prompt.d.ts

@@ -0,0 +1,10 @@
+import type { Profile } from "../config/profile.js";
+import type { DeliveryTarget, TriggerInput } from "../domain/types.js";
+export type AgentSystemPromptTrigger = {
+    kind: TriggerInput["kind"];
+    scheduleId?: string | undefined;
+    notify: boolean;
+};
+export declare function agentSystemPromptTrigger(input: TriggerInput | undefined, notifyTarget: DeliveryTarget | undefined): AgentSystemPromptTrigger;
+export declare function profilePromptDigest(profile: Pick<Profile, "persona" | "task">): string;
+export declare function buildAgentSystemPrompt(profile: Pick<Profile, "persona" | "task" | "workspace">, trigger: AgentSystemPromptTrigger): string;

package/dist/daemon/runtime-options.d.ts

@@ -0,0 +1,4 @@
+export type RuntimeOptions = {
+    /** Executable JavaScript CLI entry used by agent outcome submissions. */
+    beaconCliPath: string;
+};

package/dist/daemon/runtime-options.js

@@ -0,0 +1 @@
+export {};

package/dist/daemon/schedule/cron.d.ts

@@ -0,0 +1,2 @@
+export declare function occurrencesBetween(cron: string, timezone: string, afterExclusive: Date, throughInclusive: Date, limit: number): Date[];
+export declare function nextOccurrence(cron: string, timezone: string, afterExclusive: Date): Date;

package/dist/daemon/schedule/cursor-store.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+declare const cursorSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    scheduleId: z.ZodString;
+    through: z.ZodString;
+}, z.core.$strict>;
+export type ScheduleCursor = z.infer<typeof cursorSchema>;
+export declare class ScheduleCursorStore {
+    private readonly root;
+    constructor(profileDirectory: string);
+    private path;
+    private prepare;
+    read(scheduleId: string): Promise<ScheduleCursor | undefined>;
+    private write;
+    initialize(scheduleId: string, through: Date): Promise<ScheduleCursor>;
+    advance(scheduleId: string, through: Date): Promise<ScheduleCursor>;
+}
+export {};

package/dist/daemon/schedule/loop.d.ts

@@ -0,0 +1,17 @@
+import type { Profile } from "../config/profile.js";
+type Reconciler = {
+    reconcile(now: Date): Promise<void>;
+};
+export declare class ScheduleLoop {
+    private readonly profile;
+    private readonly reconciler;
+    private readonly onFatal;
+    private timer;
+    private stopped;
+    private active;
+    constructor(profile: Profile, reconciler: Reconciler, onFatal: (error: Error) => void);
+    start(after?: Date): void;
+    stop(): void;
+    drain(): Promise<void>;
+}
+export {};

package/dist/daemon/schedule/reconciler.d.ts

@@ -0,0 +1,16 @@
+import { type Profile } from "../config/profile.js";
+import type { TriggerInput } from "../domain/types.js";
+import type { TriggerStore } from "../state/trigger-store.js";
+import type { ScheduleCursorStore } from "./cursor-store.js";
+export type ScheduleReconcilerOptions = {
+    profile: Profile;
+    triggers: TriggerStore;
+    cursors: ScheduleCursorStore;
+    maxOccurrences: number;
+    process(triggerKey: string, normalize: () => Promise<TriggerInput>): Promise<void>;
+};
+export declare class ScheduleReconciler {
+    private readonly options;
+    constructor(options: ScheduleReconcilerOptions);
+    reconcile(now: Date): Promise<void>;
+}

package/dist/daemon/schedule-trigger.d.ts

@@ -0,0 +1,18 @@
+import { type Profile } from "./config/profile.js";
+import type { TriggerRecord } from "./domain/types.js";
+import type { RuntimeOptions } from "./runtime-options.js";
+import { TriggerStore } from "./state/trigger-store.js";
+export declare function triggerScheduleOnce(options: {
+    profile: Profile;
+    scheduleId: string;
+    store: TriggerStore;
+    process(triggerKey: string, normalize: () => Promise<{
+        kind: "schedule";
+        scheduleId: string;
+        scheduledFor: string;
+        text: string;
+    }>): Promise<void>;
+    now?: (() => Date) | undefined;
+    id?: (() => string) | undefined;
+}): Promise<TriggerRecord>;
+export declare function runScheduleTrigger(configPath: string, profileId: string, scheduleId: string, options: RuntimeOptions): Promise<void>;

package/dist/{schedule-trigger.js → daemon/schedule-trigger.js}

@@ -55,7 +55,7 @@ export async function triggerScheduleOnce(options) {
     }
     return record;
 }
-export async function runScheduleTrigger(configPath, profileId, scheduleId) {
+export async function runScheduleTrigger(configPath, profileId, scheduleId, options) {
     const global = await loadGlobalConfig(configPath);
     const runtimeEnvironment = await loadRuntimeEnvironment(global.runtimeEnvironmentPath);
     const channels = await loadChannelRegistry(global.channelsPath);
@@ -69,6 +69,7 @@ export async function runScheduleTrigger(configPath, profileId, scheduleId) {
     try {
         const store = new TriggerStore(profile.directory, profile.id);
         const orchestrator = createPiRunOrchestrator({
+            beaconCliPath: options.beaconCliPath,
             config: global,
             runtimeEnvironment,
             profile,

package/dist/daemon/service.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeOptions } from "./runtime-options.js";
+export declare function runBeacon(configPath: string, options: RuntimeOptions & {
+    uiDirectory?: string | undefined;
+}): Promise<void>;

package/dist/{service.js → daemon/service.js}

@@ -35,7 +35,7 @@ function shutdownController() {
         },
     };
 }
-export async function runBeacon(configPath) {
+export async function runBeacon(configPath, options) {
     const global = await loadGlobalConfig(configPath);
     const runtimeEnvironment = await loadRuntimeEnvironment(global.runtimeEnvironmentPath);
     const channels = await loadChannelRegistry(global.channelsPath);
@@ -50,6 +50,7 @@ export async function runBeacon(configPath) {
     try {
         if (global.dashboard.enabled) {
             dashboard = await startDashboard({
+                uiDirectory: options.uiDirectory,
                 listen: global.dashboard.listen,
                 port: global.dashboard.port,
                 profilesDirectory: global.profilesDirectory,
@@ -81,6 +82,7 @@ export async function runBeacon(configPath) {
         const gateway = createFeishuGateway(profileCredentials);
         const store = new TriggerStore(profile.directory, profile.id);
         const orchestrator = createPiRunOrchestrator({
+            beaconCliPath: options.beaconCliPath,
             config: global,
             runtimeEnvironment,
             profile,

package/dist/daemon/state/trigger-store.d.ts

@@ -0,0 +1,30 @@
+import { type DeliveryTarget, type TriggerInput, type TriggerRecord } from "../domain/types.js";
+export type TriggerClaim = {
+    input?: TriggerInput | undefined;
+    sourceKey: string[];
+    target: DeliveryTarget;
+    notifyTarget?: DeliveryTarget | undefined;
+    ingress?: Record<string, unknown> | undefined;
+    acceptedAt?: Date | undefined;
+};
+export declare class TriggerStore {
+    private readonly profileId;
+    readonly root: string;
+    constructor(profileDirectory: string, profileId: string);
+    recordPath(triggerKey: string): string;
+    private prepare;
+    private read;
+    private syncDirectory;
+    private write;
+    claim(request: TriggerClaim): Promise<{
+        created: boolean;
+        record: TriggerRecord;
+    }>;
+    update(triggerKey: string, transform: (record: TriggerRecord) => TriggerRecord): Promise<TriggerRecord>;
+    list(): Promise<TriggerRecord[]>;
+    /**
+     * Locate the Trigger whose reply or notify Delivery produced this Feishu
+     * outbound `message_id`. Newest accepted Trigger wins on collision.
+     */
+    findByDeliveredMessageId(messageId: string): Promise<TriggerRecord | undefined>;
+}

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const packageVersion: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nettee/beacon",
-  "version": "0.3.6",
+  "version": "0.4.1",
   "description": "A single-host bridge from messaging and schedules to isolated agent runs",
   "license": "Apache-2.0",
   "repository": {
@@ -23,7 +23,7 @@
   },
   "files": [
     "dist/",
-    "deploy/io.nettee.beacon.plist.example",
+    "deploy/",
     "examples/",
     "README.md",
     "LICENSE"
@@ -31,19 +31,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "tsc -p tsconfig.json && vite build --config dashboard-ui/vite.config.ts",
-    "bump-version": "node scripts/bump-version.mjs",
-    "check": "biome check .",
-    "dev": "tsx src/cli.ts",
-    "e2e:message": "tsc -p tsconfig.e2e.json --noEmit && pnpm build && tsx --test e2e/message/*.e2e.test.ts",
-    "prebuild": "node scripts/clean-dist.mjs",
-    "prepack": "pnpm build",
-    "test": "tsx --test src/*.test.ts src/**/*.test.ts scripts/*.test.mjs",
-    "test:package": "node scripts/test-package.mjs",
-    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p dashboard-ui/tsconfig.json --noEmit"
-  },
-  "packageManager": "pnpm@10.33.2",
   "engines": {
     "node": ">=22"
   },
@@ -53,18 +40,19 @@
     "yaml": "^2.9.1",
     "zod": "^4.1.8"
   },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node ../../scripts/assemble-cli.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "tsx --test src/*.test.ts",
+    "dev": "pnpm --dir ../.. build && node dist/cli.js",
+    "prepack": "pnpm --dir ../.. build",
+    "prebuild": "node ../../scripts/clean-dist.mjs"
+  },
   "devDependencies": {
-    "@biomejs/biome": "^2.5.13",
-    "@tailwindcss/vite": "^4.3.3",
+    "@nettee/beacon-daemon": "workspace:*",
+    "@nettee/beacon-web": "workspace:*",
     "@types/node": "^24.3.0",
-    "@types/react": "^19.3.0",
-    "@types/react-dom": "^19.3.0",
-    "@vitejs/plugin-react": "^6.1.1",
-    "react": "^19.3.0",
-    "react-dom": "^19.3.0",
-    "tailwindcss": "^4.3.3",
     "tsx": "^4.20.5",
-    "typescript": "^5.9.2",
-    "vite": "^8.3.0"
+    "typescript": "^5.9.2"
   }
 }