@hhuangpanda/dsh-automation 0.0.0-stage → 0.3.34

package/lib/scheduler.d.ts

@@ -0,0 +1,58 @@
+import type { AutomationTask, AutomationRun, AutomationSchedulerHealth } from './types.js';
+import { AutomationDomain, type RunOutcome } from './domain.js';
+export declare const MAX_TIMER_DELAY_MS = 2147483647;
+export declare const RETRY_BASE_DELAY_MS = 1000;
+export declare const RETRY_MAX_DELAY_MS = 60000;
+export declare const DEFAULT_MAX_RUN_DURATION_MS: number;
+export declare const DELIVERY_TIMEOUT_MS = 15000;
+export type AutomationDeliverySender = (task: AutomationTask, run: AutomationRun, outcome: RunOutcome, signal: AbortSignal) => Promise<void>;
+export type AutomationRunCancelReason = 'manual' | 'timeout' | 'shutdown';
+export interface Clock {
+    now(): number;
+    setTimeout(callback: () => void, delay: number): () => void;
+}
+export interface AutomationRunnerResult {
+    readonly status: 'succeeded' | 'failed';
+    readonly sessionId: string;
+    readonly summary?: string;
+    readonly output?: string;
+    readonly error?: string;
+}
+export interface AutomationRunner {
+    run(task: AutomationTask, run: AutomationRun): Promise<AutomationRunnerResult>;
+    cancel?(runId: string, reason: AutomationRunCancelReason): boolean;
+}
+export declare const systemClock: Clock;
+export declare class AutomationScheduler {
+    readonly domain: AutomationDomain;
+    readonly runner: AutomationRunner;
+    readonly clock: Clock;
+    private readonly onError;
+    readonly maxRunDurationMs: number;
+    private readonly sender?;
+    private cancelTimer;
+    private generation;
+    private requested;
+    private stopped;
+    private driving;
+    private healthState;
+    private pendingFinish;
+    private activeDelivery;
+    private activeRun;
+    constructor(domain: AutomationDomain, runner: AutomationRunner, clock?: Clock, onError?: (error: unknown) => void, maxRunDurationMs?: number, sender?: AutomationDeliverySender | undefined);
+    start(): void;
+    health(): AutomationSchedulerHealth;
+    cancelRun(taskId: string, runId: string): boolean;
+    requestDrive(): void;
+    whenSettled(): Promise<void>;
+    stop(): Promise<void>;
+    private markHealthy;
+    private scheduleRetry;
+    private cancelActiveRun;
+    private clearTimer;
+    private arm;
+    private finishPendingRun;
+    private sendDelivery;
+    private drive;
+}
+//# sourceMappingURL=scheduler.d.ts.map

package/lib/scheduler.js

@@ -0,0 +1,287 @@
+import { AutomationDomain } from './domain.js';
+export const MAX_TIMER_DELAY_MS = 2_147_483_647;
+export const RETRY_BASE_DELAY_MS = 1_000;
+export const RETRY_MAX_DELAY_MS = 60_000;
+export const DEFAULT_MAX_RUN_DURATION_MS = 60 * 60_000;
+export const DELIVERY_TIMEOUT_MS = 15_000;
+export const systemClock = {
+    now: () => Date.now(),
+    setTimeout(callback, delay) {
+        const handle = setTimeout(callback, delay);
+        return () => clearTimeout(handle);
+    },
+};
+export class AutomationScheduler {
+    domain;
+    runner;
+    clock;
+    onError;
+    maxRunDurationMs;
+    sender;
+    cancelTimer;
+    generation = 0;
+    requested = false;
+    stopped = false;
+    driving;
+    healthState = { status: 'healthy', consecutiveFailures: 0 };
+    pendingFinish;
+    activeDelivery;
+    activeRun;
+    constructor(domain, runner, clock = systemClock, onError = (error) => console.error(error), maxRunDurationMs = DEFAULT_MAX_RUN_DURATION_MS, sender) {
+        this.domain = domain;
+        this.runner = runner;
+        this.clock = clock;
+        this.onError = onError;
+        this.maxRunDurationMs = maxRunDurationMs;
+        this.sender = sender;
+    }
+    start() {
+        this.requestDrive();
+    }
+    health() {
+        return structuredClone(this.healthState);
+    }
+    cancelRun(taskId, runId) {
+        const active = this.activeRun;
+        if (active === undefined || active.taskId !== taskId || active.runId !== runId)
+            return false;
+        return this.cancelActiveRun('manual');
+    }
+    requestDrive() {
+        if (this.stopped)
+            return;
+        this.clearTimer();
+        this.requested = true;
+        if (this.driving !== undefined)
+            return;
+        const driving = this.drive().then(() => this.markHealthy(), (error) => this.scheduleRetry(error));
+        this.driving = driving;
+        void driving.finally(() => {
+            if (this.driving === driving)
+                this.driving = undefined;
+            if (this.requested && !this.stopped)
+                this.requestDrive();
+        });
+    }
+    async whenSettled() {
+        while (this.driving !== undefined) {
+            const current = this.driving;
+            await current;
+            if (this.driving === current)
+                await Promise.resolve();
+        }
+    }
+    async stop() {
+        this.stopped = true;
+        this.requested = false;
+        this.clearTimer();
+        this.cancelActiveRun('shutdown');
+        this.activeDelivery?.abort(new Error('DSH stopped before message delivery settled; delivery may have completed.'));
+        const { retryAt: _retryAt, ...health } = this.healthState;
+        this.healthState = { ...health, status: 'stopped' };
+        await this.driving;
+    }
+    markHealthy() {
+        if (this.stopped || this.healthState.status === 'healthy')
+            return;
+        const { lastError, lastFailedAt } = this.healthState;
+        this.healthState = {
+            status: 'healthy',
+            consecutiveFailures: 0,
+            ...(lastError === undefined ? {} : { lastError }),
+            ...(lastFailedAt === undefined ? {} : { lastFailedAt }),
+        };
+    }
+    scheduleRetry(error) {
+        if (this.stopped)
+            return;
+        this.requested = false;
+        const now = this.clock.now();
+        const consecutiveFailures = this.healthState.consecutiveFailures + 1;
+        const delay = Math.min(RETRY_BASE_DELAY_MS * (2 ** (consecutiveFailures - 1)), RETRY_MAX_DELAY_MS);
+        this.healthState = {
+            status: 'retrying',
+            consecutiveFailures,
+            lastError: error instanceof Error ? error.message : String(error),
+            lastFailedAt: new Date(now).toISOString(),
+            retryAt: new Date(now + delay).toISOString(),
+        };
+        try {
+            this.onError(error);
+        }
+        catch { }
+        this.arm(now + delay);
+    }
+    cancelActiveRun(reason) {
+        const active = this.activeRun;
+        if (active === undefined)
+            return false;
+        if (active.cancelReason !== undefined)
+            return true;
+        if (this.runner.cancel?.(active.runId, reason) !== true)
+            return false;
+        active.cancelReason = reason;
+        active.cancelTimeout?.();
+        active.cancelTimeout = undefined;
+        return true;
+    }
+    clearTimer() {
+        this.generation += 1;
+        this.cancelTimer?.();
+        this.cancelTimer = undefined;
+    }
+    arm(target) {
+        const now = this.clock.now();
+        const delay = Math.max(0, Math.min(target - now, MAX_TIMER_DELAY_MS));
+        const generation = ++this.generation;
+        this.cancelTimer = this.clock.setTimeout(() => {
+            if (this.stopped || generation !== this.generation)
+                return;
+            this.cancelTimer = undefined;
+            this.requestDrive();
+        }, delay);
+    }
+    async finishPendingRun(now) {
+        const pending = this.pendingFinish;
+        if (pending === undefined)
+            return;
+        if (!pending.executionSaved) {
+            // Record execution and send intent together before any external side effect.
+            await this.domain.finishRun(pending.task.id, pending.run.id, pending.outcome, now, pending.task.delivery);
+            pending.executionSaved = true;
+        }
+        if (pending.deliveryResult === undefined) {
+            // The task/history may have been removed while persistence was retried.
+            const savedRun = this.domain.store.snapshot().tasks[pending.task.id]?.runs.find((run) => run.id === pending.run.id);
+            if (savedRun?.delivery?.status === 'sending'
+                && ['succeeded', 'failed', 'timed_out'].includes(savedRun.status)
+                && savedRun.delivery.botId === pending.task.delivery?.botId
+                && savedRun.delivery.targetId === pending.task.delivery?.targetId) {
+                pending.deliveryResult = await this.sendDelivery(pending.task, savedRun, pending.outcome, savedRun.delivery);
+            }
+        }
+        if (pending.deliveryResult !== undefined) {
+            // Retrying this write must never call the sender (or the Agent) again.
+            await this.domain.finishDelivery(pending.task.id, pending.run.id, pending.deliveryResult);
+        }
+        if (this.pendingFinish === pending)
+            this.pendingFinish = undefined;
+    }
+    async sendDelivery(task, run, outcome, delivery) {
+        const controller = new AbortController();
+        this.activeDelivery = controller;
+        let cancelTimeout;
+        let onAbort;
+        let status = 'sent';
+        let error;
+        try {
+            const aborted = new Promise((_resolve, reject) => {
+                onAbort = () => reject(controller.signal.reason);
+                controller.signal.addEventListener('abort', onAbort, { once: true });
+            });
+            cancelTimeout = this.clock.setTimeout(() => {
+                controller.abort(new Error('Message delivery timed out; it may have completed and will not be resent automatically.'));
+            }, DELIVERY_TIMEOUT_MS);
+            if (this.stopped)
+                controller.abort(new Error('DSH stopped before message delivery started.'));
+            await Promise.race([
+                aborted,
+                Promise.resolve().then(() => {
+                    controller.signal.throwIfAborted();
+                    const saved = this.domain.store.snapshot().tasks[task.id]?.runs.find((entry) => entry.id === run.id)?.delivery;
+                    if (saved?.status !== 'sending' || saved.botId !== delivery.botId || saved.targetId !== delivery.targetId || saved.attemptedAt !== delivery.attemptedAt)
+                        return;
+                    if (this.sender === undefined)
+                        throw new Error('Message delivery service is unavailable.');
+                    return this.sender(task, run, outcome, controller.signal);
+                }),
+            ]);
+        }
+        catch (cause) {
+            status = controller.signal.aborted ? 'unknown' : 'failed';
+            error = cause instanceof Error ? cause.message : String(cause);
+            if (!error)
+                error = 'Message delivery failed.';
+        }
+        finally {
+            cancelTimeout?.();
+            if (onAbort !== undefined)
+                controller.signal.removeEventListener('abort', onAbort);
+            if (this.activeDelivery === controller)
+                this.activeDelivery = undefined;
+        }
+        return { ...delivery, status, finishedAt: new Date(this.clock.now()).toISOString(), ...(error === undefined ? {} : { error }) };
+    }
+    async drive() {
+        while (this.requested && !this.stopped) {
+            this.requested = false;
+            if (this.pendingFinish !== undefined) {
+                await this.finishPendingRun(this.clock.now());
+                this.requested = true;
+                continue;
+            }
+            const now = this.clock.now();
+            await this.domain.claimDue(now);
+            const claimed = await this.domain.takeNextQueued(this.clock.now());
+            if (claimed !== undefined) {
+                const active = {
+                    taskId: claimed.task.id,
+                    runId: claimed.run.id,
+                    cancelReason: undefined,
+                    cancelTimeout: undefined,
+                };
+                this.activeRun = active;
+                active.cancelTimeout = this.clock.setTimeout(() => {
+                    active.cancelTimeout = undefined;
+                    if (this.activeRun === active)
+                        this.cancelActiveRun('timeout');
+                }, Math.min(this.maxRunDurationMs, MAX_TIMER_DELAY_MS));
+                let outcome;
+                try {
+                    const result = await this.runner.run(claimed.task, claimed.run);
+                    outcome = {
+                        status: result.status,
+                        sessionId: result.sessionId,
+                        ...(result.summary === undefined ? {} : { summary: result.summary }),
+                        ...(result.output === undefined ? {} : { output: result.output }),
+                        ...(result.error === undefined ? {} : { error: result.error }),
+                    };
+                }
+                catch (error) {
+                    outcome = {
+                        status: 'failed',
+                        error: error instanceof Error ? error.message : String(error),
+                    };
+                }
+                finally {
+                    active.cancelTimeout?.();
+                    active.cancelTimeout = undefined;
+                }
+                const resultData = {
+                    ...(outcome.sessionId === undefined ? {} : { sessionId: outcome.sessionId }),
+                    ...(outcome.summary === undefined ? {} : { summary: outcome.summary }),
+                    ...(outcome.output === undefined ? {} : { output: outcome.output }),
+                };
+                if (active.cancelReason === 'timeout') {
+                    outcome = { status: 'timed_out', error: `Automation exceeded its ${this.maxRunDurationMs}ms run limit.`, ...resultData };
+                }
+                else if (active.cancelReason === 'manual') {
+                    outcome = { status: 'canceled', error: 'Automation run was stopped by the user.', ...resultData };
+                }
+                else if (active.cancelReason === 'shutdown') {
+                    outcome = { status: 'interrupted', error: 'DSH stopped while this automation run was active.', ...resultData };
+                }
+                if (this.activeRun === active)
+                    this.activeRun = undefined;
+                this.pendingFinish = { task: claimed.task, run: claimed.run, outcome, executionSaved: false };
+                await this.finishPendingRun(this.clock.now());
+                this.requested = true;
+                continue;
+            }
+            const target = this.domain.nextWakeAt(this.clock.now());
+            if (target !== undefined)
+                this.arm(target);
+        }
+    }
+}
+//# sourceMappingURL=scheduler.js.map

package/lib/store.d.ts

@@ -0,0 +1,14 @@
+import { type AutomationState } from './types.js';
+export type AtomicWriter = (path: string, content: string) => Promise<void>;
+export declare function writeJsonAtomic(path: string, content: string): Promise<void>;
+export declare class AutomationStore {
+    readonly path: string;
+    private readonly writer;
+    private state;
+    private tail;
+    constructor(path: string, writer?: AtomicWriter);
+    init(): Promise<void>;
+    snapshot(): AutomationState;
+    mutate<T>(operation: (draft: AutomationState) => T | Promise<T>): Promise<T>;
+}
+//# sourceMappingURL=store.d.ts.map

package/lib/store.js

@@ -0,0 +1,108 @@
+import { mkdir, open, readFile, rename, rm } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { AutomationStateSchema, emptyAutomationState } from './types.js';
+export async function writeJsonAtomic(path, content) {
+    const directory = dirname(path);
+    await mkdir(directory, { recursive: true });
+    const temporary = join(directory, `.${basename(path)}.${randomUUID()}.tmp`);
+    let handle;
+    try {
+        handle = await open(temporary, 'wx', 0o600);
+        await handle.writeFile(content, 'utf8');
+        await handle.sync();
+        await handle.close();
+        handle = undefined;
+        await rename(temporary, path);
+        // Windows cannot fsync a read-only directory handle. File contents above
+        // are still synced before the atomic rename on every platform.
+        if (process.platform !== 'win32') {
+            try {
+                const directoryHandle = await open(directory, 'r');
+                try {
+                    await directoryHandle.sync();
+                }
+                finally {
+                    await directoryHandle.close();
+                }
+            }
+            catch (error) {
+                // Rename committed the new state. Rejecting now would leave the store's
+                // memory stale and allow a later mutation to overwrite that commit.
+                process.emitWarning(`Automation state was committed to ${path}, but directory sync failed; crash durability is not guaranteed.`, {
+                    code: 'AUTOMATION_DIRECTORY_SYNC_FAILED',
+                    detail: error instanceof Error ? error.stack ?? error.message : String(error),
+                });
+            }
+        }
+    }
+    finally {
+        if (handle !== undefined)
+            await handle.close().catch(() => undefined);
+        await rm(temporary, { force: true }).catch(() => undefined);
+    }
+}
+export class AutomationStore {
+    path;
+    writer;
+    state;
+    tail = Promise.resolve();
+    constructor(path, writer = writeJsonAtomic) {
+        this.path = path;
+        this.writer = writer;
+    }
+    async init() {
+        if (this.state !== undefined)
+            return;
+        let raw;
+        try {
+            raw = await readFile(this.path, 'utf8');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+            this.state = emptyAutomationState();
+            return;
+        }
+        let value;
+        try {
+            value = JSON.parse(raw);
+        }
+        catch (error) {
+            throw new Error(`Automation state is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const parsed = AutomationStateSchema.safeParse(value);
+        if (!parsed.success)
+            throw new Error(`Automation state is invalid: ${parsed.error.message}`);
+        this.state = normalizeState(parsed.data);
+    }
+    snapshot() {
+        if (this.state === undefined)
+            throw new Error('AutomationStore.init() must complete before use.');
+        return structuredClone(this.state);
+    }
+    mutate(operation) {
+        const run = this.tail.then(async () => {
+            if (this.state === undefined)
+                throw new Error('AutomationStore.init() must complete before use.');
+            const draft = structuredClone(this.state);
+            const result = await operation(draft);
+            draft.revision = this.state.revision + 1;
+            const validated = AutomationStateSchema.parse(draft);
+            await this.writer(this.path, `${JSON.stringify(validated, null, 2)}\n`);
+            this.state = validated;
+            return result;
+        });
+        this.tail = run.then(() => undefined, () => undefined);
+        return run;
+    }
+}
+function normalizeState(state) {
+    for (const task of Object.values(state.tasks)) {
+        task.execution.target ??= { mode: 'fresh' };
+        for (const run of task.runs)
+            run.executionTarget ??= { mode: 'fresh' };
+    }
+    return state;
+}
+//# sourceMappingURL=store.js.map

package/lib/tool-configuration.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { AutomationController } from './controller.js';
+import type { AgentConfiguration } from './agent-configuration.js';
+import '@deepseek-ai/dsh-agent-preset-registry';
+import '@deepseek-ai/dsh-workspace';
+export declare function registerConfigurationTools(rootCtx: Context, toolCtx: Context, agent: Agent, controller: AutomationController, agentConfiguration: AgentConfiguration): Array<() => void>;
+//# sourceMappingURL=tool-configuration.d.ts.map