@crewx/sdk 0.9.0-rc.16 → 0.9.0-rc.160

package/dist/repository/logs-db.d.ts

@@ -0,0 +1,12 @@
+type SqliteDatabase = import('better-sqlite3').Database;
+export declare const LOGS_DB_FILE_NAME = "logs.db";
+export declare const LOGS_DB_SCHEMA_VERSION = 1;
+export declare function resolveCrewxLogsDbPath(crewxDbPath?: string): string;
+export declare function hashRequestLogBody(body: string): string;
+export interface LogsDbHandle {
+    readonly path: string;
+    readonly sqlite: SqliteDatabase;
+    close(): void;
+}
+export declare function openLogsDb(crewxDbPath?: string): LogsDbHandle;
+export {};

package/dist/repository/notification.repository.d.ts

@@ -0,0 +1,58 @@
+import { BaseSqliteRepository } from './base-sqlite-repository.js';
+import { notifications, notification_reads } from '../schema/index.js';
+export declare const DEFAULT_NOTIFICATION_CAP = 500;
+export type NotificationRow = typeof notifications.$inferSelect;
+export type NewNotification = typeof notifications.$inferInsert;
+export type NotificationReadRow = typeof notification_reads.$inferSelect;
+export type NotificationLevel = 'info' | 'warning' | 'critical';
+export type NotificationSource = 'agent' | 'system';
+export interface CreateNotificationInput {
+    workspaceId: string;
+    agentId?: string | null;
+    taskId?: string | null;
+    threadId?: string | null;
+    source?: NotificationSource;
+    level?: NotificationLevel;
+    title: string;
+    body?: string | null;
+    targetUserId?: string | null;
+    metadata?: string | null;
+}
+export interface NotificationListItem extends NotificationRow {
+    read: boolean;
+    read_at: string | null;
+}
+export interface ListNotificationsParams {
+    workspaceId: string;
+    userId: string;
+    limit?: number;
+}
+export interface UserScope {
+    workspaceId: string;
+    userId: string;
+}
+export interface MarkReadParams {
+    notificationId: string;
+    workspaceId: string;
+    userId: string;
+}
+export declare const DEFAULT_LIST_LIMIT = 50;
+export declare class NotificationRepository extends BaseSqliteRepository {
+    private readonly dbPath?;
+    private readonly cap;
+    constructor(opts?: {
+        dbPath?: string;
+        dbRoot?: string;
+        cap?: number;
+    });
+    resolveDbPath(): string;
+    private openHandle;
+    create(input: CreateNotificationInput): {
+        id: string;
+    };
+    private enforceCap;
+    list(params: ListNotificationsParams): NotificationListItem[];
+    unreadCount(params: UserScope): number;
+    markRead(params: MarkReadParams): boolean;
+    markAllRead(params: UserScope): number;
+}

package/dist/repository/project.repository.d.ts

@@ -0,0 +1,90 @@
+import { BaseSqliteRepository } from './base-sqlite-repository.js';
+import type { Project as ProjectLedgerRow, ProjectCriterion as ProjectCriterionRow, ProjectEvent as ProjectEventRow } from '../schema/index.js';
+export type ProjectScene = 'planning' | 'plan_review' | 'running' | 'human_wait' | 'limit_wait' | 'failed_stop' | 'analyzing_feedback' | 'replanned' | 'awaiting_review' | 'accepted';
+export type CriterionVerifyStatus = 'pending' | 'verifying' | 'passed' | 'failed';
+export type ProjectActorType = 'user' | 'project_manager' | 'system';
+export type ProjectEventType = 'created' | 'plan_proposed' | 'plan_approved' | 'decision_requested' | 'decision_answered' | 'replanned' | 'stage_advanced' | 'criterion_verified' | 'scene_changed' | 'result_submitted' | 'accepted';
+export type ProjectEvidenceKind = 'task' | 'wi' | 'url';
+export interface ProjectStage {
+    key: string;
+    labelOverride: string | null;
+}
+export declare const DEFAULT_PROJECT_STAGE_KEYS: readonly ["outcome_plan", "contract_check", "feature_link", "use_verify", "result_review"];
+export declare const DEFAULT_PROJECT_STAGES: readonly ProjectStage[];
+export interface ProjectEvidence {
+    kind: ProjectEvidenceKind;
+    ref: string;
+    label?: string;
+}
+export interface ProjectActorInput {
+    actorType?: ProjectActorType;
+    actorId?: string | null;
+}
+export interface CreateProjectInput {
+    workspaceId: string;
+    name: string;
+    outcome: string;
+    dueDate?: string | null;
+    stages?: readonly ProjectStage[];
+    criteria: readonly string[];
+}
+export interface ListProjectsOptions {
+    includeArchived?: boolean;
+}
+export interface ListProjectEventsOptions {
+    afterSeq?: number;
+    limit?: number;
+}
+export interface AppendProjectEventInput extends ProjectActorInput {
+    projectId: string;
+    type: ProjectEventType;
+    title: string;
+    summary?: string | null;
+    payload?: Record<string, unknown>;
+}
+export interface SetCriterionVerifyInput extends ProjectActorInput {
+    projectId?: string;
+    criterionId: string;
+    verifyStatus?: CriterionVerifyStatus;
+    status?: CriterionVerifyStatus;
+}
+export interface SetCriterionEvidenceInput extends ProjectActorInput {
+    projectId?: string;
+    criterionId: string;
+    evidence: readonly ProjectEvidence[];
+}
+export interface AcceptProjectInput extends ProjectActorInput {
+    remainingRisks: unknown;
+    nextPlan: unknown;
+    lessons: unknown;
+    evidenceRefs: unknown;
+}
+export interface ProjectDetail extends ProjectLedgerRow {
+    stages: ProjectStage[];
+    criteria: ProjectCriterionRow[];
+}
+export declare class ProjectRepository extends BaseSqliteRepository {
+    private readonly dbPath?;
+    constructor(opts?: {
+        dbPath?: string;
+        dbRoot?: string;
+    });
+    resolveDbPath(): string;
+    private openHandle;
+    private getDetailFromHandle;
+    private getDetailOrThrow;
+    createProject(input: CreateProjectInput): ProjectDetail;
+    getProject(id: string): ProjectDetail | undefined;
+    listProjectsByWorkspace(workspaceId: string, options?: ListProjectsOptions): ProjectDetail[];
+    archiveProject(id: string): ProjectDetail;
+    setScene(id: string, scene: ProjectScene, actor?: ProjectActorInput): ProjectDetail;
+    setStageIndex(id: string, index: number, actor?: ProjectActorInput): ProjectDetail;
+    setCriterionVerify(input: SetCriterionVerifyInput): ProjectCriterionRow;
+    setCriterionVerify(projectId: string, criterionId: string, status: CriterionVerifyStatus, actor?: ProjectActorInput): ProjectCriterionRow;
+    setCriterionEvidence(input: SetCriterionEvidenceInput): ProjectCriterionRow;
+    setCriterionEvidence(projectId: string, criterionId: string, evidence: readonly ProjectEvidence[], actor?: ProjectActorInput): ProjectCriterionRow;
+    appendEvent(input: AppendProjectEventInput): ProjectEventRow;
+    appendEvent(projectId: string, input: Omit<AppendProjectEventInput, 'projectId'>): ProjectEventRow;
+    listEvents(projectId: string, options?: ListProjectEventsOptions): ProjectEventRow[];
+    acceptProject(id: string, input: AcceptProjectInput): ProjectDetail;
+}

package/dist/repository/request-log-mover.d.ts

@@ -0,0 +1,70 @@
+export declare const REQUEST_LOG_MOVE_DEFAULT_BATCH_ROWS = 250;
+export declare const REQUEST_LOG_MOVE_DEFAULT_BATCH_BYTES: number;
+export declare const REQUEST_LOG_MOVE_CHECKPOINT_WAL_BYTES: number;
+export declare const REQUEST_LOG_MOVE_CHECKPOINT_MIN_INTERVAL_MS = 5000;
+export interface MoveRequestLogsProgress {
+    batches: number;
+    scannedRows: number;
+    movedRows: number;
+    bodiesAdded: number;
+    lastRowid: number;
+    elapsedMs: number;
+    deleteTxMs: number;
+    walBytes: number;
+}
+export interface MoveRequestLogsTestHooks {
+    afterRead?: (rows: ReadonlyArray<{
+        rowid: number;
+        id: string;
+    }>) => void;
+    afterLogsCommit?: (rows: ReadonlyArray<{
+        rowid: number;
+        id: string;
+    }>) => void;
+}
+export interface MoveRequestLogsOptions {
+    crewxDbPath?: string;
+    batchRows?: number;
+    batchBytes?: number;
+    maxBatches?: number;
+    maxMs?: number;
+    dryRun?: boolean;
+    checkpointWalBytes?: number;
+    checkpointMinIntervalMs?: number;
+    onProgress?: (progress: MoveRequestLogsProgress) => void;
+    testHooks?: MoveRequestLogsTestHooks;
+}
+export interface MoveRequestLogsResult {
+    crewxDbPath: string;
+    logsDbPath: string;
+    dryRun: boolean;
+    movedRows: number;
+    remainingRows: number;
+    bodiesAdded: number;
+    batches: number;
+    maxDeleteTxMs: number;
+    deleteTxMs: number[];
+    maxWalBytes: number;
+    checkpoints: number;
+    elapsedMs: number;
+    sliceLimitReached: boolean;
+    scan?: {
+        rows: number;
+        bodies: number;
+        bodyBytes: number;
+        distinctBodies: number;
+        distinctBodyBytes: number;
+    };
+}
+export declare function moveRequestLogsToLogsDb(opts?: MoveRequestLogsOptions): MoveRequestLogsResult;
+export interface RequestLogsMoveStatus {
+    crewxDbPath: string;
+    logsDbPath: string;
+    crewxRows: number;
+    crewxFreelistPages: number;
+    logsRows: number | null;
+    logsBodies: number | null;
+    logsFileBytes: number;
+    logsWalBytes: number;
+}
+export declare function inspectRequestLogsMove(crewxDbPath?: string): RequestLogsMoveStatus;

package/dist/repository/request-log.repository.d.ts

@@ -1,5 +1,5 @@
 import { BaseSqliteRepository } from './base-sqlite-repository.js';
-import { request_logs } from '../schema/index.js';
+import type { request_logs } from '../schema/index.js';
 export type RequestLogRow = typeof request_logs.$inferSelect;
 export type NewRequestLog = typeof request_logs.$inferInsert;
 export interface RequestLogEntry {
@@ -16,16 +16,20 @@ export interface RequestLogEntry {
     userId?: string;
     projectId?: string;
     partitionKey?: string;
+    timestamp?: string;
     metadata?: string;
 }
 export declare class RequestLogRepository extends BaseSqliteRepository {
     private readonly dbPath?;
+    private writer?;
     constructor(opts?: {
         dbPath?: string;
         dbRoot?: string;
     });
     resolveDbPath(): string;
-    private openHandle;
+    resolveLogsDbPath(): string;
+    private ensureWriter;
     bulkInsert(entries: RequestLogEntry[]): void;
-    findRecent(limit?: number): RequestLogRow[];
+    private prepareRow;
+    close(): void;
 }

package/dist/repository/storage-metadata.repository.d.ts

@@ -0,0 +1,64 @@
+import { BaseSqliteRepository } from './base-sqlite-repository.js';
+export declare const STORAGE_METADATA_KINDS: readonly ["taskLogs", "requestLogs", "prompts", "threadsLedger", "tasksLedger"];
+export declare const STORAGE_METADATA_UNITS: readonly ["task_log_events", "request_logs", "tasks", "threads"];
+export type StorageMetadataKind = (typeof STORAGE_METADATA_KINDS)[number];
+export type StorageMetadataUnit = (typeof STORAGE_METADATA_UNITS)[number];
+export type StorageMetadataAge = 'over6m' | 'm3to6' | 'm1to3' | 'recent1m';
+export interface StorageMetadataAggregateRow {
+    sourceKind: StorageMetadataKind;
+    age: StorageMetadataAge;
+    count: number;
+    bytes: number;
+}
+export interface StorageMetadataCutoffs {
+    cutoff6: string;
+    cutoff3: string;
+    cutoff1: string;
+}
+export interface StorageMetadataUnitReadiness {
+    cursorRowid: number;
+    endRowid: number | null;
+    complete: boolean;
+}
+export interface StorageMetadataReadiness {
+    ready: boolean;
+    units: Record<StorageMetadataUnit, StorageMetadataUnitReadiness>;
+}
+export interface StorageMetadataSnapshot {
+    readiness: StorageMetadataReadiness;
+    rows: StorageMetadataAggregateRow[];
+}
+export interface StorageMetadataBatchResult {
+    unit: StorageMetadataUnit | null;
+    rowsScanned: number;
+    rowsWritten: number;
+    cursorRowid: number;
+    complete: boolean;
+    ready: boolean;
+    elapsedMs: number;
+}
+export interface StorageMetadataVerificationMismatch {
+    sourceId: string;
+    metaBytes: number;
+    sourceBytes: number;
+}
+export declare class StorageMetadataRepository extends BaseSqliteRepository {
+    private readonly dbPath?;
+    constructor(opts?: {
+        dbPath?: string;
+        dbRoot?: string;
+    });
+    resolveDbPath(): string;
+    private hasReadableDatabase;
+    private openWritableDatabase;
+    private readReadiness;
+    private readAggregate;
+    getReadiness(): StorageMetadataReadiness;
+    aggregate(cutoffs: StorageMetadataCutoffs): StorageMetadataAggregateRow[];
+    readSnapshot(cutoffs: StorageMetadataCutoffs): StorageMetadataSnapshot;
+    runBackfillBatch(opts?: {
+        batchSize?: number;
+        unit?: StorageMetadataUnit;
+    }): StorageMetadataBatchResult;
+    verifySample(kind: StorageMetadataKind, limit: number): StorageMetadataVerificationMismatch[];
+}

package/dist/repository/task-log-migration.d.ts

@@ -0,0 +1,74 @@
+export type TaskLogMigrationMode = 'dry-run' | 'apply' | 'verify';
+export declare const TASK_LOG_MIGRATION_TERMINAL_STATUSES: readonly ["success", "failed", "completed"];
+export declare const TASK_LOG_MIGRATION_MIN_FREE_SPACE_BYTES: number;
+export declare const TASK_LOG_MIGRATION_EVENT_ROW_BYTES = 256;
+export type TaskLogVerificationIssueKind = 'malformed-blob' | 'mixed-source' | 'seq-gap' | 'duplicate-seq' | 'orphan-event' | 'count-mismatch' | 'source-invariant' | 'invalid-event';
+export type TaskLogMigrationFailureKind = 'malformed' | 'mixed-source' | 'metadata' | 'invalid-source';
+export interface TaskLogMigrationOptions {
+    mode: TaskLogMigrationMode;
+    dbPath?: string;
+    batchTasks?: number;
+    backupPath?: string;
+}
+export interface TaskLogMigrationFailure {
+    taskId: string;
+    reason: string;
+    kind?: TaskLogMigrationFailureKind;
+}
+export interface TaskLogVerificationIssue {
+    taskId: string | null;
+    kind: TaskLogVerificationIssueKind;
+    reason: string;
+    expected?: number;
+    actual?: number;
+    seq?: number;
+}
+export interface TaskLogVerificationReport {
+    checkedTasks: number;
+    eventSourceTasks: number;
+    blobSourceTasks: number;
+    eventCount: number;
+    orphanEventCount: number;
+    failedTasks: number;
+    issues: TaskLogVerificationIssue[];
+}
+export interface TaskLogMigrationReport {
+    mode: TaskLogMigrationMode;
+    ok: boolean;
+    dbPath: string;
+    backupPath?: string;
+    backupMethod?: 'sqlite-online-backup';
+    blockedReason?: string;
+    activeTaskCount: number;
+    taskCount: number;
+    candidateTaskCount: number;
+    eligibleTaskCount: number;
+    statusCounts: Record<string, number>;
+    deferredTaskCount: number;
+    deferredStatusCounts: Record<string, number>;
+    entryCount: number;
+    sourceBytes: number;
+    estimatedFreeSpaceBytes: number;
+    requiredFreeSpaceBytes: number;
+    availableFreeSpaceBytes: number;
+    minimumFreeSpaceReserveBytes: number;
+    freeSpaceGatePassed: boolean;
+    migratedTasks: number;
+    migratedEntries: number;
+    skippedTasks: number;
+    failedTasks: number;
+    malformedRows: TaskLogMigrationFailure[];
+    failures: TaskLogMigrationFailure[];
+    logicalSourceBytesRemoved: number;
+    warnings: string[];
+    remainingTaskCount: number;
+    verification?: TaskLogVerificationReport;
+}
+export declare function resolveTaskLogMigrationDbPath(dbPath?: string): string;
+export declare function hasSufficientTaskLogMigrationFreeSpace(availableFreeSpaceBytes: number, estimatedFreeSpaceBytes: number): boolean;
+export interface TaskLogWalCheckpointConnection {
+    pragma(pragma: string): unknown;
+}
+export declare function tryCheckpointTaskLogWal(db: TaskLogWalCheckpointConnection): string | undefined;
+export declare function runTaskLogMigration(options: TaskLogMigrationOptions): Promise<TaskLogMigrationReport>;
+export declare function taskLogBackupName(backupPath: string): string;

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

@@ -0,0 +1,44 @@
+import { BaseSqliteRepository } from './base-sqlite-repository.js';
+export type TaskLogStorage = 'blob' | 'events';
+export interface TaskLogEntry {
+    timestamp: string;
+    level: string;
+    message: string;
+}
+export type RawTaskLogEntry = TaskLogEntry;
+export type TaskLogRawEntry = TaskLogEntry;
+export interface TaskLogState {
+    taskId: string;
+    source: TaskLogStorage;
+    revision: number;
+    lastSeq: number;
+}
+export interface TaskLogReadResult extends TaskLogState {
+    entries: TaskLogEntry[];
+}
+export interface TaskLogRepositoryContract {
+    appendLog(taskId: string, entry: TaskLogEntry): TaskLogState;
+    appendLogs(taskId: string, entries: readonly TaskLogEntry[]): TaskLogState;
+    readLogs(taskId: string): TaskLogReadResult | undefined;
+    readLogsTail(taskId: string, limit: number): TaskLogReadResult | undefined;
+    getLogState(taskId: string): TaskLogState | undefined;
+}
+export declare class TaskLogRepository extends BaseSqliteRepository implements TaskLogRepositoryContract {
+    private readonly dbPath?;
+    constructor(opts?: {
+        dbPath?: string;
+        dbRoot?: string;
+    });
+    resolveDbPath(): string;
+    private openHandle;
+    private findStateRow;
+    private findStateRowInTransaction;
+    private requireStateRowInTransaction;
+    appendLog(taskId: string, entry: TaskLogEntry): TaskLogState;
+    appendLogs(taskId: string, entries: readonly TaskLogEntry[]): TaskLogState;
+    getLogState(taskId: string): TaskLogState | undefined;
+    readLogs(taskId: string): TaskLogReadResult | undefined;
+    readLogsTail(taskId: string, limit: number): TaskLogReadResult | undefined;
+    readTail(taskId: string, limit: number): TaskLogReadResult | undefined;
+    private readLogsInternal;
+}

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

@@ -0,0 +1,21 @@
+export type TaskStatus = 'pending' | 'running' | 'paused' | 'success' | 'failed' | 'stopped';
+export declare const TASK_TERMINAL_STATUSES: readonly ["success", "failed", "stopped"];
+export declare const TASK_TERMINAL_STORED_STATUSES: readonly ["success", "completed", "done", "failed", "error", "stopped", "runner_lost"];
+export declare function storedTaskStatusesFor(statuses: readonly string[]): string[];
+export type TaskTerminalStatus = (typeof TASK_TERMINAL_STATUSES)[number];
+export type TaskTerminalReason = 'user_stop' | 'runner_lost' | 'launch_failed';
+export declare const LEGACY_TASK_TERMINAL_ERROR_PATTERNS: {
+    readonly stopped: RegExp;
+    readonly runnerLost: RegExp;
+};
+export interface TaskStatusInput {
+    status: string;
+    error?: string | null;
+    metadata?: string | null;
+}
+export declare function readTaskTerminalReason(row: TaskStatusInput): TaskTerminalReason | undefined;
+export declare function normalizeTaskStatus(row: TaskStatusInput): TaskStatus;
+export declare function normalizeTaskRow<T extends TaskStatusInput>(row: T): Omit<T, 'status'> & {
+    status: TaskStatus;
+};
+export declare function isTaskRetryableByDefault(row: TaskStatusInput): boolean;