@nettee/beacon 0.3.5 → 0.4.0

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;