@crewx/sdk 0.9.0-rc.174 → 0.9.0-rc.175

package/dist/repository/run-columns.d.ts

@@ -0,0 +1,10 @@
+export declare const RUN_COLUMNS_BACKFILL = "tasks_run_columns";
+export declare const WORKFLOW_RUN_INDEX = "idx_tasks_workflow_run_id";
+export declare const SCHEDULE_TASKS_INDEX = "idx_tasks_ws_schedule_started";
+export declare const HUMAN_TASKS_INDEX = "idx_tasks_ws_human_started";
+export declare const RUN_COLUMN_INDEXES: ReadonlyArray<{
+    name: string;
+    sql: string;
+}>;
+export declare const SCHEDULED_TRIGGERS: readonly ["cron", "cron_manual"];
+export declare function readScheduleIdFromMetadata(metadata: string | null | undefined): string | null;

package/dist/repository/run-history.repository.d.ts

@@ -0,0 +1,112 @@
+import { BaseSqliteRepository } from './base-sqlite-repository.js';
+import type { ScheduleRunMode } from './schedule-run.repository.js';
+import { type TaskStatus } from './task-status.js';
+export type RunHistoryOrigin = 'all' | 'mine' | 'delegated' | 'scheduled' | 'workflow';
+export type RunHistoryKind = 'task' | 'workflow' | 'schedule_run';
+export type RunHistoryClass = 'mine' | 'delegated' | 'scheduled' | 'workflow' | 'system' | 'unknown';
+export type RunHistoryTerminalReason = 'user_stop' | 'runner_lost' | 'launch_failed';
+export interface RunHistoryQuery {
+    workspaceId: string;
+    origin?: RunHistoryOrigin;
+    scheduleId?: string;
+    includeFrequentSuccess?: boolean;
+    agents?: readonly string[];
+    statuses?: readonly TaskStatus[];
+    q?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface RunHistoryRow {
+    kind: RunHistoryKind;
+    id: string;
+    origin: RunHistoryClass;
+    startedAt: string;
+    finishedAt: string | null;
+    durationMs: number | null;
+    status: TaskStatus;
+    terminalReason: RunHistoryTerminalReason | null;
+    agentId: string | null;
+    mode: ScheduleRunMode | null;
+    taskId: string | null;
+    scheduleId: string | null;
+    scheduleName: string | null;
+    builtinId: string | null;
+    workflowRunId: string | null;
+    highFrequency: boolean;
+    errorCode: string | null;
+    preview: string | null;
+}
+export interface RunHistoryPage {
+    rows: RunHistoryRow[];
+    total: number;
+}
+export interface ScheduleRunSummaryLastRun {
+    kind: 'task' | 'schedule_run';
+    id: string;
+    taskId: string | null;
+    status: TaskStatus;
+    startedAt: string;
+    finishedAt: string | null;
+}
+export interface ScheduleRunSummary {
+    lastRun: ScheduleRunSummaryLastRun | null;
+    succeededToday: number;
+    failedLast24h: number;
+    checkedAt: string;
+}
+export interface ScheduleRunSummaryInput {
+    workspaceId: string;
+    scheduleIds: readonly string[];
+    timezoneBySchedule: Readonly<Record<string, string | undefined>>;
+    now: Date;
+}
+export interface FailedScheduleRunsSinceInput {
+    workspaceId: string;
+    since: Date;
+}
+export interface RunTaskIdsInput {
+    workspaceId: string;
+    taskIds: readonly string[];
+}
+export interface RunTaskListItemRow {
+    id: string;
+    model: string | null;
+    input_tokens: number | null;
+    output_tokens: number | null;
+    cost_usd: number | null;
+    thread_id: string | null;
+    metadata: string | null;
+    coding_agent_command: string | null;
+    caller_agent_id: string | null;
+    parent_agent_id: string | null;
+}
+export interface RunScheduleRunByTask {
+    taskId: string;
+    scheduleName: string | null;
+    builtinId: string | null;
+}
+export interface RunColumnBackfillInput {
+    batchSize?: number;
+}
+export interface RunColumnBackfillResult {
+    scanned: number;
+    updated: number;
+    done: boolean;
+    indexesBuilt: string[];
+}
+export declare const RUN_HISTORY_PREVIEW_RAW_CHARS = 1000;
+export declare class RunHistoryRepository extends BaseSqliteRepository {
+    private readonly dbPath?;
+    constructor(opts?: {
+        dbPath?: string;
+        dbRoot?: string;
+    });
+    resolveDbPath(): string;
+    private withReadable;
+    listRunHistory(query: RunHistoryQuery): RunHistoryPage;
+    getScheduleRunSummaries(input: ScheduleRunSummaryInput): Record<string, ScheduleRunSummary>;
+    countFailedScheduleRunsSince(input: FailedScheduleRunsSinceInput): number;
+    listTaskListItems(input: RunTaskIdsInput): RunTaskListItemRow[];
+    listScheduleRunsByTaskIds(input: RunTaskIdsInput): RunScheduleRunByTask[];
+    backfillRunColumns(input?: RunColumnBackfillInput): RunColumnBackfillResult;
+}

package/dist/repository/schedule-run.repository.d.ts

@@ -0,0 +1,103 @@
+import { BaseSqliteRepository } from './base-sqlite-repository.js';
+export type ScheduleRunMode = 'command' | 'agent' | 'app';
+export type ScheduleRunStatus = 'running' | 'success' | 'failed' | 'lost';
+export interface ScheduleRun {
+    id: string;
+    scheduleId: string;
+    workspaceId: string;
+    mode: ScheduleRunMode;
+    trigger: string;
+    occurrenceKey: string | null;
+    taskId: string | null;
+    appId: string | null;
+    scheduleName: string | null;
+    builtinId: string | null;
+    command: string | null;
+    highFrequency: boolean;
+    status: ScheduleRunStatus;
+    errorCode: string | null;
+    exitCode: number | null;
+    signal: string | null;
+    startedAt: string;
+    finishedAt: string | null;
+    durationMs: number | null;
+    pid: number | null;
+    hostPid: number | null;
+    outputTail: string | null;
+    outputBytes: number | null;
+    outputTruncated: boolean;
+}
+export interface NewScheduleRun {
+    id: string;
+    scheduleId: string;
+    workspaceId: string;
+    mode: ScheduleRunMode;
+    trigger: string;
+    occurrenceKey?: string | null;
+    taskId?: string | null;
+    appId?: string | null;
+    scheduleName?: string | null;
+    builtinId?: string | null;
+    command?: string | null;
+    highFrequency: boolean;
+    status: ScheduleRunStatus;
+    errorCode?: string | null;
+    startedAt: string;
+    finishedAt?: string | null;
+    durationMs?: number | null;
+    pid?: number | null;
+    hostPid?: number | null;
+}
+export interface ScheduleRunFinish {
+    status: 'success' | 'failed' | 'lost';
+    errorCode?: string | null;
+    exitCode?: number | null;
+    signal?: string | null;
+    finishedAt: string;
+    durationMs: number;
+    outputTail?: string | null;
+    outputBytes?: number | null;
+    outputTruncated?: boolean;
+}
+export interface ScheduleRunListOptions {
+    scheduleId?: string;
+    mode?: ScheduleRunMode;
+    limit?: number;
+}
+export interface ScheduleRunPruneResult {
+    deleted: number;
+    tailsCleared: number;
+}
+export interface ScheduleRunRepositoryInterface {
+    insert(run: NewScheduleRun): void;
+    finish(id: string, finish: ScheduleRunFinish): boolean;
+    markLost(id: string, finish: Omit<ScheduleRunFinish, 'status'>): boolean;
+    get(id: string): ScheduleRun | undefined;
+    listByWorkspace(workspaceId: string, options?: ScheduleRunListOptions): ScheduleRun[];
+    listBySchedule(workspaceId: string, scheduleId: string, limit?: number): ScheduleRun[];
+    listRunning(workspaceId: string): ScheduleRun[];
+    prune(workspaceId: string, now: Date): ScheduleRunPruneResult;
+}
+export declare const SCHEDULE_RUN_COMMAND_MAX_BYTES: number;
+export declare const SCHEDULE_RUN_SUCCESS_RETENTION_MS: number;
+export declare const SCHEDULE_RUN_FAILURE_RETENTION_MS: number;
+export declare const SCHEDULE_RUN_SUCCESS_TAIL_KEEP = 20;
+export declare const SCHEDULE_RUN_FAILURE_TAIL_KEEP = 50;
+export declare class ScheduleRunRepository extends BaseSqliteRepository implements ScheduleRunRepositoryInterface {
+    private readonly dbPath?;
+    constructor(opts?: {
+        dbPath?: string;
+        dbRoot?: string;
+    });
+    resolveDbPath(): string;
+    private openWritable;
+    private withReadable;
+    insert(run: NewScheduleRun): void;
+    finish(id: string, finish: ScheduleRunFinish): boolean;
+    markLost(id: string, finish: Omit<ScheduleRunFinish, 'status'>): boolean;
+    get(id: string): ScheduleRun | undefined;
+    listByWorkspace(workspaceId: string, options?: ScheduleRunListOptions): ScheduleRun[];
+    listBySchedule(workspaceId: string, scheduleId: string, limit?: number): ScheduleRun[];
+    listRunning(workspaceId: string): ScheduleRun[];
+    prune(workspaceId: string, now: Date): ScheduleRunPruneResult;
+}

package/dist/repository/task.repository.d.ts

@@ -2,6 +2,8 @@ import { BaseSqliteRepository } from './base-sqlite-repository.js';
 import type { DrizzleDb } from './db.js';
 import { RepositoryError } from './errors.js';
 import { tasks } from '../schema/index.js';
+import { type WorkflowAnchorTaskKind } from './workflow-anchor-kinds.js';
+import { type ProcessControlOptions } from '../process/process-control.js';
 import type { TaskLogEntry, TaskLogReadResult, TaskLogState } from './task-log.repository.js';
 import { type TaskStatus, type TaskTerminalReason } from './task-status.js';
 import { type StopTaskOptions, type StopTaskGenerationForInstructionOptions, type StopTaskResult } from '../lifecycle/task-stop.js';
@@ -86,7 +88,9 @@ export interface WorkflowParentTaskRow {
     started_at: string;
     metadata: string | null;
 }
-export type WorkflowParentTaskKind = 'workflow_card' | 'workflow_ui_instance';
+export { WORKFLOW_ANCHOR_TASK_KINDS, isWorkflowAnchorTaskKind } from './workflow-anchor-kinds.js';
+export type { WorkflowAnchorTaskKind } from './workflow-anchor-kinds.js';
+export type WorkflowParentTaskKind = WorkflowAnchorTaskKind;
 export interface WorkflowParentTaskLookup {
     workspaceId: string;
     workflowRunId: string;
@@ -185,6 +189,7 @@ export interface ThreadChain {
     targetAgentTurnCount: number;
     turns: ThreadChainTurn[];
 }
+export declare const CANONICAL_USER_STOP_ERROR = "Stopped by user";
 export declare const HOST_SHUTDOWN_TERMINAL_ERROR = "Stopped by app shutdown";
 type TaskUsageColumns = Pick<TaskRow, 'input_tokens' | 'output_tokens' | 'cached_input_tokens' | 'cost_usd'>;
 export declare function mergeTerminalReason(metadataJson: string | null | undefined, reason: TaskTerminalReason): string;
@@ -199,12 +204,15 @@ export declare class TaskRepository extends BaseSqliteRepository {
     private readonly dbPath?;
     private readonly clock;
     private readonly taskLogRepository;
+    private readonly processControl;
     private lastReaperTickAt?;
+    private orphanReapInFlight?;
     private readonly pidNullObservedSince;
     constructor(opts?: {
         dbPath?: string;
         dbRoot?: string;
         clock?: () => number;
+        processControl?: ProcessControlOptions;
     });
     resolveDbPath(): string;
     private openHandle;
@@ -325,7 +333,10 @@ export declare class TaskRepository extends BaseSqliteRepository {
     readProviderInput(id: string, runEpoch: number): ProviderInputRecord | undefined;
     getTask(id: string): TaskRow | undefined;
     killTask(id: string): Promise<TaskKillResult>;
-    reapOrphanedTasks(options?: ReapOrphanedTasksOptions): number;
+    reapOrphanedTasks(options?: ReapOrphanedTasksOptions): Promise<number>;
+    private runOrphanReaperPass;
+    private judgeRecordedTargets;
+    private terminateRecordedProcesses;
     reapRunningWorkflowTasks(graceMs?: number): number;
     findTaskStatus(taskId: string, workspaceId?: string): TaskRow | undefined;
     findChildTasks(parentTaskId: string, workspaceId?: string): TaskRow[];

package/dist/repository/workflow-anchor-kinds.d.ts

@@ -0,0 +1,4 @@
+export declare const WORKFLOW_ANCHOR_TASK_KINDS: readonly ["workflow_card", "workflow_ui_instance", "workflow_run"];
+export type WorkflowAnchorTaskKind = (typeof WORKFLOW_ANCHOR_TASK_KINDS)[number];
+export declare function isWorkflowAnchorTaskKind(value: unknown): value is WorkflowAnchorTaskKind;
+export declare function readWorkflowRunIdFromMetadata(metadata: string | null | undefined): string | null;

package/dist/schema/index.d.ts

@@ -23,3 +23,5 @@ export * from './thread-history.js';
 export * from './storage-metadata.js';
 export * from './agent-send-history.js';
 export * from './sidebar-tabs.js';
+export * from './schedule-runs.js';
+export * from './run-column-backfill.js';

package/dist/schema/run-column-backfill.d.ts

@@ -0,0 +1,81 @@
+export declare const run_column_backfill: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "run_column_backfill";
+    schema: undefined;
+    columns: {
+        name: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "name";
+            tableName: "run_column_backfill";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        cursor: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "cursor";
+            tableName: "run_column_backfill";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        anchor_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "anchor_id";
+            tableName: "run_column_backfill";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        completed_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "completed_at";
+            tableName: "run_column_backfill";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;