@hold-rein/cli 0.0.0

package/dist/runtime/api/modules/workspaces/workspace-repository.js

@@ -0,0 +1,326 @@
+import { desc, eq, sql } from "drizzle-orm";
+import { modelTokenUsageHourly, tasks, workspaces } from "../../db/index.js";
+export function createInMemoryWorkspaceRepository(seed = { tasks: [], workspaces: [] }) {
+    const workspaceRows = seed.workspaces.map((workspace) => workspace);
+    const taskRows = seed.tasks.map(toTaskRow);
+    const modelTokenUsageHourlyRows = [];
+    return {
+        addModelTokenUsageHourly: (usage) => {
+            const hour = normalizeUsageHour(usage.hour);
+            const existingIndex = modelTokenUsageHourlyRows.findIndex((row) => row.provider === usage.provider &&
+                row.modelName === usage.modelName &&
+                row.hour === hour);
+            const existingUsage = modelTokenUsageHourlyRows[existingIndex];
+            const nextUsage = {
+                hour,
+                inputToken: (existingUsage?.inputToken ?? 0) + (usage.inputToken ?? 0),
+                modelName: usage.modelName,
+                outputToken: (existingUsage?.outputToken ?? 0) + (usage.outputToken ?? 0),
+                provider: usage.provider
+            };
+            if (existingIndex >= 0) {
+                modelTokenUsageHourlyRows[existingIndex] = nextUsage;
+            }
+            else {
+                modelTokenUsageHourlyRows.push(nextUsage);
+            }
+            return nextUsage;
+        },
+        addTaskTokenUsage: (taskId, usage) => {
+            const taskIndex = taskRows.findIndex((task) => task.id === taskId);
+            const existingTask = taskRows[taskIndex];
+            if (!existingTask)
+                return undefined;
+            const nextTask = {
+                ...existingTask,
+                inputToken: existingTask.inputToken + usage.inputToken,
+                outputToken: existingTask.outputToken + usage.outputToken
+            };
+            taskRows[taskIndex] = nextTask;
+            return nextTask;
+        },
+        createTask: (task) => {
+            const row = toTaskRow(task);
+            taskRows.push(row);
+            return row;
+        },
+        createWorkspace: (workspace) => {
+            workspaceRows.push(workspace);
+            return workspace;
+        },
+        deleteTaskById: (taskId) => {
+            const taskIndex = taskRows.findIndex((task) => task.id === taskId);
+            if (taskIndex >= 0) {
+                taskRows.splice(taskIndex, 1);
+            }
+        },
+        deleteTasksByWorkspaceId: (workspaceId) => {
+            for (let index = taskRows.length - 1; index >= 0; index -= 1) {
+                if (taskRows[index]?.workspaceId === workspaceId) {
+                    taskRows.splice(index, 1);
+                }
+            }
+        },
+        deleteWorkspaceById: (workspaceId) => {
+            const workspaceIndex = workspaceRows.findIndex((workspace) => workspace.id === workspaceId);
+            if (workspaceIndex >= 0) {
+                workspaceRows.splice(workspaceIndex, 1);
+            }
+        },
+        findTaskById: (taskId) => taskRows.find((task) => task.id === taskId),
+        findWorkspaceById: (workspaceId) => workspaceRows.find((workspace) => workspace.id === workspaceId),
+        findWorkspaceByPath: (workspacePath) => workspaceRows.find((workspace) => workspace.path === workspacePath),
+        listTasksAfterLastContinuedAt: ({ afterLastContinuedAt, limit, workspaceId }) => sortTasksDescending(taskRows.filter((task) => task.workspaceId === workspaceId &&
+            task.lastContinuedAt !== null &&
+            task.lastContinuedAt < afterLastContinuedAt)).slice(0, limit),
+        listAllTasksByWorkspaceId: (workspaceId) => taskRows.filter((task) => task.workspaceId === workspaceId),
+        listTasksByWorkspaceId: ({ limit, workspaceId }) => sortTasksDescending(taskRows.filter((task) => task.workspaceId === workspaceId && task.lastContinuedAt !== null)).slice(0, limit),
+        listWorkspaces: () => [...workspaceRows].sort((left, right) => left.name.localeCompare(right.name)),
+        updateTaskTitle: (taskId, title, updatedAt) => {
+            const taskIndex = taskRows.findIndex((task) => task.id === taskId);
+            const existingTask = taskRows.find((task) => task.id === taskId);
+            if (taskIndex === -1 || !existingTask) {
+                return undefined;
+            }
+            const nextTask = { ...existingTask, title, updatedAt };
+            taskRows[taskIndex] = nextTask;
+            return nextTask;
+        },
+        updateTaskContinuedAt: (taskId, continuedAt) => {
+            const taskIndex = taskRows.findIndex((task) => task.id === taskId);
+            const existingTask = taskRows[taskIndex];
+            if (!existingTask)
+                return undefined;
+            const nextTask = {
+                ...existingTask,
+                lastContinuedAt: continuedAt,
+                updatedAt: continuedAt
+            };
+            taskRows[taskIndex] = nextTask;
+            return nextTask;
+        },
+        updateTaskModel: (taskId, model, updatedAt) => {
+            const taskIndex = taskRows.findIndex((task) => task.id === taskId);
+            const existingTask = taskRows[taskIndex];
+            if (!existingTask)
+                return undefined;
+            const nextTask = { ...existingTask, ...model, updatedAt };
+            taskRows[taskIndex] = nextTask;
+            return nextTask;
+        },
+        updateTaskOptions: (taskId, options, updatedAt) => {
+            const taskIndex = taskRows.findIndex((task) => task.id === taskId);
+            const existingTask = taskRows[taskIndex];
+            if (!existingTask)
+                return undefined;
+            const nextTask = { ...existingTask, ...options, updatedAt };
+            taskRows[taskIndex] = nextTask;
+            return nextTask;
+        },
+        updateTaskSession: (taskId, session) => {
+            const taskIndex = taskRows.findIndex((task) => task.id === taskId);
+            const existingTask = taskRows[taskIndex];
+            if (!existingTask)
+                return undefined;
+            const nextTask = {
+                ...existingTask,
+                sessionCreatedAt: session.createdAt,
+                sessionId: session.id,
+                sessionPath: session.path
+            };
+            taskRows[taskIndex] = nextTask;
+            return nextTask;
+        },
+        updateTaskStatus: (taskId, status, updatedAt) => {
+            const taskIndex = taskRows.findIndex((task) => task.id === taskId);
+            const existingTask = taskRows[taskIndex];
+            if (!existingTask)
+                return undefined;
+            const nextTask = { ...existingTask, status, updatedAt };
+            taskRows[taskIndex] = nextTask;
+            return nextTask;
+        }
+    };
+}
+export function createSqliteWorkspaceRepository(database) {
+    return {
+        addModelTokenUsageHourly: (usage) => {
+            const row = {
+                ...usage,
+                hour: normalizeUsageHour(usage.hour),
+                inputToken: usage.inputToken ?? 0,
+                outputToken: usage.outputToken ?? 0
+            };
+            database.db
+                .insert(modelTokenUsageHourly)
+                .values(row)
+                .onConflictDoUpdate({
+                set: {
+                    inputToken: sql `${modelTokenUsageHourly.inputToken} + ${row.inputToken}`,
+                    outputToken: sql `${modelTokenUsageHourly.outputToken} + ${row.outputToken}`
+                },
+                target: [
+                    modelTokenUsageHourly.provider,
+                    modelTokenUsageHourly.modelName,
+                    modelTokenUsageHourly.hour
+                ]
+            })
+                .run();
+            return database.db
+                .select()
+                .from(modelTokenUsageHourly)
+                .where(sql `
+          ${modelTokenUsageHourly.provider} = ${row.provider}
+          AND ${modelTokenUsageHourly.modelName} = ${row.modelName}
+          AND ${modelTokenUsageHourly.hour} = ${row.hour}
+        `)
+                .get();
+        },
+        addTaskTokenUsage: (taskId, usage) => {
+            database.db
+                .update(tasks)
+                .set({
+                inputToken: sql `${tasks.inputToken} + ${usage.inputToken}`,
+                outputToken: sql `${tasks.outputToken} + ${usage.outputToken}`
+            })
+                .where(eq(tasks.id, taskId))
+                .run();
+            return database.db.select().from(tasks).where(eq(tasks.id, taskId)).get();
+        },
+        createTask: (task) => {
+            const row = toTaskRow(task);
+            database.db.insert(tasks).values(row).run();
+            return row;
+        },
+        createWorkspace: (workspace) => {
+            database.db.insert(workspaces).values(workspace).run();
+            return workspace;
+        },
+        deleteTaskById: (taskId) => {
+            database.db.delete(tasks).where(eq(tasks.id, taskId)).run();
+        },
+        deleteTasksByWorkspaceId: (workspaceId) => {
+            database.db.delete(tasks).where(eq(tasks.workspaceId, workspaceId)).run();
+        },
+        deleteWorkspaceById: (workspaceId) => {
+            database.db.delete(workspaces).where(eq(workspaces.id, workspaceId)).run();
+        },
+        findTaskById: (taskId) => database.db
+            .select()
+            .from(tasks)
+            .where(eq(tasks.id, taskId))
+            .get(),
+        findWorkspaceById: (workspaceId) => database.db
+            .select()
+            .from(workspaces)
+            .where(eq(workspaces.id, workspaceId))
+            .get(),
+        findWorkspaceByPath: (workspacePath) => database.db
+            .select()
+            .from(workspaces)
+            .where(eq(workspaces.path, workspacePath))
+            .get(),
+        listTasksAfterLastContinuedAt: ({ afterLastContinuedAt, limit, workspaceId }) => database.db
+            .select()
+            .from(tasks)
+            .where(eq(tasks.workspaceId, workspaceId))
+            .orderBy(desc(tasks.lastContinuedAt))
+            .all()
+            .filter((task) => task.lastContinuedAt !== null &&
+            task.lastContinuedAt < afterLastContinuedAt)
+            .slice(0, limit),
+        listAllTasksByWorkspaceId: (workspaceId) => database.db
+            .select()
+            .from(tasks)
+            .where(eq(tasks.workspaceId, workspaceId))
+            .all(),
+        listTasksByWorkspaceId: ({ limit, workspaceId }) => database.db
+            .select()
+            .from(tasks)
+            .where(eq(tasks.workspaceId, workspaceId))
+            .orderBy(desc(tasks.lastContinuedAt))
+            .all()
+            .filter((task) => task.lastContinuedAt !== null)
+            .slice(0, limit),
+        listWorkspaces: () => database.db.select().from(workspaces).all(),
+        updateTaskTitle: (taskId, title, updatedAt) => {
+            database.db
+                .update(tasks)
+                .set({ title, updatedAt })
+                .where(eq(tasks.id, taskId))
+                .run();
+            return database.db
+                .select()
+                .from(tasks)
+                .where(eq(tasks.id, taskId))
+                .get();
+        },
+        updateTaskContinuedAt: (taskId, continuedAt) => {
+            database.db
+                .update(tasks)
+                .set({ lastContinuedAt: continuedAt, updatedAt: continuedAt })
+                .where(eq(tasks.id, taskId))
+                .run();
+            return database.db.select().from(tasks).where(eq(tasks.id, taskId)).get();
+        },
+        updateTaskModel: (taskId, model, updatedAt) => {
+            database.db
+                .update(tasks)
+                .set({ ...model, updatedAt })
+                .where(eq(tasks.id, taskId))
+                .run();
+            return database.db.select().from(tasks).where(eq(tasks.id, taskId)).get();
+        },
+        updateTaskOptions: (taskId, options, updatedAt) => {
+            database.db
+                .update(tasks)
+                .set({ ...options, updatedAt })
+                .where(eq(tasks.id, taskId))
+                .run();
+            return database.db.select().from(tasks).where(eq(tasks.id, taskId)).get();
+        },
+        updateTaskSession: (taskId, session) => {
+            database.db
+                .update(tasks)
+                .set({
+                sessionCreatedAt: session.createdAt,
+                sessionId: session.id,
+                sessionPath: session.path
+            })
+                .where(eq(tasks.id, taskId))
+                .run();
+            return database.db.select().from(tasks).where(eq(tasks.id, taskId)).get();
+        },
+        updateTaskStatus: (taskId, status, updatedAt) => {
+            database.db
+                .update(tasks)
+                .set({ status, updatedAt })
+                .where(eq(tasks.id, taskId))
+                .run();
+            return database.db.select().from(tasks).where(eq(tasks.id, taskId)).get();
+        }
+    };
+}
+function sortTasksDescending(taskRows) {
+    return [...taskRows].sort((left, right) => String(right.lastContinuedAt).localeCompare(String(left.lastContinuedAt)));
+}
+function normalizeUsageHour(hour) {
+    const date = new Date(hour);
+    date.setUTCMinutes(0, 0, 0);
+    return date.toISOString();
+}
+function toTaskRow(task) {
+    return {
+        ...task,
+        approvalPolicy: task.approvalPolicy ?? "approval",
+        lastContinuedAt: task.lastContinuedAt ?? null,
+        lastModelId: task.lastModelId ?? null,
+        inputToken: task.inputToken ?? 0,
+        outputToken: task.outputToken ?? 0,
+        sessionCreatedAt: task.sessionCreatedAt ?? null,
+        sessionId: task.sessionId ?? null,
+        sessionPath: task.sessionPath ?? null,
+        status: task.status ?? "completed",
+        thinkingLevel: task.thinkingLevel ?? "medium"
+    };
+}

package/dist/runtime/api/modules/workspaces/workspace-types.d.ts

@@ -0,0 +1,33 @@
+import type { TaskRow, WorkspaceRow } from "../../db";
+export interface WorkspaceTaskSummary {
+    activeAgentId?: string;
+    approvalPolicy: TaskRow["approvalPolicy"];
+    id: string;
+    initialUserMessage: string;
+    lastContinuedAt: string;
+    lastModelId: TaskRow["lastModelId"];
+    lastModelName: string;
+    lastModelProvider: string;
+    lastModelProviderSource: TaskRow["lastModelProviderSource"];
+    status: TaskRow["status"];
+    thinkingLevel: TaskRow["thinkingLevel"];
+    title: string;
+}
+export interface WorkspaceWithTasksSummary {
+    hasMore: boolean;
+    id: string;
+    name: string;
+    path: string;
+    tasks: WorkspaceTaskSummary[];
+}
+export interface RecentWorkspaceTasksResult {
+    workspaces: WorkspaceWithTasksSummary[];
+}
+export interface WorkspaceTaskPageResult {
+    hasMore: boolean;
+    tasks: WorkspaceTaskSummary[];
+    workspaceId: string;
+}
+export type WorkspaceNavigationRow = WorkspaceRow;
+export type WorkspaceNavigationTaskRow = TaskRow;
+//# sourceMappingURL=workspace-types.d.ts.map

package/dist/runtime/api/modules/workspaces/workspace-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-types.d.ts","sourceRoot":"","sources":["../../../src/modules/workspaces/workspace-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAEtD,MAAM,WAAW,oBAAoB;IACnC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC1C,EAAE,EAAE,MAAM,CAAC;IACX,kBAAkB,EAAE,MAAM,CAAC;IAC3B,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;IACpC,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,uBAAuB,EAAE,OAAO,CAAC,yBAAyB,CAAC,CAAC;IAC5D,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC1B,aAAa,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;IACxC,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,OAAO,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,oBAAoB,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,0BAA0B;IACzC,UAAU,EAAE,yBAAyB,EAAE,CAAC;CACzC;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,oBAAoB,EAAE,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,MAAM,sBAAsB,GAAG,YAAY,CAAC;AAClD,MAAM,MAAM,0BAA0B,GAAG,OAAO,CAAC"}

package/dist/runtime/api/modules/workspaces/workspace-types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/api/modules/workspaces/workspaces-router.d.ts

@@ -0,0 +1,7 @@
+import { Router } from "express";
+import type { WorkspacesService } from "./workspaces-service";
+export interface CreateWorkspacesRouterOptions {
+    workspacesService?: WorkspacesService;
+}
+export declare function createWorkspacesRouter(options?: CreateWorkspacesRouterOptions): Router;
+//# sourceMappingURL=workspaces-router.d.ts.map

package/dist/runtime/api/modules/workspaces/workspaces-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspaces-router.d.ts","sourceRoot":"","sources":["../../../src/modules/workspaces/workspaces-router.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EAIP,MAAM,SAAS,CAAC;AAKjB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,MAAM,WAAW,6BAA6B;IAC5C,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;CACvC;AAKD,wBAAgB,sBAAsB,CACpC,OAAO,GAAE,6BAAkC,GAC1C,MAAM,CAgGR"}

package/dist/runtime/api/modules/workspaces/workspaces-router.js

@@ -0,0 +1,71 @@
+import { Router } from "express";
+import { sendError, sendSuccess } from "../../response/index.js";
+import { RESPONSE_CODE_DEFINITIONS } from "../../response/response-codes.js";
+import { getDefaultWorkspacesService } from "./default-workspaces-service.js";
+const DEFAULT_TASK_PAGE_LIMIT = 20;
+const MAX_TASK_PAGE_LIMIT = 100;
+export function createWorkspacesRouter(options = {}) {
+    const router = Router();
+    const getService = () => options.workspacesService ?? getDefaultWorkspacesService();
+    router.get("/workspaces/recent-tasks", (_request, response) => {
+        sendSuccess(response, getService().listRecentWorkspaceTasks());
+    });
+    router.delete("/workspaces/:workspaceId", async (request, response, next) => {
+        try {
+            const result = await getService().deleteWorkspace(request.params.workspaceId);
+            if (result.status === "not_found") {
+                sendError(response, RESPONSE_CODE_DEFINITIONS.notFound, "Unknown workspace");
+                return;
+            }
+            if (result.status === "has_running_tasks") {
+                sendError(response, RESPONSE_CODE_DEFINITIONS.conflict, "Workspace has running tasks");
+                return;
+            }
+            sendSuccess(response, { workspaceId: result.workspaceId });
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    router.get("/workspaces/:workspaceId/tasks", (request, response) => {
+        const afterLastContinuedAt = getStringQuery(request.query.afterLastContinuedAt);
+        if (afterLastContinuedAt === null || !isIsoDateString(afterLastContinuedAt)) {
+            sendError(response, RESPONSE_CODE_DEFINITIONS.badRequest, "afterLastContinuedAt must be an ISO date string");
+            return;
+        }
+        const limit = getLimit(request.query.limit);
+        if (limit === null) {
+            sendError(response, RESPONSE_CODE_DEFINITIONS.badRequest, `limit must be an integer from 1 to ${MAX_TASK_PAGE_LIMIT}`);
+            return;
+        }
+        const result = getService().listWorkspaceTasksAfter({
+            afterLastContinuedAt,
+            limit,
+            workspaceId: request.params.workspaceId
+        });
+        if (!result) {
+            sendError(response, RESPONSE_CODE_DEFINITIONS.notFound, "Unknown workspace");
+            return;
+        }
+        sendSuccess(response, result);
+    });
+    return router;
+}
+function getStringQuery(value) {
+    return typeof value === "string" ? value : null;
+}
+function getLimit(value) {
+    if (value === undefined) {
+        return DEFAULT_TASK_PAGE_LIMIT;
+    }
+    if (typeof value !== "string" || !/^\d+$/.test(value)) {
+        return null;
+    }
+    const parsedLimit = Number(value);
+    return parsedLimit >= 1 && parsedLimit <= MAX_TASK_PAGE_LIMIT
+        ? parsedLimit
+        : null;
+}
+function isIsoDateString(value) {
+    return !Number.isNaN(Date.parse(value));
+}

package/dist/runtime/api/modules/workspaces/workspaces-service.d.ts

@@ -0,0 +1,24 @@
+import type { ActiveTaskRunRegistry } from "../agents/task/active-run-registry";
+import type { RecentWorkspaceTasksResult, WorkspaceTaskPageResult } from "./workspace-types";
+import type { WorkspaceRepository } from "./workspace-repository";
+export interface CreateWorkspacesServiceOptions {
+    activeTaskRuns?: ActiveTaskRunRegistry;
+    now?: () => Date;
+    repository: WorkspaceRepository;
+}
+export interface ListWorkspaceTasksAfterOptions {
+    afterLastContinuedAt: string;
+    limit: number;
+    workspaceId: string;
+}
+export interface WorkspacesService {
+    deleteWorkspace: (workspaceId: string) => Promise<DeleteWorkspaceResult>;
+    listRecentWorkspaceTasks: () => RecentWorkspaceTasksResult;
+    listWorkspaceTasksAfter: (options: ListWorkspaceTasksAfterOptions) => WorkspaceTaskPageResult | undefined;
+}
+export interface DeleteWorkspaceResult {
+    status: "deleted" | "has_running_tasks" | "not_found";
+    workspaceId: string;
+}
+export declare function createWorkspacesService({ activeTaskRuns, now, repository }: CreateWorkspacesServiceOptions): WorkspacesService;
+//# sourceMappingURL=workspaces-service.d.ts.map

package/dist/runtime/api/modules/workspaces/workspaces-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspaces-service.d.ts","sourceRoot":"","sources":["../../../src/modules/workspaces/workspaces-service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAChF,OAAO,KAAK,EACV,0BAA0B,EAE1B,uBAAuB,EAGxB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAElE,MAAM,WAAW,8BAA8B;IAC7C,cAAc,CAAC,EAAE,qBAAqB,CAAC;IACvC,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;IACjB,UAAU,EAAE,mBAAmB,CAAC;CACjC;AAED,MAAM,WAAW,8BAA8B;IAC7C,oBAAoB,EAAE,MAAM,CAAC;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,iBAAiB;IAChC,eAAe,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,qBAAqB,CAAC,CAAC;IACzE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;IAC3D,uBAAuB,EAAE,CACvB,OAAO,EAAE,8BAA8B,KACpC,uBAAuB,GAAG,SAAS,CAAC;CAC1C;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,SAAS,GAAG,mBAAmB,GAAG,WAAW,CAAC;IACtD,WAAW,EAAE,MAAM,CAAC;CACrB;AAKD,wBAAgB,uBAAuB,CAAC,EACtC,cAAc,EACd,GAAsB,EACtB,UAAU,EACX,EAAE,8BAA8B,GAAG,iBAAiB,CAqFpD"}

package/dist/runtime/api/modules/workspaces/workspaces-service.js

@@ -0,0 +1,109 @@
+import { unlink } from "node:fs/promises";
+const RECENT_TASK_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
+const RECENT_TASK_FETCH_LIMIT = 500;
+export function createWorkspacesService({ activeTaskRuns, now = () => new Date(), repository }) {
+    return {
+        deleteWorkspace: async (workspaceId) => {
+            if (!repository.findWorkspaceById(workspaceId)) {
+                return { status: "not_found", workspaceId };
+            }
+            const workspaceTasks = repository.listAllTasksByWorkspaceId(workspaceId);
+            if (workspaceTasks.some((task) => task.status === "running")) {
+                return { status: "has_running_tasks", workspaceId };
+            }
+            await Promise.all(workspaceTasks
+                .map((task) => task.sessionPath)
+                .filter((sessionPath) => Boolean(sessionPath))
+                .map(deleteSessionFile));
+            repository.deleteTasksByWorkspaceId(workspaceId);
+            repository.deleteWorkspaceById(workspaceId);
+            return { status: "deleted", workspaceId };
+        },
+        listRecentWorkspaceTasks: () => {
+            const cutoff = new Date(now().getTime() - RECENT_TASK_WINDOW_MS).toISOString();
+            const workspaceSummaries = sortWorkspacesByCreatedAtDescending(repository.listWorkspaces()).map((workspace) => {
+                const tasks = repository.listTasksByWorkspaceId({
+                    limit: RECENT_TASK_FETCH_LIMIT,
+                    workspaceId: workspace.id
+                });
+                const recentTasks = sortTasksByCreatedAtDescending(tasks.filter((task) => task.lastContinuedAt !== null && task.lastContinuedAt >= cutoff));
+                const summary = {
+                    hasMore: tasks.some((task) => task.lastContinuedAt !== null && task.lastContinuedAt < cutoff),
+                    id: workspace.id,
+                    name: workspace.name,
+                    path: workspace.path,
+                    tasks: recentTasks.map((task) => toTaskSummary(resolveTaskStatus(task, activeTaskRuns, repository, now), activeTaskRuns))
+                };
+                return summary;
+            });
+            return { workspaces: workspaceSummaries };
+        },
+        listWorkspaceTasksAfter: ({ afterLastContinuedAt, limit, workspaceId }) => {
+            if (!repository.findWorkspaceById(workspaceId)) {
+                return undefined;
+            }
+            const tasks = repository.listTasksAfterLastContinuedAt({
+                afterLastContinuedAt,
+                limit: limit + 1,
+                workspaceId
+            });
+            return {
+                hasMore: tasks.length > limit,
+                tasks: tasks
+                    .slice(0, limit)
+                    .map((task) => toTaskSummary(resolveTaskStatus(task, activeTaskRuns, repository, now), activeTaskRuns)),
+                workspaceId
+            };
+        }
+    };
+}
+async function deleteSessionFile(sessionPath) {
+    try {
+        await unlink(sessionPath);
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return;
+        }
+        throw error;
+    }
+}
+function isMissingFileError(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        error.code === "ENOENT");
+}
+function resolveTaskStatus(task, activeTaskRuns, repository, now) {
+    if (task.status !== "running" ||
+        !activeTaskRuns ||
+        activeTaskRuns.hasTask(task.id)) {
+        return task;
+    }
+    return repository.updateTaskStatus(task.id, "error", now().toISOString()) ?? task;
+}
+function toTaskSummary(task, activeTaskRuns) {
+    if (task.lastContinuedAt === null) {
+        throw new Error("Task summary requires lastContinuedAt");
+    }
+    const activeAgentId = activeTaskRuns?.getAgentId(task.id);
+    return {
+        ...(activeAgentId ? { activeAgentId } : {}),
+        approvalPolicy: task.approvalPolicy,
+        id: task.id,
+        initialUserMessage: task.initialUserMessage,
+        lastContinuedAt: task.lastContinuedAt,
+        lastModelId: task.lastModelId,
+        lastModelName: task.lastModelName,
+        lastModelProvider: task.lastModelProvider,
+        lastModelProviderSource: task.lastModelProviderSource,
+        status: task.status,
+        thinkingLevel: task.thinkingLevel,
+        title: task.title
+    };
+}
+function sortTasksByCreatedAtDescending(tasks) {
+    return [...tasks].sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+}
+function sortWorkspacesByCreatedAtDescending(workspaces) {
+    return [...workspaces].sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+}

package/dist/runtime/api/plugin.d.ts

@@ -0,0 +1,5 @@
+import { type RuntimePluginManifest } from "@hold-rein/plugin-server";
+export declare const pluginRegistry: import("@hold-rein/plugin-server").ServerPluginRegistry;
+export declare function bootstrapServerPlugins(pluginRoot: string): Promise<void>;
+export declare function getRuntimeWebPlugins(): readonly RuntimePluginManifest[];
+//# sourceMappingURL=plugin.d.ts.map

package/dist/runtime/api/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAIA,OAAO,EAGL,KAAK,qBAAqB,EAC3B,MAAM,0BAA0B,CAAC;AAElC,eAAO,MAAM,cAAc,yDAA+B,CAAC;AAK3D,wBAAsB,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAY9E;AAED,wBAAgB,oBAAoB,IAAI,SAAS,qBAAqB,EAAE,CAEvE"}

package/dist/runtime/api/plugin.js

@@ -0,0 +1,48 @@
+import { readFileSync, realpathSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createServerPluginRegistry, loadInstalledServerPlugins } from "@hold-rein/plugin-server";
+export const pluginRegistry = createServerPluginRegistry();
+let runtimeWebPlugins = [];
+const apiPackageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+export async function bootstrapServerPlugins(pluginRoot) {
+    const loaded = await loadInstalledServerPlugins({
+        hostNodeModules: join(process.cwd(), "node_modules"),
+        pluginRoot,
+        resolvePackageTarget: resolveRuntimePackageTarget
+    });
+    for (const plugin of loaded.plugins) {
+        registerPluginIfMissing(plugin);
+    }
+    runtimeWebPlugins = loaded.webPlugins;
+}
+export function getRuntimeWebPlugins() {
+    return runtimeWebPlugins;
+}
+function registerPluginIfMissing(plugin) {
+    if (!pluginRegistry.has(plugin.id)) {
+        pluginRegistry.register(plugin);
+    }
+}
+function resolveRuntimePackageTarget(packageName) {
+    let directory = realpathSync(join(apiPackageRoot, "node_modules", ...packageName.split("/")));
+    while (true) {
+        if (hasPackageName(directory, packageName)) {
+            return directory;
+        }
+        const parent = dirname(directory);
+        if (parent === directory) {
+            throw new Error(`Unable to resolve package root for "${packageName}".`);
+        }
+        directory = parent;
+    }
+}
+function hasPackageName(directory, packageName) {
+    try {
+        const packageJson = JSON.parse(readFileSync(join(directory, "package.json"), "utf8"));
+        return packageJson.name === packageName;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/runtime/api/response/api-response.d.ts

@@ -0,0 +1,11 @@
+import type { Response } from "express";
+import { type ResponseCodeDefinition } from "./response-codes";
+export interface ApiResponse<T> {
+    code: number;
+    msg: string;
+    data: T;
+}
+export declare function createApiResponse<T>(definition: ResponseCodeDefinition, data: T, message?: string): ApiResponse<T>;
+export declare function sendSuccess<T>(response: Response, data: T, message?: string): void;
+export declare function sendError(response: Response, definition: ResponseCodeDefinition, message?: string): void;
+//# sourceMappingURL=api-response.d.ts.map

package/dist/runtime/api/response/api-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-response.d.ts","sourceRoot":"","sources":["../../src/response/api-response.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,OAAO,EAEL,KAAK,sBAAsB,EAC5B,MAAM,kBAAkB,CAAC;AAE1B,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,CAAC,CAAC;CACT;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,UAAU,EAAE,sBAAsB,EAClC,IAAI,EAAE,CAAC,EACP,OAAO,SAA4B,GAClC,WAAW,CAAC,CAAC,CAAC,CAMhB;AAED,wBAAgB,WAAW,CAAC,CAAC,EAC3B,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,CAAC,EACP,OAAO,CAAC,EAAE,MAAM,GACf,IAAI,CAIN;AAED,wBAAgB,SAAS,CACvB,QAAQ,EAAE,QAAQ,EAClB,UAAU,EAAE,sBAAsB,EAClC,OAAO,CAAC,EAAE,MAAM,GACf,IAAI,CAIN"}