@michengai/dsh-automation 0.1.0

package/lib/types/client/protocol.d.ts

@@ -0,0 +1,153 @@
+/** Web 客户端与 Host RPC 共享的 JSON 契约。 */
+export type AutomationStatus = 'active' | 'paused';
+export type AutomationRunStatus = 'queued' | 'running' | 'succeeded' | 'failed' | 'skipped' | 'cancelled' | 'interrupted';
+export type AutomationPermission = 'read-only' | 'workspace-write' | 'full-access';
+export type AutomationSchedule = {
+    readonly kind: 'once';
+    readonly at: string;
+    readonly timeZone?: string;
+} | {
+    readonly kind: 'interval';
+    readonly everyMinutes: number;
+    readonly anchor?: string;
+    readonly timeZone?: string;
+} | {
+    readonly kind: 'daily';
+    readonly time: string;
+    readonly timeZone?: string;
+} | {
+    readonly kind: 'weekly';
+    readonly time: string;
+    readonly weekdays: readonly number[];
+    readonly timeZone?: string;
+} | {
+    readonly kind: 'hourly';
+    readonly minute: number;
+    readonly timeZone?: string;
+} | {
+    readonly kind: 'monthly';
+    readonly day: number;
+    readonly time: string;
+    readonly timeZone?: string;
+} | {
+    readonly kind: 'custom';
+    readonly everyDays: number;
+    readonly time: string;
+    readonly timeZone?: string;
+};
+export interface WorkspaceOption {
+    readonly id: string;
+    readonly title: string;
+    readonly path: string;
+}
+export interface ModelOption {
+    readonly provider: string;
+    readonly model: string;
+    readonly label: string;
+}
+export interface AutomationViewModel {
+    readonly id: string;
+    readonly revision: number;
+    readonly name: string;
+    readonly prompt: string;
+    readonly status: AutomationStatus;
+    readonly schedule: AutomationSchedule;
+    readonly scheduleSummary: string;
+    readonly timeZone: string;
+    readonly permission: AutomationPermission;
+    readonly workspaceId?: string;
+    readonly cwd?: string;
+    readonly provider?: string | null;
+    readonly model?: string | null;
+    readonly reasoningEffort?: string | null | undefined;
+    readonly nextRunAt?: string;
+    readonly lastRunAt?: string;
+    readonly lastRunStatus?: AutomationRunStatus;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export interface AutomationRunViewModel {
+    readonly id: string;
+    readonly automationId: string;
+    readonly automationName: string;
+    readonly status: AutomationRunStatus;
+    readonly trigger: 'schedule' | 'manual' | 'catch-up';
+    readonly scheduledFor: string;
+    readonly startedAt?: string;
+    readonly finishedAt?: string;
+    readonly sessionId?: string;
+    readonly summary?: string;
+    readonly error?: string;
+    readonly unread?: boolean;
+}
+export interface AutomationSnapshot {
+    readonly scope: {
+        readonly workspaceId?: string;
+        readonly workspaceName?: string;
+        readonly cwd: string;
+    };
+    readonly workspaces?: readonly WorkspaceOption[];
+    readonly models?: readonly ModelOption[];
+    readonly defaultModel?: ModelOption | null;
+    readonly skills?: readonly {
+        readonly id: string;
+        readonly name: string;
+    }[];
+    readonly automations: readonly AutomationViewModel[];
+    readonly runs: readonly AutomationRunViewModel[];
+    readonly serverNow: string;
+}
+export interface CreateAutomationInput {
+    readonly name: string;
+    readonly prompt: string;
+    readonly schedule: AutomationSchedule;
+    readonly timeZone: string;
+    readonly permission: AutomationPermission;
+    readonly workspaceId: string;
+    readonly cwd: string;
+    readonly provider?: string | null;
+    readonly model?: string | null;
+    readonly reasoningEffort?: string | null | undefined;
+}
+export interface SnapshotRequest {
+    readonly sessionId?: string;
+}
+export interface CreateRequest {
+    readonly sessionId?: string;
+    readonly input: CreateAutomationInput;
+}
+export interface MutateRequest {
+    readonly sessionId?: string;
+    readonly automationId: string;
+    readonly mutation: 'pause' | 'resume' | 'delete';
+}
+export interface UpdateRequest {
+    readonly sessionId?: string;
+    readonly automationId: string;
+    readonly input: CreateAutomationInput;
+}
+export interface RunNowRequest {
+    readonly sessionId?: string;
+    readonly automationId: string;
+}
+export interface MarkReadRequest {
+    readonly sessionId?: string;
+    readonly runId: string;
+}
+export interface AddWorkspaceRequest {
+    readonly sessionId?: string;
+    readonly path: string;
+}
+export interface RpcErrorValue {
+    readonly code: string;
+    readonly message: string;
+    readonly details?: unknown;
+}
+export type RpcResult<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: RpcErrorValue;
+};
+export declare function unwrapRpcResult<T>(value: unknown): T;

package/lib/types/client/runtime.d.ts

@@ -0,0 +1,29 @@
+import type { ClientRpc } from './contracts.js';
+import type { AutomationSnapshot, CreateAutomationInput, MutateRequest } from './protocol.js';
+export declare function isTransportError(error: unknown): boolean;
+export interface AutomationClientState {
+    readonly phase: 'idle' | 'loading' | 'ready' | 'error';
+    readonly snapshot?: AutomationSnapshot;
+    readonly error?: string;
+    readonly refreshedAt?: number;
+}
+export interface AutomationStateSource {
+    getSnapshot(): AutomationClientState;
+    subscribe(listener: () => void): () => void;
+}
+export interface AutomationRuntime {
+    readonly source: AutomationStateSource;
+    refresh(): Promise<void>;
+    createAutomation(input: CreateAutomationInput): Promise<void>;
+    mutateAutomation(automationId: string, mutation: MutateRequest['mutation']): Promise<void>;
+    updateAutomation(automationId: string, input: CreateAutomationInput): Promise<void>;
+    runNow(automationId: string): Promise<void>;
+    markRunRead(runId: string): Promise<void>;
+    addWorkspace(path: string): Promise<{
+        id: string;
+    }>;
+    adoptSession(sessionId: string): Promise<void>;
+    forgetSession(sessionId: string): Promise<void>;
+    forgetAutomationSessions(automationId: string): Promise<void>;
+}
+export declare function createAutomationRuntime(rpc: ClientRpc): AutomationRuntime;

package/lib/types/client/schedule-rail-model.d.ts

@@ -0,0 +1,87 @@
+/** 侧栏定时树与原生任务列表的纯函数，供组件和单测共用。 */
+export declare const AUTOMATION_SESSION_PREFIX = "dsh-automation-session-";
+export declare const NATIVE_SIDEBAR_TAB_KEY = "dsh-automation.sidebar-tab";
+export interface ScheduleRailSession {
+    readonly id: string;
+    readonly running: boolean;
+    readonly label: string;
+}
+export interface ScheduleRailGroup {
+    readonly id: string;
+    readonly name: string;
+    readonly sessions: readonly ScheduleRailSession[];
+}
+export interface ScheduleRunLike {
+    readonly automationId: string;
+    readonly automationName?: string;
+    readonly sessionId?: string;
+    readonly status: string;
+    readonly startedAt?: string;
+    readonly scheduledFor: string;
+}
+export interface NativeSessionLike {
+    readonly id?: string;
+    readonly title?: string;
+    readonly blank?: boolean;
+    readonly origin?: string;
+    readonly updatedAt?: number | string;
+    readonly running?: boolean;
+}
+export interface NativeWorkspaceLike {
+    readonly id?: string;
+    readonly workspaceId?: string;
+    readonly title?: string;
+    readonly path?: string;
+    readonly sessionIds?: readonly string[];
+}
+export type NativeSidebarTab = 'tasks' | 'channels' | 'schedule';
+export { formatRunStamp } from '../run-title.js';
+/** 定时会话标题复刻任务树：优先用 Session 真实标题，没有再用执行时间兜底。 */
+export declare function scheduledSessionTitle(liveTitle: string | undefined, fallbackLabel: string): string;
+export declare function sessionUpdatedAtIso(value: number | string | undefined, fallback: string): string;
+export declare function groupScheduledSessions(automations: readonly {
+    readonly id: string;
+    readonly name: string;
+}[], runs: readonly ScheduleRunLike[]): ScheduleRailGroup[];
+export declare function isNativeTaskSession(item: NativeSessionLike | undefined): boolean;
+export declare function groupNativeTaskSessions(sessions: {
+    readonly ids?: readonly string[];
+    readonly byId?: Record<string, NativeSessionLike>;
+}, workspaces: {
+    readonly items?: readonly NativeWorkspaceLike[];
+    readonly archivedSessionIds?: readonly string[];
+} | undefined, ungroupedLabel: string): {
+    readonly id: string;
+    readonly label: string;
+    readonly sessions: readonly NativeSessionLike[];
+}[];
+export declare function readNativeSidebarTab(raw: string | null): NativeSidebarTab;
+export declare function tabForSessionId(sessionId: string | null | undefined): NativeSidebarTab | undefined;
+export declare function occupantLooksLikeCodexUi(value: unknown): boolean;
+export declare function slotOccupantName(item: unknown): string;
+export declare function hasCodexUiSidebar(entries: readonly unknown[] | undefined): boolean;
+export interface SessionListState {
+    readonly ids?: readonly string[];
+    readonly byId?: Record<string, NativeSessionLike>;
+    readonly current?: string | null;
+}
+export declare function filterTaskSessionState<T extends SessionListState>(state: T | undefined): T;
+export interface WorkspaceListState {
+    readonly items?: readonly NativeWorkspaceLike[];
+    readonly archivedSessionIds?: readonly string[];
+}
+export declare function openScheduledSession(id: string, openRuntime?: (sessionId: string) => void, openHost?: (sessionId: string) => void): void;
+export declare function isHiddenSidebarSessionId(id: string): boolean;
+export declare function filterWorkspaceListState<T extends WorkspaceListState>(state: T | undefined): T;
+export type WrapperFlags = {
+    __dshAutomationWrapped?: unknown;
+    __dshAutomationOriginal?: unknown;
+    __imConnectWrapped?: unknown;
+    __imConnectOriginal?: unknown;
+};
+export declare function wrapperFlags(component: unknown): WrapperFlags;
+export declare function isOwnAutomationWrapper(component: unknown): boolean;
+export declare function isMarkedWorkspaceWrapper(component: unknown): boolean;
+export declare function resolveOfficialTreeComponent(component: unknown): unknown;
+export declare function isAutomationWorkspaceWrapper(item: unknown): boolean;
+export declare function pickWrappableWorkspacesEntry(entries: readonly unknown[]): unknown;

package/lib/types/client/styles.d.ts

@@ -0,0 +1 @@
+export declare function installStyles(): () => void;

package/lib/types/domain.d.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import type { AutomationDefinition, AutomationRun, AutomationSchedule, CreateAutomationInput, DeleteAutomationPlan, UpdateAutomationInput } from './types.ts';
+export declare const automationScheduleSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"once">;
+    at: z.ZodString;
+    timeZone: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"interval">;
+    everyMinutes: z.ZodNumber;
+    anchor: z.ZodString;
+    timeZone: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"daily">;
+    time: z.ZodString;
+    timeZone: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"weekly">;
+    weekdays: z.ZodArray<z.ZodEnum<{
+        MO: "MO";
+        TU: "TU";
+        WE: "WE";
+        TH: "TH";
+        FR: "FR";
+        SA: "SA";
+        SU: "SU";
+    }>>;
+    time: z.ZodString;
+    timeZone: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"hourly">;
+    minute: z.ZodNumber;
+    timeZone: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"monthly">;
+    day: z.ZodNumber;
+    time: z.ZodString;
+    timeZone: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"custom">;
+    everyDays: z.ZodNumber;
+    time: z.ZodString;
+    timeZone: z.ZodString;
+}, z.core.$strip>], "kind">;
+export declare const automationDefinitionSchema: z.ZodType<AutomationDefinition>;
+export declare const automationRunSchema: z.ZodType<AutomationRun>;
+export declare const automationDomainSpec: {
+    readonly name: "dsh_automation";
+    readonly version: 1;
+    readonly tables: {
+        readonly definitions: {
+            readonly valueSchema: z.ZodType<AutomationDefinition, unknown, z.core.$ZodTypeInternals<AutomationDefinition, unknown>>;
+        };
+        readonly runs: {
+            readonly valueSchema: z.ZodType<AutomationRun, unknown, z.core.$ZodTypeInternals<AutomationRun, unknown>>;
+        };
+    };
+};
+export declare function createDefinition(input: CreateAutomationInput): AutomationDefinition;
+export declare function updateDefinition(current: AutomationDefinition, input: UpdateAutomationInput): AutomationDefinition;
+export declare function pauseDefinition(current: AutomationDefinition, now: string): AutomationDefinition;
+export declare function resumeDefinition(current: AutomationDefinition, now: string): AutomationDefinition;
+export declare function deleteDefinition(current: AutomationDefinition): DeleteAutomationPlan;
+export declare function occurrenceKey(automationId: string, definitionRevision: number, scheduledFor: string): string;
+export declare function runIdForOccurrence(key: string): string;
+export declare function createScheduledRun(definition: AutomationDefinition, scheduledFor: string): AutomationRun;
+export declare function createManualRun(definition: AutomationDefinition, scheduledFor: string, nonce?: string): AutomationRun;
+export type { AutomationSchedule };

package/lib/types/executor.d.ts

@@ -0,0 +1,30 @@
+/** 已认领 run 的独立 Agent 执行边界。 */
+import type { Context } from '@deepseek-ai/cordis';
+import type { AutomationDefinition, AutomationRun } from './types.ts';
+interface SessionEventLike {
+    readonly seq: number;
+    readonly type: string;
+    readonly data: Record<string, any>;
+}
+export declare function unattendedToolGuardReason(name: string, args: unknown): string | undefined;
+export interface RunCompletion {
+    readonly sessionId?: string;
+    readonly status: 'succeeded' | 'failed' | 'cancelled';
+    readonly summary?: string;
+    readonly error?: {
+        readonly code: string;
+        readonly message: string;
+    };
+}
+export interface ExecutorConfig {
+    readonly runTimeoutMs: number;
+    readonly sessionId: string;
+    readonly signal?: AbortSignal;
+}
+export declare function summarizeRun(events: readonly SessionEventLike[], firstSeq: number): {
+    readonly text: string;
+    readonly reason?: Record<string, any>;
+};
+export declare function executeAutomationRun(ctx: Context, definition: AutomationDefinition, run: AutomationRun, config: ExecutorConfig): Promise<RunCompletion>;
+export declare function pinAutomationSessionTitle(ctx: Context, session: unknown, title: string): void;
+export {};

package/lib/types/index.d.ts

@@ -0,0 +1,20 @@
+/** 独立自动化的 Cordis Host 插件入口。 */
+import type { Context } from '@deepseek-ai/cordis';
+export declare const name = "dsh-automation";
+export declare const inject: string[];
+export interface Config {
+    readonly maxConcurrentRuns?: number;
+    readonly runTimeoutMinutes?: number;
+    readonly misfireGraceMinutes?: number;
+    readonly historyLimit?: number;
+}
+export declare const Config: any;
+export declare function needsHumanApproval(exec: {
+    readonly name: string;
+    readonly arguments?: unknown;
+    readonly signal: AbortSignal;
+}, isMountedAgent: boolean): boolean;
+export declare function humanApprovalReason(toolName: string): string;
+export declare function apply(ctx: Context, rawConfig: Config): Promise<void>;
+export type * from './types.ts';
+export { automationDomainSpec } from './domain.ts';

package/lib/types/recurrence.d.ts

@@ -0,0 +1,7 @@
+import type { AutomationSchedule } from './types.ts';
+export declare function assertValidSchedule(schedule: AutomationSchedule): void;
+export declare function normalizeSchedule(schedule: AutomationSchedule): AutomationSchedule;
+export declare function scheduleToRRule(schedule: AutomationSchedule): string;
+export declare function nextOccurrence(schedule: AutomationSchedule, afterExclusive: string): string | null;
+export declare function latestDueOccurrence(schedule: AutomationSchedule, now: string): string | null;
+export declare function occurrencesBetween(schedule: AutomationSchedule, afterExclusive: string, untilInclusive: string, limit?: number): string[];

package/lib/types/rpc.d.ts

@@ -0,0 +1,13 @@
+/** 仅 loopback 的 Web 客户端 RPC 适配器。 */
+import type { AutomationService } from './service.ts';
+interface RpcContext {
+    readonly connection: {
+        readonly rpc: {
+            handle(channel: string, handler: (endpoint: string, payload: unknown, signal: AbortSignal) => Promise<unknown>, options: {
+                readonly authority: 'loopback' | 'trusted-host';
+            }): () => Promise<void>;
+        };
+    };
+}
+export declare function registerAutomationRpc(ctx: RpcContext, service: AutomationService): () => Promise<void>;
+export {};

package/lib/types/run-title.d.ts

@@ -0,0 +1,3 @@
+/** 定时执行 Session 的展示标题，Host 与侧栏共用。 */
+export declare function formatRunStamp(iso: string): string;
+export declare function automationSessionTitle(taskName: string, iso: string): string;

package/lib/types/service.d.ts

@@ -0,0 +1,110 @@
+/** 持久化定义、occurrence 认领、时钟与执行调度。 */
+import type { Context } from '@deepseek-ai/cordis';
+import type { AutomationDefinition, AutomationRun, AutomationSchedule, PermissionPreset, UpdateAutomationInput } from './types.ts';
+export declare const AUTOMATION_SESSION_PREFIX = "dsh-automation-session-";
+export interface AutomationConfig {
+    readonly maxConcurrentRuns: number;
+    readonly runTimeoutMs: number;
+    readonly misfireGraceMs: number;
+    readonly historyLimit: number;
+}
+export interface WorkspaceOption {
+    readonly id: string;
+    readonly title: string;
+    readonly path: string;
+}
+export interface ModelOption {
+    readonly provider: string;
+    readonly model: string;
+    readonly label: string;
+}
+export interface CreateRequest {
+    readonly name: string;
+    readonly prompt: string;
+    readonly schedule: AutomationSchedule;
+    readonly permissionPreset?: PermissionPreset;
+    readonly workspaceId?: string;
+    readonly cwd?: string;
+    readonly provider?: string | null;
+    readonly model?: string | null;
+    readonly reasoningEffort?: string | null;
+    readonly agentPreset?: string;
+}
+export interface AutomationScope {
+    readonly sessionId: string;
+    readonly creatorKind: 'agent' | 'web';
+    readonly hostWide?: boolean;
+}
+export interface AutomationSnapshot {
+    readonly generatedAt: string;
+    readonly workspace: WorkspaceOption | null;
+    readonly workspaces: readonly WorkspaceOption[];
+    readonly models: readonly ModelOption[];
+    readonly defaultModel: ModelOption | null;
+    readonly skills: readonly {
+        readonly id: string;
+        readonly name: string;
+    }[];
+    readonly definitions: readonly AutomationDefinitionView[];
+    readonly runs: readonly AutomationRun[];
+}
+export interface AutomationDefinitionView extends AutomationDefinition {
+    readonly nextRunAt: string | null;
+    readonly lastRun: AutomationRun | null;
+}
+interface SessionEventLike {
+    readonly type: string;
+    readonly data: unknown;
+}
+export declare class AutomationService {
+    private readonly ctx;
+    private readonly domain;
+    private readonly config;
+    private definitions;
+    private runs;
+    private timer;
+    private operationTail;
+    private pumpScheduled;
+    private requested;
+    private started;
+    private stopping;
+    private readonly active;
+    private constructor();
+    static open(ctx: Context, config: AutomationConfig): Promise<AutomationService>;
+    start(): void;
+    ownsSession(sessionId: string, events?: readonly SessionEventLike[]): boolean;
+    dispose(): Promise<void>;
+    snapshot(scope: AutomationScope, signal?: AbortSignal): Promise<AutomationSnapshot>;
+    create(scope: AutomationScope, request: CreateRequest, signal?: AbortSignal): Promise<AutomationDefinition>;
+    update(scope: AutomationScope, id: string, input: Omit<UpdateAutomationInput, 'now'> & {
+        readonly status?: 'active' | 'paused';
+    }, signal?: AbortSignal): Promise<AutomationDefinition>;
+    delete(scope: AutomationScope, id: string, signal?: AbortSignal): Promise<{
+        readonly id: string;
+        readonly deleted: boolean;
+    }>;
+    runNow(scope: AutomationScope, id: string, signal?: AbortSignal): Promise<AutomationRun>;
+    markRead(scope: AutomationScope, runId: string, signal?: AbortSignal): Promise<AutomationRun>;
+    forgetSession(sessionId: string): Promise<void>;
+    forgetAutomationSessions(automationId: string): Promise<void>;
+    adoptSession(sessionId: string): Promise<void>;
+    addWorkspace(path: string): Promise<WorkspaceOption>;
+    private collectOptions;
+    private resolveCreateTarget;
+    private resolveScope;
+    private ownedDefinition;
+    private requestPump;
+    private pumpOnce;
+    private claimLatestDue;
+    private startQueuedRuns;
+    private startRun;
+    private executeRun;
+    private armNextTimer;
+    private armRetryTimer;
+    private clearTimer;
+    private serialize;
+    private recoverInterruptedRuns;
+    private pruneWorkspaceHistory;
+    private pruneAllHistory;
+}
+export {};

package/lib/types/tools.d.ts

@@ -0,0 +1,12 @@
+/** 绑定到单个 root Agent 工作区的管理工具。 */
+import type { AutomationService } from './service.ts';
+interface ToolAgent {
+    readonly id: string;
+    readonly ctx: {
+        readonly tools: {
+            register(definition: unknown): () => void;
+        };
+    };
+}
+export declare function registerAutomationTools(service: AutomationService, agent: ToolAgent): () => void;
+export {};