@hhuangpanda/dsh-automation 0.0.0-stage → 0.3.34

package/lib/controller.d.ts

@@ -0,0 +1,36 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type AutomationDomain } from './domain.js';
+import type { AutomationScheduler } from './scheduler.js';
+import type { AgentConfiguration } from './agent-configuration.js';
+import type { AutomationDelivery, AutomationDeliveryOptions, AutomationRun, AutomationSchedulerHealth, AutomationTask, AutomationTaskView, CreateAutomationRequest, ResumeOptions, UpdateAutomationRequest } from './types.js';
+export declare function validatePersistedSessionTarget(ctx: Context, task: AutomationTask, sessionId: string): Promise<void>;
+export declare class AutomationController {
+    readonly domain: AutomationDomain;
+    readonly scheduler: AutomationScheduler;
+    private readonly now;
+    private readonly agentConfiguration?;
+    private readonly validateSessionTarget?;
+    private readonly delivery?;
+    constructor(domain: AutomationDomain, scheduler: AutomationScheduler, now?: () => number, agentConfiguration?: AgentConfiguration | undefined, validateSessionTarget?: ((task: AutomationTask, sessionId: string) => Promise<void>) | undefined, delivery?: {
+        options(botId?: string): Promise<AutomationDeliveryOptions>;
+        validate(destination: AutomationDelivery): Promise<void>;
+    } | undefined);
+    deliveryOptions(botId?: string): Promise<AutomationDeliveryOptions>;
+    list(): AutomationTaskView[];
+    get(id: string): AutomationTask;
+    schedulerHealth(): AutomationSchedulerHealth;
+    create(request: CreateAutomationRequest): Promise<AutomationTask>;
+    update(id: string, request: UpdateAutomationRequest): Promise<AutomationTask>;
+    options(id: string, agentPreset?: string | null, provider?: string, model?: string): Promise<import("./types.js").AgentConfigurationOptions>;
+    delete(id: string): Promise<boolean>;
+    deleteRun(taskId: string, runId: string): Promise<boolean>;
+    markNotificationsRead(): Promise<void>;
+    pause(id: string): Promise<AutomationTask>;
+    resume(id: string, options: ResumeOptions): Promise<AutomationTask>;
+    runNow(id: string): Promise<AutomationRun>;
+    stop(id: string): Promise<{
+        runId: string;
+        status: 'canceling' | 'canceled';
+    }>;
+}
+//# sourceMappingURL=controller.d.ts.map

package/lib/controller.js

@@ -0,0 +1,154 @@
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { WorkspaceId } from '@deepseek-ai/dsh-workspace';
+import { AutomationError } from './errors.js';
+import { applyExecutionPatch, normalizeSkills } from './validation.js';
+import { AutomationDomainError } from './domain.js';
+export async function validatePersistedSessionTarget(ctx, task, sessionId) {
+    const persistence = ctx.get('sessionPersistence');
+    if (persistence === undefined)
+        throw new AutomationError('target_session_unavailable', 'persisted session inspection is unavailable.');
+    const id = SessionId(sessionId);
+    const snapshot = await persistence.stat(id);
+    if (snapshot === undefined || snapshot.header.id !== id)
+        throw new AutomationError('target_session_not_found', 'target session could not be resolved.');
+    if (snapshot.header.cwd !== task.execution.cwd)
+        throw new AutomationError('target_workspace_mismatch', 'target session cwd does not match the task.');
+    const registry = ctx.get('workspaceRegistry');
+    const workspace = registry?.get(WorkspaceId(task.execution.workspaceId));
+    if (workspace === undefined || workspace.path !== task.execution.cwd || !workspace.sessionIds.includes(id)) {
+        throw new AutomationError('target_workspace_mismatch', 'target session must belong to the task workspace.');
+    }
+    if (snapshot.header.origin === 'subagent' || registry?.archivedSessionIds.includes(id)) {
+        throw new AutomationError('target_session_unavailable', 'select a visible ordinary session.');
+    }
+}
+export class AutomationController {
+    domain;
+    scheduler;
+    now;
+    agentConfiguration;
+    validateSessionTarget;
+    delivery;
+    constructor(domain, scheduler, now = () => Date.now(), agentConfiguration, validateSessionTarget, delivery) {
+        this.domain = domain;
+        this.scheduler = scheduler;
+        this.now = now;
+        this.agentConfiguration = agentConfiguration;
+        this.validateSessionTarget = validateSessionTarget;
+        this.delivery = delivery;
+    }
+    async deliveryOptions(botId) {
+        return this.delivery?.options(botId) ?? { available: false, bots: [], targets: [] };
+    }
+    list() {
+        return this.domain.list().map((task) => {
+            const permissionDisplayName = this.agentConfiguration?.permissionName(task.security.permissionPreset);
+            return permissionDisplayName === undefined ? task : { ...task, permissionDisplayName };
+        });
+    }
+    get(id) {
+        return this.domain.get(id);
+    }
+    schedulerHealth() {
+        return this.scheduler.health();
+    }
+    async create(request) {
+        const execution = normalizedExecution(request.execution);
+        await this.agentConfiguration?.validate(execution.target?.mode === 'pinned-session'
+            ? { ...execution, agentPreset: undefined, provider: undefined, model: undefined, reasoningEffort: undefined, skills: [] }
+            : execution, request.permissionPreset);
+        const task = await this.domain.create(request, this.now());
+        this.scheduler.requestDrive();
+        return task;
+    }
+    async update(id, request) {
+        const agentConfiguration = this.agentConfiguration;
+        const beforeCommit = async (current) => {
+            if (request.delivery != null && (request.delivery.botId !== current.delivery?.botId || request.delivery.targetId !== current.delivery?.targetId)) {
+                if (this.delivery === undefined)
+                    throw new Error('dsh-im direct delivery is unavailable on this Host.');
+                await this.delivery.validate(request.delivery);
+            }
+            if (request.execution?.target?.mode === 'pinned-session') {
+                if (this.validateSessionTarget === undefined)
+                    throw new Error('target_session_unavailable: persisted session validation is unavailable.');
+                await this.validateSessionTarget(current, request.execution.target.sessionId);
+            }
+            if (request.permissionPreset !== undefined && request.permissionPreset !== current.security.permissionPreset && request.permissionChangeConfirmed !== true) {
+                throw new Error('Explicit user confirmation is required to change permissions.');
+            }
+            const execution = applyExecutionPatch(current.execution, request.execution);
+            const preservesLegacyPartialModel = request.execution?.provider === undefined
+                && request.execution?.model === undefined
+                && ((current.execution.provider === undefined) !== (current.execution.model === undefined));
+            await agentConfiguration?.validate(execution.target?.mode === 'pinned-session'
+                ? { ...execution, agentPreset: undefined, provider: undefined, model: undefined, reasoningEffort: undefined, skills: [] }
+                : execution, request.permissionPreset ?? current.security.permissionPreset, { allowLegacyPartialModel: preservesLegacyPartialModel });
+        };
+        const task = await this.domain.update(id, request, this.now(), beforeCommit);
+        this.scheduler.requestDrive();
+        return task;
+    }
+    async options(id, agentPreset, provider, model) {
+        if (this.agentConfiguration === undefined)
+            throw new Error('Agent configuration is unavailable.');
+        const task = this.domain.get(id);
+        const savedModel = provider === undefined && model === undefined && task.execution.target?.mode !== 'pinned-session'
+            && task.execution.provider !== undefined && task.execution.model !== undefined;
+        return this.agentConfiguration.options(task.execution.cwd, agentPreset === undefined ? task.execution.agentPreset : agentPreset ?? undefined, savedModel ? task.execution.provider : provider, savedModel ? task.execution.model : model);
+    }
+    async delete(id) {
+        const deleted = await this.domain.delete(id);
+        if (deleted)
+            this.scheduler.requestDrive();
+        return deleted;
+    }
+    async deleteRun(taskId, runId) {
+        return this.domain.deleteRun(taskId, runId);
+    }
+    async markNotificationsRead() {
+        await this.domain.markNotificationsRead();
+    }
+    async pause(id) {
+        const task = await this.domain.pause(id, this.now());
+        this.scheduler.requestDrive();
+        return task;
+    }
+    async resume(id, options) {
+        const task = await this.domain.resume(id, options, this.now());
+        this.scheduler.requestDrive();
+        return task;
+    }
+    async runNow(id) {
+        const run = await this.domain.runNow(id, this.now());
+        this.scheduler.requestDrive();
+        return run;
+    }
+    async stop(id) {
+        const task = this.domain.get(id);
+        const run = task.runs.find((entry) => entry.status === 'queued' || entry.status === 'running');
+        if (run === undefined) {
+            throw new AutomationDomainError('invalid_state', `Automation ${id} has no queued or running run.`);
+        }
+        if (run.status === 'queued') {
+            await this.domain.cancelQueuedRun(id, run.id, this.now());
+            this.scheduler.requestDrive();
+            return { runId: run.id, status: 'canceled' };
+        }
+        if (!this.scheduler.cancelRun(id, run.id)) {
+            throw new AutomationDomainError('invalid_state', `Automation ${id} is no longer cancelable.`);
+        }
+        return { runId: run.id, status: 'canceling' };
+    }
+}
+function normalizedExecution(execution) {
+    return {
+        ...execution,
+        target: execution.target ?? { mode: 'fresh' },
+        ...(execution.agentPreset === undefined ? {} : { agentPreset: execution.agentPreset.trim() }),
+        ...(execution.provider === undefined ? {} : { provider: execution.provider.trim() }),
+        ...(execution.model === undefined ? {} : { model: execution.model.trim() }),
+        skills: normalizeSkills(execution.skills),
+    };
+}
+//# sourceMappingURL=controller.js.map

package/lib/domain.d.ts

@@ -0,0 +1,44 @@
+import { AutomationStore } from './store.js';
+import { type AutomationDelivery, type AutomationRunDelivery } from './types.js';
+import { AutomationError } from './errors.js';
+import type { AutomationRun, AutomationTask, AutomationTaskView, CreateAutomationRequest, ResumeOptions, UpdateAutomationRequest } from './types.js';
+export declare class AutomationDomainError extends AutomationError {
+    readonly code: 'task_not_found' | 'invalid_state' | 'run_in_progress' | 'schedule_exhausted';
+    constructor(code: 'task_not_found' | 'invalid_state' | 'run_in_progress' | 'schedule_exhausted', message: string);
+}
+export interface ClaimedRun {
+    readonly task: AutomationTask;
+    readonly run: AutomationRun;
+}
+export interface RunOutcome {
+    readonly status: 'succeeded' | 'failed' | 'interrupted' | 'timed_out' | 'canceled';
+    readonly sessionId?: string;
+    readonly summary?: string;
+    /** Full own-turn text for delivery only; never persisted in the run record. */
+    readonly output?: string;
+    readonly error?: string;
+}
+export declare class AutomationDomain {
+    readonly store: AutomationStore;
+    readonly maxRunHistory: number;
+    constructor(store: AutomationStore, maxRunHistory?: number);
+    init(now: number): Promise<void>;
+    list(): AutomationTaskView[];
+    get(id: string): AutomationTask;
+    create(request: CreateAutomationRequest, now: number): Promise<AutomationTask>;
+    update(id: string, request: UpdateAutomationRequest, now: number, beforeCommit?: (current: AutomationTask) => Promise<void>): Promise<AutomationTask>;
+    delete(id: string): Promise<boolean>;
+    deleteRun(taskId: string, runId: string): Promise<boolean>;
+    markNotificationsRead(): Promise<void>;
+    pause(id: string, now: number): Promise<AutomationTask>;
+    resume(id: string, options: ResumeOptions, now: number): Promise<AutomationTask>;
+    runNow(id: string, now: number): Promise<AutomationRun>;
+    cancelQueuedRun(id: string, runId: string, now: number): Promise<AutomationRun>;
+    claimDue(now: number): Promise<AutomationRun[]>;
+    nextWakeAt(now: number): number | undefined;
+    takeNextQueued(now: number): Promise<ClaimedRun | undefined>;
+    finishRun(taskId: string, runId: string, outcome: RunOutcome, now: number, delivery?: AutomationDelivery): Promise<void>;
+    /** Delivery settlement never changes execution status or failure counters. */
+    finishDelivery(taskId: string, runId: string, delivery: AutomationRunDelivery): Promise<void>;
+}
+//# sourceMappingURL=domain.d.ts.map