@flowdot.ai/daemon 1.0.0

package/dist/loop/types.d.ts

@@ -0,0 +1,280 @@
+export type ModelTier = 'simple' | 'capable' | 'complex';
+export declare function isModelTier(value: unknown): value is ModelTier;
+export type LoopId = string;
+export type LoopRunId = string;
+export type LoopStatus = 'running' | 'paused' | 'stopped' | 'expired' | 'error';
+export type LoopRunStatus = 'running' | 'success' | 'error';
+export type NotifyMethod = 'none' | 'terminal' | 'webhook' | 'slack';
+export type OnErrorAction = 'continue' | 'pause' | 'stop';
+export type IntervalType = 'duration' | 'cron';
+export interface LoopInterval {
+    readonly type: IntervalType;
+    readonly raw: string;
+    readonly milliseconds: number;
+    readonly cronExpression: string | null;
+    nextRunAt: Date;
+}
+export interface LoopOptions {
+    readonly model: ModelTier;
+    readonly maxRuns: number | null;
+    readonly onError: OnErrorAction;
+    readonly notify: NotifyMethod;
+    readonly webhookUrl: string | null;
+    readonly slackWebhookUrl: string | null;
+    readonly quiet: boolean;
+}
+export declare const DEFAULT_LOOP_OPTIONS: LoopOptions;
+export interface LoopStats {
+    totalRuns: number;
+    successfulRuns: number;
+    failedRuns: number;
+    consecutiveFailures: number;
+    lastRunAt: Date | null;
+    lastRunStatus: 'success' | 'error' | null;
+    lastRunDuration: number | null;
+    lastError: string | null;
+}
+export declare const INITIAL_LOOP_STATS: LoopStats;
+export interface Loop {
+    readonly id: LoopId;
+    readonly name: string | null;
+    readonly prompt: string;
+    readonly interval: LoopInterval;
+    status: LoopStatus;
+    readonly createdAt: Date;
+    readonly expiresAt: Date | null;
+    readonly options: LoopOptions;
+    stats: LoopStats;
+    readonly cwd: string;
+}
+export interface LoopRunError {
+    readonly code: string;
+    readonly message: string;
+    readonly stack: string | null;
+}
+export interface LoopRun {
+    readonly id: LoopRunId;
+    readonly loopId: LoopId;
+    readonly startedAt: Date;
+    completedAt: Date | null;
+    status: LoopRunStatus;
+    duration: number | null;
+    output: string | null;
+    error: LoopRunError | null;
+}
+export interface LoopRegistryEntry {
+    readonly id: LoopId;
+    readonly name: string | null;
+    status: LoopStatus;
+    readonly createdAt: string;
+    lastRunAt: string | null;
+}
+export interface LoopRegistry {
+    readonly version: number;
+    updatedAt: string;
+    loops: Record<LoopId, LoopRegistryEntry>;
+}
+export declare const LOOP_REGISTRY_VERSION = 1;
+export interface LoopDaemonConfig {
+    readonly port: number;
+    readonly logLevel: 'debug' | 'info' | 'warn' | 'error';
+    readonly healthCheckInterval: number;
+}
+export interface LoopWebhookConfig {
+    readonly defaultUrl: string | null;
+    readonly timeout: number;
+    readonly retries: number;
+}
+export interface LoopConfig {
+    readonly defaultExpiration: string;
+    readonly defaultOnError: OnErrorAction;
+    readonly defaultNotify: NotifyMethod;
+    readonly maxConcurrentLoops: number;
+    readonly minInterval: string;
+    readonly maxRunDuration: string;
+    readonly errorThreshold: number;
+    readonly daemon: LoopDaemonConfig;
+    readonly webhooks: LoopWebhookConfig;
+}
+export declare const DEFAULT_LOOP_CONFIG: LoopConfig;
+export interface CreateLoopInput {
+    readonly interval: string;
+    readonly prompt: string;
+    readonly name?: string;
+    readonly maxRuns?: number;
+    readonly expires?: string;
+    readonly model?: ModelTier;
+    readonly onError?: OnErrorAction;
+    readonly notify?: NotifyMethod;
+    readonly webhookUrl?: string;
+    readonly slackWebhookUrl?: string;
+    readonly quiet?: boolean;
+    readonly dryRun?: boolean;
+    readonly cwd?: string;
+}
+export interface UpdateLoopInput {
+    readonly identifier: string;
+    readonly name?: string;
+    readonly interval?: string;
+    readonly model?: ModelTier;
+    readonly onError?: OnErrorAction;
+    readonly notify?: NotifyMethod;
+}
+export type IPCMessageType = 'ping' | 'pong' | 'request' | 'create_loop' | 'pause_loop' | 'resume_loop' | 'stop_loop' | 'run_loop' | 'get_loop' | 'list_loops' | 'get_history' | 'get_stats' | 'shutdown' | 'response' | 'error' | 'event';
+export interface IPCMessage {
+    readonly type: IPCMessageType;
+    readonly id: string;
+    readonly payload?: unknown;
+    readonly timestamp: string;
+}
+export interface IPCRequest extends IPCMessage {
+    readonly type: Exclude<IPCMessageType, 'response' | 'error' | 'pong' | 'event'>;
+}
+export interface IPCResponse extends IPCMessage {
+    readonly type: 'response' | 'error';
+    readonly requestId: string;
+    readonly success: boolean;
+    readonly errorMessage?: string;
+    readonly errorCode?: string;
+}
+export interface IPCEvent extends IPCMessage {
+    readonly type: 'event';
+    readonly event: string;
+    readonly data: unknown;
+}
+export interface DaemonStatus {
+    readonly running: boolean;
+    readonly pid: number | null;
+    readonly startedAt: Date | null;
+    readonly activeLoops: number;
+    readonly uptime: number | null;
+}
+export interface ManagerStats {
+    totalLoops: number;
+    activeLoops: number;
+    pausedLoops: number;
+    stoppedLoops: number;
+    errorLoops: number;
+    totalRuns: number;
+    successfulRuns: number;
+    failedRuns: number;
+}
+export interface NotificationPayload {
+    readonly title: string;
+    readonly message: string;
+    readonly loopId: LoopId;
+    readonly loopName: string | null;
+    readonly runId?: LoopRunId;
+    readonly status?: LoopRunStatus;
+    readonly error?: string;
+    readonly timestamp: Date;
+}
+export interface Notifier {
+    readonly type: NotifyMethod;
+    send(payload: NotificationPayload): Promise<void>;
+}
+export declare function isLoopStatus(value: unknown): value is LoopStatus;
+export declare function isLoopRunStatus(value: unknown): value is LoopRunStatus;
+export declare function isNotifyMethod(value: unknown): value is NotifyMethod;
+export declare function isOnErrorAction(value: unknown): value is OnErrorAction;
+export declare function isIntervalType(value: unknown): value is IntervalType;
+export interface SerializedLoop {
+    id: string;
+    name: string | null;
+    prompt: string;
+    interval: {
+        type: IntervalType;
+        raw: string;
+        milliseconds: number;
+        cronExpression: string | null;
+        nextRunAt: string;
+    };
+    status: LoopStatus;
+    createdAt: string;
+    expiresAt: string | null;
+    options: LoopOptions;
+    stats: {
+        totalRuns: number;
+        successfulRuns: number;
+        failedRuns: number;
+        consecutiveFailures: number;
+        lastRunAt: string | null;
+        lastRunStatus: 'success' | 'error' | null;
+        lastRunDuration: number | null;
+        lastError: string | null;
+    };
+    cwd: string;
+}
+export interface SerializedLoopRun {
+    id: string;
+    loopId: string;
+    startedAt: string;
+    completedAt: string | null;
+    status: LoopRunStatus;
+    duration: number | null;
+    output: string | null;
+    error: LoopRunError | null;
+}
+export declare function serializeLoop(loop: Loop): SerializedLoop;
+export declare function deserializeLoop(data: SerializedLoop): Loop;
+export declare function serializeLoopRun(run: LoopRun): SerializedLoopRun;
+export declare function deserializeLoopRun(data: SerializedLoopRun): LoopRun;
+export interface SerializedRegistry {
+    version: number;
+    updatedAt: string;
+    loops: Record<string, SerializedLoop>;
+    byName: Record<string, string>;
+}
+export interface ExtendedLoopRegistry {
+    loops: Record<LoopId, Loop>;
+    byName: Record<string, LoopId>;
+    lastUpdated: Date;
+}
+export declare function serializeRegistry(registry: ExtendedLoopRegistry): SerializedRegistry;
+export declare function deserializeRegistry(data: SerializedRegistry): ExtendedLoopRegistry;
+export declare function createDefaultLoopOptions(overrides?: Partial<LoopOptions>): LoopOptions;
+export declare function createDefaultLoopStats(): LoopStats;
+export declare function createLoop(params: {
+    prompt: string;
+    interval: LoopInterval;
+    name?: string | null;
+    options?: Partial<LoopOptions>;
+    cwd?: string;
+    expiresAt?: Date | null;
+}): Loop;
+export declare function createLoopRun(loopId: LoopId): LoopRun;
+export declare function isActiveStatus(status: LoopStatus): boolean;
+export declare function isTerminalStatus(status: LoopStatus): boolean;
+export declare function canTransitionTo(from: LoopStatus, to: LoopStatus): boolean;
+export declare function generateLoopId(): LoopId;
+export declare function generateLoopRunId(): LoopRunId;
+export declare function isValidLoopId(value: unknown): value is LoopId;
+export declare function isValidLoopRunId(value: unknown): value is LoopRunId;
+export interface Logger {
+    debug(category: string, message: string, data?: Record<string, unknown>): void;
+    info(category: string, message: string, data?: Record<string, unknown>): void;
+    warn(category: string, message: string, data?: Record<string, unknown>): void;
+    error(category: string, message: string, data?: Record<string, unknown>): void;
+}
+export type AgenticResponseCallback = (chunk: string) => void;
+export type AgenticResponseFunction = (prompt: string, options: {
+    model?: ModelTier;
+    cwd?: string;
+    timeout?: number;
+    onOutput?: AgenticResponseCallback;
+    abortSignal?: AbortSignal;
+}) => Promise<{
+    success: boolean;
+    output: string;
+    error?: string;
+}>;
+export type ExecuteActionFunction = (action: string, options?: {
+    cwd?: string;
+    timeout?: number;
+    abortSignal?: AbortSignal;
+}) => Promise<{
+    success: boolean;
+    output: string;
+    error?: string;
+}>;
+export type LoopCreateInput = CreateLoopInput;

package/dist/loop/types.js

@@ -0,0 +1,222 @@
+export function isModelTier(value) {
+    return (typeof value === 'string' &&
+        ['simple', 'capable', 'complex'].includes(value));
+}
+export const DEFAULT_LOOP_OPTIONS = {
+    model: 'capable',
+    maxRuns: null,
+    onError: 'continue',
+    notify: 'none',
+    webhookUrl: null,
+    slackWebhookUrl: null,
+    quiet: false,
+};
+export const INITIAL_LOOP_STATS = {
+    totalRuns: 0,
+    successfulRuns: 0,
+    failedRuns: 0,
+    consecutiveFailures: 0,
+    lastRunAt: null,
+    lastRunStatus: null,
+    lastRunDuration: null,
+    lastError: null,
+};
+export const LOOP_REGISTRY_VERSION = 1;
+export const DEFAULT_LOOP_CONFIG = {
+    defaultExpiration: '3d',
+    defaultOnError: 'continue',
+    defaultNotify: 'none',
+    maxConcurrentLoops: 10,
+    minInterval: '1m',
+    maxRunDuration: '30m',
+    errorThreshold: 5,
+    daemon: {
+        port: 47691,
+        logLevel: 'info',
+        healthCheckInterval: 30000,
+    },
+    webhooks: {
+        defaultUrl: null,
+        timeout: 30000,
+        retries: 3,
+    },
+};
+export function isLoopStatus(value) {
+    return (typeof value === 'string' &&
+        ['running', 'paused', 'stopped', 'expired', 'error'].includes(value));
+}
+export function isLoopRunStatus(value) {
+    return (typeof value === 'string' &&
+        ['running', 'success', 'error'].includes(value));
+}
+export function isNotifyMethod(value) {
+    return (typeof value === 'string' &&
+        ['none', 'terminal', 'webhook', 'slack'].includes(value));
+}
+export function isOnErrorAction(value) {
+    return (typeof value === 'string' &&
+        ['continue', 'pause', 'stop'].includes(value));
+}
+export function isIntervalType(value) {
+    return (typeof value === 'string' &&
+        ['duration', 'cron'].includes(value));
+}
+export function serializeLoop(loop) {
+    return {
+        id: loop.id,
+        name: loop.name,
+        prompt: loop.prompt,
+        interval: {
+            type: loop.interval.type,
+            raw: loop.interval.raw,
+            milliseconds: loop.interval.milliseconds,
+            cronExpression: loop.interval.cronExpression,
+            nextRunAt: loop.interval.nextRunAt.toISOString(),
+        },
+        status: loop.status,
+        createdAt: loop.createdAt.toISOString(),
+        expiresAt: loop.expiresAt?.toISOString() ?? null,
+        options: loop.options,
+        stats: {
+            ...loop.stats,
+            lastRunAt: loop.stats.lastRunAt?.toISOString() ?? null,
+        },
+        cwd: loop.cwd,
+    };
+}
+export function deserializeLoop(data) {
+    return {
+        id: data.id,
+        name: data.name,
+        prompt: data.prompt,
+        interval: {
+            type: data.interval.type,
+            raw: data.interval.raw,
+            milliseconds: data.interval.milliseconds,
+            cronExpression: data.interval.cronExpression,
+            nextRunAt: new Date(data.interval.nextRunAt),
+        },
+        status: data.status,
+        createdAt: new Date(data.createdAt),
+        expiresAt: data.expiresAt ? new Date(data.expiresAt) : null,
+        options: data.options,
+        stats: {
+            ...data.stats,
+            lastRunAt: data.stats.lastRunAt ? new Date(data.stats.lastRunAt) : null,
+        },
+        cwd: data.cwd,
+    };
+}
+export function serializeLoopRun(run) {
+    return {
+        id: run.id,
+        loopId: run.loopId,
+        startedAt: run.startedAt.toISOString(),
+        completedAt: run.completedAt?.toISOString() ?? null,
+        status: run.status,
+        duration: run.duration,
+        output: run.output,
+        error: run.error,
+    };
+}
+export function deserializeLoopRun(data) {
+    return {
+        id: data.id,
+        loopId: data.loopId,
+        startedAt: new Date(data.startedAt),
+        completedAt: data.completedAt ? new Date(data.completedAt) : null,
+        status: data.status,
+        duration: data.duration,
+        output: data.output,
+        error: data.error,
+    };
+}
+export function serializeRegistry(registry) {
+    const serializedLoops = {};
+    for (const [id, loop] of Object.entries(registry.loops)) {
+        serializedLoops[id] = serializeLoop(loop);
+    }
+    return {
+        version: LOOP_REGISTRY_VERSION,
+        updatedAt: registry.lastUpdated.toISOString(),
+        loops: serializedLoops,
+        byName: registry.byName,
+    };
+}
+export function deserializeRegistry(data) {
+    const loops = {};
+    for (const [id, serializedLoop] of Object.entries(data.loops)) {
+        loops[id] = deserializeLoop(serializedLoop);
+    }
+    return {
+        loops,
+        byName: data.byName,
+        lastUpdated: new Date(data.updatedAt),
+    };
+}
+export function createDefaultLoopOptions(overrides) {
+    return {
+        ...DEFAULT_LOOP_OPTIONS,
+        ...overrides,
+    };
+}
+export function createDefaultLoopStats() {
+    return { ...INITIAL_LOOP_STATS };
+}
+export function createLoop(params) {
+    return {
+        id: generateLoopId(),
+        name: params.name ?? null,
+        prompt: params.prompt,
+        interval: params.interval,
+        status: 'paused',
+        createdAt: new Date(),
+        expiresAt: params.expiresAt ?? null,
+        options: createDefaultLoopOptions(params.options),
+        stats: createDefaultLoopStats(),
+        cwd: params.cwd ?? process.cwd(),
+    };
+}
+export function createLoopRun(loopId) {
+    return {
+        id: generateLoopRunId(),
+        loopId,
+        startedAt: new Date(),
+        completedAt: null,
+        status: 'running',
+        duration: null,
+        output: null,
+        error: null,
+    };
+}
+export function isActiveStatus(status) {
+    return status === 'running';
+}
+export function isTerminalStatus(status) {
+    return status === 'stopped' || status === 'expired';
+}
+const STATUS_TRANSITIONS = {
+    running: ['paused', 'stopped', 'error', 'expired'],
+    paused: ['running', 'stopped'],
+    stopped: [],
+    expired: [],
+    error: ['paused', 'stopped', 'running'],
+};
+export function canTransitionTo(from, to) {
+    return STATUS_TRANSITIONS[from].includes(to);
+}
+export function generateLoopId() {
+    return `loop-${generateRandomId()}`;
+}
+export function generateLoopRunId() {
+    return `run-${generateRandomId()}`;
+}
+function generateRandomId() {
+    return Math.random().toString(36).substring(2, 10);
+}
+export function isValidLoopId(value) {
+    return typeof value === 'string' && value.startsWith('loop-') && value.length > 5;
+}
+export function isValidLoopRunId(value) {
+    return typeof value === 'string' && value.startsWith('run-') && value.length > 4;
+}

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "@flowdot.ai/daemon",
+  "version": "1.0.0",
+  "description": "Shared FlowDot daemon and loop/goal management for CLI and native app",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./loop": {
+      "types": "./dist/loop/index.d.ts",
+      "import": "./dist/loop/index.js"
+    }
+  },
+  "scripts": {
+    "clean": "rimraf dist coverage",
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "verify-pack": "node scripts/verify-pack.mjs",
+    "prepublishOnly": "npm run clean && npm run lint && npm test && npm run build && npm run verify-pack",
+    "prepare": "husky || true"
+  },
+  "keywords": [
+    "flowdot",
+    "daemon",
+    "loop",
+    "scheduler"
+  ],
+  "author": "FlowDot",
+  "license": "SEE LICENSE IN LICENSE",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ElliotTheGreek/flowdot-daemon.git"
+  },
+  "homepage": "https://flowdot.ai/docs/daemon",
+  "dependencies": {
+    "cron-parser": "^4.9.0",
+    "ms": "^2.1.3",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.15.0",
+    "@types/ms": "^2.1.0",
+    "@types/node": "^20.0.0",
+    "@types/node-notifier": "^8.0.5",
+    "@types/uuid": "^9.0.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "eslint": "^9.15.0",
+    "globals": "^15.12.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^15.2.10",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.0.0",
+    "typescript-eslint": "^8.15.0",
+    "vitest": "^3.2.4"
+  },
+  "peerDependencies": {
+    "@flowdot.ai/api": "^1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@flowdot.ai/api": {
+      "optional": true
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "optionalDependencies": {
+    "node-notifier": "^10.0.1"
+  },
+  "lint-staged": {
+    "*.ts": [
+      "eslint --fix"
+    ]
+  }
+}