@crewx/sdk 0.8.2 → 0.8.3-rc.0

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

@@ -0,0 +1,115 @@
+import { BaseSqliteRepository } from './base-sqlite-repository.js';
+import { tasks } from '../schema/index.js';
+export type TaskRow = typeof tasks.$inferSelect;
+export type NewTask = typeof tasks.$inferInsert;
+export interface AgentUsageRow {
+    agentId: string;
+    totalTasks: number;
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+    costUsd: number;
+}
+export interface TrendRow {
+    date: string;
+    agentId: string;
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+    costUsd: number;
+}
+export declare class TaskRepository extends BaseSqliteRepository {
+    private readonly dbPath?;
+    constructor(opts?: {
+        dbPath?: string;
+        dbRoot?: string;
+    });
+    resolveDbPath(): string;
+    private openHandle;
+    startTask(opts: {
+        id: string;
+        agentId: string;
+        prompt: string;
+        mode: string;
+        status: string;
+        startedAt: string;
+        pid?: number | null;
+        parentTaskId?: string | null;
+        callerAgentId?: string | null;
+        traceId?: string | null;
+        command?: string | null;
+        metadata?: string | null;
+        workspaceId?: string | null;
+        workspaceName?: string | null;
+        platform?: string | null;
+        crewxVersion?: string | null;
+        threadId?: string | null;
+        model?: string | null;
+        renderedPrompt?: string | null;
+        codingAgentCommand?: string | null;
+    }): void;
+    finishTask(opts: {
+        id: string;
+        status: string;
+        result?: string | null;
+        error?: string | null;
+        completedAt: string;
+        durationMs?: number | null;
+        exitCode?: number | null;
+        inputTokens?: number;
+        outputTokens?: number;
+        cachedInputTokens?: number;
+        costUsd?: number;
+        model?: string | null;
+    }): void;
+    appendLog(taskId: string, entry: {
+        timestamp: string;
+        level: string;
+        message: string;
+    }): void;
+    getRunningTasks(): TaskRow[];
+    getAllTasks(): TaskRow[];
+    getTask(id: string): TaskRow | undefined;
+    killTask(id: string): {
+        killed: boolean;
+        pid?: number;
+    };
+    findTaskStatus(taskId: string, workspaceId?: string): TaskRow | undefined;
+    findChildTasks(parentTaskId: string, workspaceId?: string): TaskRow[];
+    getWorkspaceUsageSummary(workspaceId?: string): Array<{
+        workspace_id: string;
+        workspace_name: string;
+        input_tokens: number;
+        output_tokens: number;
+        cost_usd: number;
+        task_count: number;
+    }>;
+    getThreadTokenUsage(threadId: string, workspaceId?: string): {
+        inputTokens: number;
+        outputTokens: number;
+        costUsd: number;
+    };
+    findTasksByThread(threadId: string, workspaceId?: string): TaskRow[];
+    findAllTasks(params: {
+        workspaceId?: string;
+        agentId?: string;
+        agents?: string[];
+        status?: string;
+        statuses?: string[];
+        search?: string;
+        q?: string;
+        limit: number;
+        offset: number;
+        sortDir?: 'ASC' | 'DESC';
+        from?: string;
+        to?: string;
+    }): {
+        rows: TaskRow[];
+        total: number;
+    };
+    getAgentUsage(from: string, to: string, workspace?: string): AgentUsageRow[];
+    getAgentUsageTrendRaw(from: string, to: string, workspace?: string): TrendRow[];
+    findTaskForStop(taskId: string, workspaceId: string): TaskRow | undefined;
+    markTaskFailed(taskId: string, error: string, workspaceId?: string): void;
+    findTasksByPromptHint(hint: string, workspaceId?: string): TaskRow[];
+}

package/dist/repository/thread-box.repository.d.ts

@@ -0,0 +1,20 @@
+import { BaseSqliteRepository } from './base-sqlite-repository.js';
+import { thread_boxes } from '../schema/index.js';
+export type ThreadBoxRow = typeof thread_boxes.$inferSelect;
+export type NewThreadBox = typeof thread_boxes.$inferInsert;
+export declare class ThreadBoxRepository extends BaseSqliteRepository {
+    private readonly dbPath?;
+    constructor(opts?: {
+        dbPath?: string;
+        dbRoot?: string;
+    });
+    resolveDbPath(): string;
+    private openHandle;
+    private ensureThreadExists;
+    findByThreadId(threadId: string): ThreadBoxRow[];
+    findById(threadId: string, boxId: string): ThreadBoxRow | undefined;
+    insert(data: Omit<NewThreadBox, 'id'> & {
+        id: string;
+        threadId: string;
+    }): ThreadBoxRow;
+}

package/dist/repository/thread.repository.d.ts

@@ -0,0 +1,56 @@
+import { BaseSqliteRepository } from './base-sqlite-repository.js';
+import { threads } from '../schema/index.js';
+import type { TaskRow } from './task.repository.js';
+export type ThreadRow = typeof threads.$inferSelect;
+export type NewThread = typeof threads.$inferInsert;
+export declare class ThreadRepository extends BaseSqliteRepository {
+    private readonly dbPath?;
+    constructor(opts?: {
+        dbPath?: string;
+        dbRoot?: string;
+    });
+    resolveDbPath(): string;
+    private openHandle;
+    private validateWorkspaceId;
+    findAllThreads(workspaceId?: string): ThreadRow[];
+    findThreadById(threadId: string, workspaceId?: string): ThreadRow | undefined;
+    threadExists(threadId: string, workspaceId?: string): boolean;
+    aggregateTaskStats(threadId: string, workspaceId?: string): {
+        taskCount: number;
+        inputTokens: number;
+        outputTokens: number;
+        cachedInputTokens: number;
+        costUsd: number;
+        agentIds: string[];
+    };
+    findTopLevelTasks(threadId: string, workspaceId?: string): TaskRow[];
+    findAllTasks(threadId: string, workspaceId?: string): TaskRow[];
+    findTaskById(threadId: string, taskId: string, workspaceId?: string): {
+        task: TaskRow;
+        children: TaskRow[];
+    } | undefined;
+    batchFetchTasks(threadIds: string[], workspaceId?: string): Map<string, TaskRow[]>;
+    updateThreadTitle(threadId: string, title: string, workspaceId?: string): void;
+    upsertThread(threadId: string, opts: {
+        platform: string;
+        workspaceId?: string;
+        title?: string;
+        titleLocked?: boolean;
+    }): void;
+    ensureThread(threadId: string, platform: string, workspaceId?: string): void;
+    saveUserMessage(threadId: string, text: string, opts?: {
+        platform?: string;
+        model?: string;
+    }): void;
+    saveAssistantMessage(threadId: string, text: string, opts?: {
+        platform?: string;
+        model?: string;
+        inputTokens?: number;
+        outputTokens?: number;
+        cachedInputTokens?: number;
+    }): void;
+    updateThread(threadId: string, patch: {
+        title?: string;
+        titleLocked?: boolean;
+    }): void;
+}

package/dist/repository/tool-call.repository.d.ts

@@ -0,0 +1,19 @@
+import { BaseSqliteRepository } from './base-sqlite-repository.js';
+import { tool_calls } from '../schema/index.js';
+export type ToolCallRow = typeof tool_calls.$inferSelect;
+export type NewToolCall = typeof tool_calls.$inferInsert;
+export declare class ToolCallRepository extends BaseSqliteRepository {
+    private readonly dbPath?;
+    constructor(opts?: {
+        dbPath?: string;
+        dbRoot?: string;
+    });
+    resolveDbPath(): string;
+    private openHandle;
+    insertToolCall(opts: NewToolCall): void;
+    findByTaskId(taskId: string): ToolCallRow[];
+    aggregateByName(taskId: string): {
+        toolName: string;
+        count: number;
+    }[];
+}

package/dist/repository/workspace.repository.d.ts

@@ -0,0 +1,64 @@
+import { BaseSqliteRepository } from './base-sqlite-repository.js';
+import type { DrizzleDb } from './db.js';
+import type { Workspace } from '../schema/index.js';
+export type ProjectRow = Workspace;
+export interface ThreadRow {
+    id: string;
+    workspace_id: string | null;
+    platform: string;
+    title: string | null;
+    first_message: string | null;
+    last_message: string | null;
+    message_count: number;
+    created_at: string;
+    updated_at: string;
+    metadata: string | null;
+}
+export interface ThreadWithAgentRow extends ThreadRow {
+    agent_id: string | null;
+}
+export declare class WorkspaceRepository extends BaseSqliteRepository {
+    private readonly dbRoot?;
+    constructor(opts?: {
+        dbRoot?: string;
+    });
+    resolveDbPath(): string;
+    private openHandle;
+    resolveSlug(db: DrizzleDb, workspaceId: string, workspacePath: string): string;
+    ensureRow(db: DrizzleDb, opts: {
+        id: string;
+        slug: string;
+        name: string;
+        workspacePath: string;
+    }): void;
+    registerWorkspace(workspacePath: string): {
+        id: string;
+        slug: string;
+    };
+    listProjects(params: {
+        isActive?: boolean;
+        limit: number;
+        offset: number;
+    }): {
+        rows: ProjectRow[];
+        total: number;
+    };
+    findById(id: string): ProjectRow | undefined;
+    findAgentsByProject(id: string): string[];
+    findThreadsByProject(id: string, params: {
+        limit: number;
+        offset: number;
+    }): {
+        rows: ThreadWithAgentRow[];
+        total: number;
+    };
+    findBySlug(slug: string): ProjectRow | undefined;
+    slugExists(slug: string, excludeId?: string): boolean;
+    insert(id: string, slug: string, name: string, repoPath: string | null): ProjectRow;
+    update(id: string, updates: string[], args: (string | number | null)[]): ProjectRow;
+    cleanupOrphanWorkspaces(): {
+        softDeleted: number;
+        checked: number;
+    };
+    delete(id: string): void;
+}

package/dist/schema/index.d.ts

@@ -0,0 +1,7 @@
+export * from './workspaces.js';
+export * from './tasks.js';
+export * from './threads.js';
+export * from './spans.js';
+export * from './tool-calls.js';
+export * from './thread-boxes.js';
+export * from './request-logs.js';

package/dist/schema/request-logs.d.ts

@@ -0,0 +1,309 @@
+export declare const request_logs: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "request_logs";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "request_logs";
+            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;
+        }>;
+        path: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "path";
+            tableName: "request_logs";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        method: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "method";
+            tableName: "request_logs";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        status_code: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "status_code";
+            tableName: "request_logs";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        duration_ms: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "duration_ms";
+            tableName: "request_logs";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        ip: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "ip";
+            tableName: "request_logs";
+            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;
+        }>;
+        request_headers: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "request_headers";
+            tableName: "request_logs";
+            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;
+        }>;
+        response_headers: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "response_headers";
+            tableName: "request_logs";
+            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;
+        }>;
+        request_body: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "request_body";
+            tableName: "request_logs";
+            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;
+        }>;
+        response_body: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "response_body";
+            tableName: "request_logs";
+            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;
+        }>;
+        query: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "query";
+            tableName: "request_logs";
+            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;
+        }>;
+        user_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "user_id";
+            tableName: "request_logs";
+            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;
+        }>;
+        project_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "project_id";
+            tableName: "request_logs";
+            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;
+        }>;
+        partition_key: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "partition_key";
+            tableName: "request_logs";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        timestamp: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "timestamp";
+            tableName: "request_logs";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        metadata: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "metadata";
+            tableName: "request_logs";
+            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";
+}>;
+export type RequestLog = typeof request_logs.$inferSelect;
+export type NewRequestLog = typeof request_logs.$inferInsert;