@hasna/loops 0.1.0 → 0.3.0

package/dist/lib/accounts.d.ts

@@ -0,0 +1,4 @@
+import type { AccountRef, AgentProvider } from "../types.js";
+export declare function accountToolForProvider(provider: AgentProvider): string;
+export declare function parseAccountExportLines(output: string): Record<string, string>;
+export declare function resolveAccountEnv(account: AccountRef | undefined, toolHint?: string, env?: NodeJS.ProcessEnv): Record<string, string>;

package/dist/lib/doctor.d.ts

@@ -0,0 +1,13 @@
+import type { Store } from "./store.js";
+export type DoctorSeverity = "ok" | "warn" | "fail";
+export interface DoctorCheck {
+    id: string;
+    status: DoctorSeverity;
+    message: string;
+    detail?: string;
+}
+export interface DoctorReport {
+    ok: boolean;
+    checks: DoctorCheck[];
+}
+export declare function runDoctor(store: Store): DoctorReport;

package/dist/lib/executor.d.ts

@@ -1,7 +1,26 @@
-import type { ExecutorResult, Loop, LoopRun } from "../types.js";
+import type { ExecutableTarget, ExecutorResult, Loop, LoopRun } from "../types.js";
 export interface ExecuteOptions {
     maxOutputBytes?: number;
     env?: NodeJS.ProcessEnv;
     log?: (message: string) => void;
+    signal?: AbortSignal;
+    onSpawn?: (pid: number) => void;
 }
+export interface ExecutionMetadata {
+    loopId?: string;
+    loopName?: string;
+    runId?: string;
+    scheduledFor?: string;
+    workflowId?: string;
+    workflowName?: string;
+    workflowRunId?: string;
+    workflowStepId?: string;
+}
+export interface PreflightResult {
+    command: string;
+    accountProfile?: string;
+    accountTool?: string;
+}
+export declare function preflightTarget(target: ExecutableTarget, metadata?: ExecutionMetadata, opts?: ExecuteOptions): PreflightResult;
+export declare function executeTarget(target: ExecutableTarget, metadata?: ExecutionMetadata, opts?: ExecuteOptions): Promise<ExecutorResult>;
 export declare function executeLoop(loop: Loop, run: LoopRun, opts?: ExecuteOptions): Promise<ExecutorResult>;

package/dist/lib/format.d.ts

@@ -1,4 +1,8 @@
-import type { Loop, LoopRun } from "../types.js";
+import type { Loop, LoopRun, WorkflowEvent, WorkflowRun, WorkflowSpec, WorkflowStepRun } from "../types.js";
 export declare function redact(value: string | undefined, visible?: number): string | undefined;
 export declare function publicLoop(loop: Loop): Record<string, unknown>;
 export declare function publicRun(run: LoopRun, showOutput?: boolean): Record<string, unknown>;
+export declare function publicWorkflow(workflow: WorkflowSpec): Record<string, unknown>;
+export declare function publicWorkflowRun(run: WorkflowRun): Record<string, unknown>;
+export declare function publicWorkflowStepRun(run: WorkflowStepRun, showOutput?: boolean): Record<string, unknown>;
+export declare function publicWorkflowEvent(event: WorkflowEvent): Record<string, unknown>;

package/dist/lib/scheduler.d.ts

@@ -15,4 +15,16 @@ export interface TickResult {
     recovered: LoopRun[];
     expired: Loop[];
 }
+export declare function manualRunScheduledFor(loop: Loop, now?: Date): string;
+export declare function shouldAdvanceManualRun(loop: Loop, scheduledFor: string, now?: Date): boolean;
+export declare function advanceLoop(store: Store, loop: Loop, run: LoopRun, finishedAt: Date, succeeded: boolean): void;
+export declare function executeClaimedRun(deps: {
+    store: Store;
+    runnerId: string;
+    loop: Loop;
+    run: LoopRun;
+    now?: () => Date;
+    execute?: (loop: Loop, run: LoopRun) => Promise<ExecutorResult>;
+    onError?: (loop: Loop, error: unknown) => void;
+}): Promise<LoopRun>;
 export declare function tick(deps: SchedulerDeps): Promise<TickResult>;

package/dist/lib/store.d.ts

@@ -1,4 +1,4 @@
-import type { CreateLoopInput, Loop, LoopRun, LoopStatus, RunStatus } from "../types.js";
+import type { CreateLoopInput, CreateWorkflowInput, Loop, LoopRun, LoopStatus, RunStatus, WorkflowEvent, WorkflowRun, WorkflowRunStatus, WorkflowSpec, WorkflowStepRun } from "../types.js";
 export interface DaemonLease {
     id: string;
     pid: number;
@@ -12,6 +12,13 @@ export interface ClaimRunResult {
     run: LoopRun;
     loop: Loop;
 }
+export interface CreateWorkflowRunInput {
+    workflow: WorkflowSpec;
+    loop?: Loop;
+    loopRun?: LoopRun;
+    scheduledFor?: string;
+    idempotencyKey?: string;
+}
 export declare class Store {
     private db;
     constructor(path?: string);
@@ -27,12 +34,50 @@ export declare class Store {
     dueLoops(now: Date): Loop[];
     updateLoop(id: string, patch: Partial<Pick<Loop, "status" | "nextRunAt" | "retryScheduledFor" | "expiresAt">>): Loop;
     deleteLoop(idOrName: string): boolean;
+    createWorkflow(input: CreateWorkflowInput): WorkflowSpec;
+    getWorkflow(id: string): WorkflowSpec | undefined;
+    findWorkflowByName(name: string): WorkflowSpec | undefined;
+    requireWorkflow(idOrName: string): WorkflowSpec;
+    listWorkflows(opts?: {
+        status?: WorkflowSpec["status"];
+        limit?: number;
+    }): WorkflowSpec[];
+    archiveWorkflow(idOrName: string): WorkflowSpec;
+    createWorkflowRun(input: CreateWorkflowRunInput): WorkflowRun;
+    getWorkflowRun(id: string): WorkflowRun | undefined;
+    requireWorkflowRun(id: string): WorkflowRun;
+    listWorkflowRuns(opts?: {
+        workflowId?: string;
+        loopRunId?: string;
+        limit?: number;
+    }): WorkflowRun[];
+    listWorkflowStepRuns(workflowRunId: string): WorkflowStepRun[];
+    getWorkflowStepRun(workflowRunId: string, stepId: string): WorkflowStepRun | undefined;
+    isWorkflowRunTerminal(workflowRunId: string): boolean;
+    startWorkflowStepRun(workflowRunId: string, stepId: string): WorkflowStepRun;
+    markWorkflowStepPid(workflowRunId: string, stepId: string, pid: number): WorkflowStepRun;
+    recoverWorkflowRun(workflowRunId: string, reason?: string): {
+        run: WorkflowRun;
+        recoveredSteps: WorkflowStepRun[];
+    };
+    finalizeWorkflowStepRun(workflowRunId: string, stepId: string, patch: Pick<WorkflowStepRun, "status" | "finishedAt" | "durationMs" | "stdout" | "stderr"> & Partial<Pick<WorkflowStepRun, "exitCode" | "error">>): WorkflowStepRun;
+    skipWorkflowStepRun(workflowRunId: string, stepId: string, reason: string): WorkflowStepRun;
+    finalizeWorkflowRun(workflowRunId: string, status: WorkflowRunStatus, patch?: Partial<Pick<WorkflowRun, "finishedAt" | "durationMs" | "error">>): WorkflowRun;
+    cancelWorkflowRun(workflowRunId: string, reason?: string): WorkflowRun;
+    appendWorkflowEvent(workflowRunId: string, eventType: string, stepId?: string, payload?: Record<string, unknown>): WorkflowEvent;
+    listWorkflowEvents(workflowRunId: string, limit?: number): WorkflowEvent[];
     hasRunningRun(loopId: string): boolean;
+    markRunPid(id: string, pid: number, claimedBy?: string): LoopRun | undefined;
+    private hasLiveWorkflowStepProcesses;
     createSkippedRun(loop: Loop, scheduledFor: string, reason: string): LoopRun;
     getRun(id: string): LoopRun | undefined;
     getRunBySlot(loopId: string, scheduledFor: string): LoopRun | undefined;
     claimRun(loop: Loop, scheduledFor: string, runnerId: string, now?: Date): ClaimRunResult | undefined;
-    finalizeRun(id: string, patch: Pick<LoopRun, "status" | "finishedAt" | "durationMs" | "stdout" | "stderr"> & Partial<Pick<LoopRun, "exitCode" | "error" | "pid">>): LoopRun;
+    finalizeRun(id: string, patch: Pick<LoopRun, "status" | "finishedAt" | "durationMs" | "stdout" | "stderr"> & Partial<Pick<LoopRun, "exitCode" | "error" | "pid">>, opts?: {
+        claimedBy?: string;
+        now?: Date;
+    }): LoopRun;
+    heartbeatRunLease(id: string, claimedBy: string, leaseMs: number, now?: Date): LoopRun | undefined;
     listRuns(opts?: {
         loopId?: string;
         status?: RunStatus;