hivehq 2.0.0

package/dist/src/server/workflow-scheduler.js

@@ -0,0 +1,97 @@
+import { CronExpressionParser } from 'cron-parser';
+const defaultComputeNextRunAt = (cron, after) => {
+    // cron-parser 5.x: `currentDate` is the reference point; `next()` returns
+    // the first strictly-greater fire. UTC by default.
+    const expr = CronExpressionParser.parse(cron, { currentDate: after, tz: 'UTC' });
+    return expr.next().toDate().getTime();
+};
+const DEFAULT_TICK_INTERVAL_MS = 30_000;
+export const createWorkflowScheduler = (deps) => {
+    const computeNext = deps.computeNextRunAt ?? defaultComputeNextRunAt;
+    let timer = null;
+    const scheduler = {
+        async tick(now = Date.now()) {
+            // Experimental gate: while workflows are disabled, hold all scheduled
+            // runs (don't fire, don't advance nextRunAt) so they resume cleanly
+            // once re-enabled.
+            if (deps.isWorkflowEnabled && !deps.isWorkflowEnabled())
+                return;
+            const due = deps.schedules.listDueSchedules(now);
+            for (const schedule of due) {
+                // TIER 1 #4 — self-heal orphan schedules: if a schedule survived a
+                // workspace-delete operation (shouldn't happen after the cascade
+                // fix, but defending against historical orphans), drop it now so
+                // it doesn't error-spam every tick from here forward.
+                if (deps.workspaceExists && !deps.workspaceExists(schedule.workspaceId)) {
+                    console.warn('[hive] workflow-scheduler: deleting orphan schedule', {
+                        scheduleId: schedule.id,
+                        workspaceId: schedule.workspaceId,
+                    });
+                    deps.schedules.deleteSchedule(schedule.id);
+                    continue;
+                }
+                // Compute the next fire BEFORE firing this one so a startWorkflow
+                // exception cannot keep us re-firing the same row each tick.
+                let nextRunAt;
+                try {
+                    nextRunAt = computeNext(schedule.cron, new Date(now));
+                }
+                catch (error) {
+                    console.error('[hive] workflow-scheduler: invalid cron, disabling schedule', {
+                        scheduleId: schedule.id,
+                        cron: schedule.cron,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                    deps.schedules.update(schedule.id, { enabled: false });
+                    continue;
+                }
+                // TIER 1 #5 — compare-and-swap claim. If a previous tick is still
+                // running (slow esbuild / slow startWorkflow / many due schedules
+                // in one tick) and setInterval fires again, both ticks would
+                // otherwise see the same due schedule and fire it twice. CAS on
+                // the original next_run_at means only the first tick wins;
+                // losers see changes=0 and quietly skip.
+                const claimed = deps.schedules.claimDueSchedule({
+                    id: schedule.id,
+                    expectedNextRunAt: schedule.nextRunAt ?? 0,
+                    newNextRunAt: nextRunAt,
+                    lastRunAt: now,
+                });
+                if (!claimed)
+                    continue;
+                try {
+                    await deps.startWorkflow({
+                        workspaceId: schedule.workspaceId,
+                        scriptPath: schedule.scriptPath,
+                        hivePort: deps.getHivePort?.() ?? '',
+                        ...(schedule.args !== undefined && schedule.args !== null
+                            ? { args: schedule.args }
+                            : {}),
+                    });
+                }
+                catch (error) {
+                    console.error('[hive] workflow-scheduler: startWorkflow failed', {
+                        scheduleId: schedule.id,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+        },
+        start({ tickIntervalMs = DEFAULT_TICK_INTERVAL_MS } = {}) {
+            if (timer)
+                clearInterval(timer);
+            timer = setInterval(() => {
+                scheduler.tick().catch((error) => {
+                    console.error('[hive] swallowed:workflow-scheduler.tick', error);
+                });
+            }, tickIntervalMs);
+        },
+        close() {
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+        },
+    };
+    return scheduler;
+};

package/dist/src/server/workflow-script-loader.d.ts

@@ -0,0 +1,34 @@
+export interface WorkflowMeta {
+    name: string;
+    description: string;
+    cron?: string;
+    phases?: Array<{
+        title: string;
+        detail?: string;
+        model?: string;
+    }>;
+    /** TIER 2 #11 — per-script budget overrides. Hard cap on total
+     *  `agent()` calls (default 1000 — matches CC's lifetime cap) and on
+     *  wall-clock duration in ms (default 60 min). Both apply to the
+     *  ENTIRE run including nested workflow() calls; exceeding either
+     *  rejects the offending agent() call and the run transitions to
+     *  'failed' (or 'stopped' if duration was the trigger). */
+    maxAgentCalls?: number;
+    maxDurationMs?: number;
+}
+export interface LoadedWorkflow {
+    meta: WorkflowMeta;
+    scriptPath: string;
+    scriptHash: string;
+    /** Transpiled `async function __wf(...) {…}` — the runner evals it via
+     *  `new Function(source + '; return __wf')()` and calls it with the DSL. */
+    compiledFunctionSource: string;
+}
+interface ExtractedMeta {
+    meta: WorkflowMeta;
+    body: string;
+}
+export declare const extractMeta: (source: string) => ExtractedMeta;
+export declare const loadWorkflowScriptSource: (source: string, scriptPath: string) => Promise<LoadedWorkflow>;
+export declare const loadWorkflowScriptFile: (absPath: string) => Promise<LoadedWorkflow>;
+export {};

package/dist/src/server/workflow-script-loader.js

@@ -0,0 +1,106 @@
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+const DSL_PARAMS = 'agent, parallel, pipeline, phase, log, workflow, args';
+// Find the matching close brace for the object literal whose '{' is at
+// openIndex, ignoring braces inside '...' "..." `...` strings and // /* */
+// comments so they don't miscount the depth.
+const matchBrace = (source, openIndex) => {
+    let depth = 0;
+    let i = openIndex;
+    let str = null;
+    while (i < source.length) {
+        const ch = source[i];
+        const next = source[i + 1];
+        if (str) {
+            if (ch === '\\') {
+                i += 2;
+                continue;
+            }
+            if (ch === str)
+                str = null;
+            i += 1;
+            continue;
+        }
+        if (ch === '/' && next === '/') {
+            const nl = source.indexOf('\n', i);
+            i = nl === -1 ? source.length : nl;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            const end = source.indexOf('*/', i + 2);
+            i = end === -1 ? source.length : end + 2;
+            continue;
+        }
+        if (ch === "'" || ch === '"' || ch === '`') {
+            str = ch;
+            i += 1;
+            continue;
+        }
+        if (ch === '{')
+            depth += 1;
+        else if (ch === '}') {
+            depth -= 1;
+            if (depth === 0)
+                return i;
+        }
+        i += 1;
+    }
+    throw new Error('workflow meta: unbalanced braces in `export const meta`');
+};
+export const extractMeta = (source) => {
+    const re = /export\s+const\s+meta\s*(?::[^=]+)?=\s*\{/;
+    const m = re.exec(source);
+    if (!m) {
+        throw new Error('workflow script must `export const meta = { name, description }`');
+    }
+    const braceStart = source.indexOf('{', m.index + m[0].length - 1);
+    const braceEnd = matchBrace(source, braceStart);
+    const literal = source.slice(braceStart, braceEnd + 1);
+    let meta;
+    try {
+        // meta MUST be a pure literal (no calls/vars); eval it in isolation.
+        meta = new Function(`return (${literal})`)();
+    }
+    catch (error) {
+        throw new Error(`workflow meta is not a plain literal: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!meta || typeof meta.name !== 'string' || !meta.name.trim()) {
+        throw new Error('workflow meta requires a non-empty `name`');
+    }
+    if (typeof meta.description !== 'string') {
+        throw new Error('workflow meta requires a `description`');
+    }
+    let after = braceEnd + 1;
+    const tailMatch = /^(\s*as\s+const)?\s*;?/.exec(source.slice(after));
+    if (tailMatch)
+        after += tailMatch[0].length;
+    const body = source.slice(0, m.index) + source.slice(after);
+    return { meta, body };
+};
+// Module-level cache for esbuild's dynamic import. esbuild's top-level
+// invariant check requires `new TextEncoder().encode('') instanceof
+// Uint8Array` — true in Node, FALSE in jsdom's realm. Workflow runs are not
+// designed to be exercised end-to-end inside a jsdom test environment;
+// jsdom-hosted tests stub the run step at the network layer.
+let esbuildModulePromise = null;
+const loadEsbuild = async () => {
+    if (!esbuildModulePromise)
+        esbuildModulePromise = import('esbuild');
+    return esbuildModulePromise;
+};
+export const loadWorkflowScriptSource = async (source, scriptPath) => {
+    if (/^\s*import\s/m.test(source)) {
+        throw new Error('workflow scripts may not use `import`; use the ambient DSL + inline schemas');
+    }
+    const { meta, body } = extractMeta(source);
+    const wrapped = `async function __wf(${DSL_PARAMS}) {\n${body}\n}`;
+    // Lazy-load esbuild: its native binary breaks under jsdom/worker contexts
+    // used by the web test suite, so importing it at module-load time would
+    // crash any test file that transitively pulls in the runtime store. The
+    // transpile path is only reached when a workflow actually runs.
+    const { transform } = await loadEsbuild();
+    const { code } = await transform(wrapped, { loader: 'ts', target: 'es2022' });
+    const scriptHash = createHash('sha256').update(code).digest('hex');
+    return { meta, scriptPath, scriptHash, compiledFunctionSource: code };
+};
+export const loadWorkflowScriptFile = async (absPath) => loadWorkflowScriptSource(await readFile(absPath, 'utf8'), absPath);

package/dist/src/server/workspace-path-validation.d.ts

@@ -0,0 +1 @@
+export declare const validateWorkspacePath: (path: unknown) => string;

package/dist/src/server/workspace-path-validation.js

@@ -0,0 +1,42 @@
+import { statSync } from 'node:fs';
+import { sanitizePastedPath } from '../shared/path-input.js';
+import { BadRequestError } from './http-errors.js';
+import { realpathNative } from './path-canonicalization.js';
+export const validateWorkspacePath = (path) => {
+    if (typeof path !== 'string') {
+        throw new BadRequestError('Workspace path is required');
+    }
+    const candidate = sanitizePastedPath(path);
+    if (candidate.length === 0) {
+        throw new BadRequestError('Workspace path is required');
+    }
+    let resolved;
+    try {
+        resolved = realpathNative(candidate);
+    }
+    catch (error) {
+        const code = error?.code;
+        if (code === 'EACCES' || code === 'EPERM') {
+            throw new BadRequestError(`Workspace path is not accessible: ${candidate}`);
+        }
+        if (code === 'ENAMETOOLONG') {
+            throw new BadRequestError(`Workspace path is too long: ${candidate}`);
+        }
+        throw new BadRequestError(`Workspace path does not exist: ${candidate}`);
+    }
+    let stat;
+    try {
+        stat = statSync(resolved);
+    }
+    catch (error) {
+        const code = error?.code;
+        if (code === 'EACCES' || code === 'EPERM') {
+            throw new BadRequestError(`Workspace path is not accessible: ${candidate}`);
+        }
+        throw new BadRequestError(`Workspace path does not exist: ${candidate}`);
+    }
+    if (!stat.isDirectory()) {
+        throw new BadRequestError(`Workspace path is not a directory: ${candidate}`);
+    }
+    return resolved;
+};

package/dist/src/server/workspace-shell-runtime.d.ts

@@ -0,0 +1,35 @@
+import type { WorkspaceSummary } from '../shared/types.js';
+import type { AgentManager } from './agent-manager.js';
+import type { LiveAgentRun } from './agent-runtime-types.js';
+export declare const getWorkspaceShellAgentId: (workspaceId: string) => string;
+export declare const isWorkspaceShellAgentId: (agentId: string) => boolean;
+export declare const resolveWorkspaceShellLaunch: (env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform) => {
+    args: string[];
+    command: string;
+};
+export declare const resolveWorkspaceShellStart: (workspacePath: string, env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform) => {
+    args: string[];
+    command: string;
+    cwd: string;
+};
+export declare const createWorkspaceShellRuntime: (agentManager: AgentManager | undefined) => {
+    close(): void;
+    closeRun(workspaceId: string, runId: string): boolean;
+    deleteWorkspace(workspaceId: string): void;
+    getLiveRun(runId: string): LiveAgentRun | undefined;
+    hasRun: (runId: string) => boolean;
+    listTerminalRuns(workspaceId: string): {
+        agent_id: string;
+        agent_name: string;
+        run_id: string;
+        status: import("./agent-manager.js").RunStatus;
+        terminal_input_profile: "default";
+    }[];
+    pauseRun(runId: string): void;
+    resizeRun(runId: string, cols: number, rows: number): void;
+    resumeRun(runId: string): void;
+    start(workspace: WorkspaceSummary): Promise<LiveAgentRun>;
+    stopRun(runId: string): void;
+    writeInput(runId: string, input: Buffer | string): void;
+};
+export type WorkspaceShellRuntime = ReturnType<typeof createWorkspaceShellRuntime>;

package/dist/src/server/workspace-shell-runtime.js

@@ -0,0 +1,228 @@
+import { basename } from 'node:path';
+import { escapeCmdToken } from './windows-command-line.js';
+const WORKSPACE_SHELL_SUFFIX = ':shell';
+const WORKSPACE_SHELL_LABEL = 'Shell';
+const EXITED_SHELL_RETENTION_MS = 5000;
+export const getWorkspaceShellAgentId = (workspaceId) => `${workspaceId}${WORKSPACE_SHELL_SUFFIX}`;
+export const isWorkspaceShellAgentId = (agentId) => agentId.endsWith(WORKSPACE_SHELL_SUFFIX);
+const shouldUseLoginShell = (command) => {
+    const name = basename(command).toLowerCase();
+    return name === 'bash' || name === 'fish' || name === 'ksh' || name === 'zsh';
+};
+const getEnvValue = (env, key, platform) => {
+    if (platform !== 'win32')
+        return env[key];
+    const matched = Object.keys(env).find((item) => item.toLowerCase() === key.toLowerCase());
+    return matched ? env[matched] : undefined;
+};
+export const resolveWorkspaceShellLaunch = (env = process.env, platform = process.platform) => {
+    if (platform === 'win32')
+        return { command: getEnvValue(env, 'ComSpec', platform) ?? 'cmd.exe', args: [] };
+    const command = env.SHELL || '/bin/sh';
+    return { command, args: shouldUseLoginShell(command) ? ['-l'] : [] };
+};
+const isWindowsUncPath = (path, platform = process.platform) => platform === 'win32' && /^[\\/]{2}[^\\/]+[\\/]+[^\\/]+/u.test(path);
+const getWindowsSafeShellCwd = (env = process.env) => {
+    const systemRoot = getEnvValue(env, 'SystemRoot', 'win32');
+    if (systemRoot)
+        return systemRoot;
+    const systemDrive = getEnvValue(env, 'SystemDrive', 'win32');
+    if (systemDrive)
+        return `${systemDrive}\\`;
+    return process.cwd();
+};
+export const resolveWorkspaceShellStart = (workspacePath, env = process.env, platform = process.platform) => {
+    const launch = resolveWorkspaceShellLaunch(env, platform);
+    if (isWindowsUncPath(workspacePath, platform)) {
+        return {
+            args: ['/d', '/s', '/k', `pushd ${escapeCmdToken(workspacePath)}`],
+            command: launch.command,
+            cwd: getWindowsSafeShellCwd(env),
+        };
+    }
+    return { ...launch, cwd: workspacePath };
+};
+export const createWorkspaceShellRuntime = (agentManager) => {
+    const labelsByRunId = new Map();
+    const workspaceIdsByRunId = new Map();
+    const runIdsByWorkspaceId = new Map();
+    const startedAtByRunId = new Map();
+    const exitCleanupTimersByRunId = new Map();
+    const requireManager = () => {
+        if (!agentManager)
+            throw new Error('Agent manager is required for workspace shell terminals');
+        return agentManager;
+    };
+    const hasRun = (runId) => workspaceIdsByRunId.has(runId);
+    const toLiveRun = (runId) => {
+        try {
+            return {
+                ...requireManager().getRun(runId),
+                startedAt: startedAtByRunId.get(runId) ?? Date.now(),
+            };
+        }
+        catch (error) {
+            detachRun(runId);
+            throw error;
+        }
+    };
+    const detachRun = (runId) => {
+        const exitCleanupTimer = exitCleanupTimersByRunId.get(runId);
+        if (exitCleanupTimer)
+            clearTimeout(exitCleanupTimer);
+        exitCleanupTimersByRunId.delete(runId);
+        const workspaceId = workspaceIdsByRunId.get(runId);
+        if (workspaceId) {
+            const retained = (runIdsByWorkspaceId.get(workspaceId) ?? []).filter((id) => id !== runId);
+            if (retained.length > 0)
+                runIdsByWorkspaceId.set(workspaceId, retained);
+            else
+                runIdsByWorkspaceId.delete(workspaceId);
+        }
+        labelsByRunId.delete(runId);
+        workspaceIdsByRunId.delete(runId);
+        startedAtByRunId.delete(runId);
+    };
+    const attachRun = (workspaceId, runId, label, startedAt) => {
+        labelsByRunId.set(runId, label);
+        workspaceIdsByRunId.set(runId, workspaceId);
+        startedAtByRunId.set(runId, startedAt);
+        runIdsByWorkspaceId.set(workspaceId, [...(runIdsByWorkspaceId.get(workspaceId) ?? []), runId]);
+    };
+    const forgetShellRun = (runId) => {
+        detachRun(runId);
+        try {
+            requireManager().removeRun(runId);
+        }
+        catch {
+            // The PTY manager may have already dropped the run.
+        }
+    };
+    const handleShellExit = (runId) => {
+        if (!hasRun(runId) || exitCleanupTimersByRunId.has(runId))
+            return;
+        const timer = setTimeout(() => {
+            exitCleanupTimersByRunId.delete(runId);
+            if (hasRun(runId))
+                forgetShellRun(runId);
+        }, EXITED_SHELL_RETENTION_MS);
+        timer.unref?.();
+        exitCleanupTimersByRunId.set(runId, timer);
+    };
+    const isListedRun = (run) => run.status === 'starting' || run.status === 'running';
+    const stopPtyRun = (runId) => {
+        requireManager().stopRun(runId);
+    };
+    const closeRun = (runId) => {
+        try {
+            stopPtyRun(runId);
+        }
+        catch {
+            // The shell may have already exited or been removed by the PTY manager.
+        }
+        try {
+            requireManager().removeRun(runId);
+        }
+        catch {
+            // The PTY manager may have already dropped the run.
+        }
+        detachRun(runId);
+    };
+    return {
+        close() {
+            for (const runId of Array.from(workspaceIdsByRunId.keys()))
+                closeRun(runId);
+            runIdsByWorkspaceId.clear();
+            workspaceIdsByRunId.clear();
+            startedAtByRunId.clear();
+            labelsByRunId.clear();
+            for (const timer of exitCleanupTimersByRunId.values())
+                clearTimeout(timer);
+            exitCleanupTimersByRunId.clear();
+        },
+        closeRun(workspaceId, runId) {
+            if (workspaceIdsByRunId.get(runId) !== workspaceId)
+                return false;
+            closeRun(runId);
+            return true;
+        },
+        deleteWorkspace(workspaceId) {
+            for (const runId of Array.from(runIdsByWorkspaceId.get(workspaceId) ?? [])) {
+                try {
+                    closeRun(runId);
+                }
+                catch {
+                    // Workspace deletion should not fail because the shell already exited.
+                }
+            }
+            runIdsByWorkspaceId.delete(workspaceId);
+        },
+        getLiveRun(runId) {
+            if (!hasRun(runId))
+                return undefined;
+            return toLiveRun(runId);
+        },
+        hasRun,
+        listTerminalRuns(workspaceId) {
+            return (runIdsByWorkspaceId.get(workspaceId) ?? []).flatMap((runId) => {
+                try {
+                    const run = toLiveRun(runId);
+                    if (!isListedRun(run))
+                        return [];
+                    return [
+                        {
+                            agent_id: getWorkspaceShellAgentId(workspaceId),
+                            agent_name: labelsByRunId.get(runId) ?? 'Shell',
+                            run_id: run.runId,
+                            status: run.status,
+                            terminal_input_profile: 'default',
+                        },
+                    ];
+                }
+                catch {
+                    return [];
+                }
+            });
+        },
+        pauseRun(runId) {
+            if (hasRun(runId))
+                requireManager().pauseRun(runId);
+        },
+        resizeRun(runId, cols, rows) {
+            if (hasRun(runId))
+                requireManager().resizeRun(runId, cols, rows);
+        },
+        resumeRun(runId) {
+            if (hasRun(runId))
+                requireManager().resumeRun(runId);
+        },
+        async start(workspace) {
+            const startedAt = Date.now();
+            const launch = resolveWorkspaceShellStart(workspace.path);
+            const run = await requireManager().startAgent({
+                agentId: getWorkspaceShellAgentId(workspace.id),
+                args: launch.args,
+                command: launch.command,
+                cwd: launch.cwd,
+                env: {
+                    COLORTERM: 'truecolor',
+                    FORCE_COLOR: '1',
+                    NO_COLOR: undefined,
+                    TERM: 'xterm-256color',
+                    TERM_PROGRAM: 'hive-shell',
+                },
+                onExit: ({ runId }) => handleShellExit(runId),
+            });
+            attachRun(workspace.id, run.runId, WORKSPACE_SHELL_LABEL, startedAt);
+            return { ...run, startedAt };
+        },
+        stopRun(runId) {
+            if (hasRun(runId))
+                stopPtyRun(runId);
+        },
+        writeInput(runId, input) {
+            if (hasRun(runId))
+                requireManager().writeInput(runId, input);
+        },
+    };
+};

package/dist/src/server/workspace-store-contract.d.ts

@@ -0,0 +1,32 @@
+import type { AgentSummary, TeamListItem, WorkerRole, WorkerSpawnSource, WorkspaceSummary } from '../shared/types.js';
+export interface WorkspaceRecord {
+    summary: WorkspaceSummary;
+    agents: AgentSummary[];
+}
+export interface WorkerInput {
+    description?: string;
+    name: string;
+    role: WorkerRole;
+    ephemeral?: boolean;
+    spawnedBy?: WorkerSpawnSource;
+}
+export interface WorkspaceStore {
+    addWorker: (workspaceId: string, input: WorkerInput) => AgentSummary;
+    createWorkspace: (path: string, name: string) => WorkspaceSummary;
+    deleteWorkspace: (workspaceId: string) => void;
+    deleteWorker: (workspaceId: string, workerId: string) => void;
+    renameWorker: (workspaceId: string, workerId: string, name: string) => AgentSummary;
+    getAgent: (workspaceId: string, agentId: string) => AgentSummary;
+    getWorker: (workspaceId: string, workerId: string) => AgentSummary;
+    getWorkerByName: (workspaceId: string, workerName: string) => AgentSummary;
+    getWorkspaceSnapshot: (workspaceId: string) => WorkspaceRecord;
+    hasAgent: (workspaceId: string, agentId: string) => boolean;
+    hasWorkspace: (workspaceId: string) => boolean;
+    listWorkers: (workspaceId: string) => TeamListItem[];
+    listWorkspaces: () => WorkspaceSummary[];
+    markAgentStarted: (workspaceId: string, agentId: string) => void;
+    markAgentStopped: (workspaceId: string, agentId: string) => void;
+    markTaskDispatched: (workspaceId: string, workerId: string) => void;
+    markTaskCancelled: (workspaceId: string, workerId: string) => void;
+    markTaskReported: (workspaceId: string, workerId: string) => void;
+}

package/dist/src/server/workspace-store-contract.js

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

package/dist/src/server/workspace-store-hydration.d.ts

@@ -0,0 +1,5 @@
+import type { Database } from 'better-sqlite3';
+import type { WorkspaceRecord } from './workspace-store-contract.js';
+import { type MessageKindRecord } from './workspace-store-support.js';
+export declare const hydrateWorkspaceFromDb: (db: Database, workspaces: Map<string, WorkspaceRecord>, messageKinds: MessageKindRecord[], workspaceId: string) => void;
+export declare const seedWorkspacesFromDb: (db: Database, workspaces: Map<string, WorkspaceRecord>, messageKinds: MessageKindRecord[]) => void;

package/dist/src/server/workspace-store-hydration.js

@@ -0,0 +1,76 @@
+import { getDefaultRoleDescription } from './role-templates.js';
+import { applyPendingTaskCount, createOrchestrator, createWorkflowAgent, isWorkerAgent, } from './workspace-store-support.js';
+const createWorkerSummary = (workspaceId, row) => ({
+    id: row.id,
+    workspaceId,
+    name: row.name,
+    description: row.description ?? getDefaultRoleDescription(row.role),
+    role: row.role,
+    status: 'stopped',
+    pendingTaskCount: 0,
+    ephemeral: row.ephemeral === 1,
+    spawnedBy: row.spawned_by ?? null,
+});
+/**
+ * Build the worker SELECT defensively. The global runtime data dir
+ * (`~/.config/hive`) is shared across every Hive install on the machine, so a
+ * DB may have been migrated forward by a NEWER Hive whose `schema_version`
+ * already lists 19+. In that case our own v19 ALTER is skipped and the
+ * `workers` table can lack `ephemeral`/`spawned_by`. Selecting a non-existent
+ * column throws and crashes startup, so we only request the optional columns
+ * when they actually exist; `createWorkerSummary` defaults them otherwise.
+ */
+const buildWorkerSelect = (db, whereClause) => {
+    const present = new Set(db.prepare('PRAGMA table_info(workers)').all().map((c) => c.name));
+    const optional = ['ephemeral', 'spawned_by'].filter((column) => present.has(column));
+    const columns = ['id', 'workspace_id', 'name', 'description', 'role', ...optional].join(', ');
+    const where = whereClause ? `${whereClause} ` : '';
+    return `SELECT ${columns} FROM workers ${where}ORDER BY created_at ASC`;
+};
+const applyMessageKinds = (workspaces, messageKinds, workspaceId) => {
+    for (const row of messageKinds) {
+        if (workspaceId && row.workspace_id !== workspaceId) {
+            continue;
+        }
+        const worker = workspaces
+            .get(row.workspace_id)
+            ?.agents.find((agent) => agent.id === row.worker_id);
+        if (!worker || !isWorkerAgent(worker)) {
+            continue;
+        }
+        applyPendingTaskCount(worker, row.type, true);
+    }
+};
+export const hydrateWorkspaceFromDb = (db, workspaces, messageKinds, workspaceId) => {
+    if (workspaces.has(workspaceId)) {
+        return;
+    }
+    const row = db.prepare('SELECT id, name, path FROM workspaces WHERE id = ?').get(workspaceId);
+    if (!row) {
+        return;
+    }
+    workspaces.set(row.id, {
+        summary: { id: row.id, name: row.name, path: row.path },
+        agents: [createOrchestrator(row.id), createWorkflowAgent(row.id)],
+    });
+    for (const workerRow of db
+        .prepare(buildWorkerSelect(db, 'WHERE workspace_id = ?'))
+        .all(workspaceId)) {
+        workspaces.get(workspaceId)?.agents.push(createWorkerSummary(workerRow.workspace_id, workerRow));
+    }
+    applyMessageKinds(workspaces, messageKinds, workspaceId);
+};
+export const seedWorkspacesFromDb = (db, workspaces, messageKinds) => {
+    for (const row of db
+        .prepare('SELECT id, name, path FROM workspaces ORDER BY created_at ASC')
+        .all()) {
+        workspaces.set(row.id, {
+            summary: { id: row.id, name: row.name, path: row.path },
+            agents: [createOrchestrator(row.id), createWorkflowAgent(row.id)],
+        });
+    }
+    for (const row of db.prepare(buildWorkerSelect(db, '')).all()) {
+        workspaces.get(row.workspace_id)?.agents.push(createWorkerSummary(row.workspace_id, row));
+    }
+    applyMessageKinds(workspaces, messageKinds);
+};