hivehq 2.0.0

package/dist/src/server/runtime-store.js

@@ -0,0 +1,165 @@
+import { createRuntimeStoreDreamMethods } from './runtime-store-dream.js';
+import { createRuntimeStoreLifecycle, createRuntimeStoreServices, logTasksFileWatchStartError, } from './runtime-store-helpers.js';
+import { createRuntimeStoreMemoryMethods } from './runtime-store-memory.js';
+import { createRuntimeStoreRemoteMethods } from './runtime-store-remote.js';
+import { createRuntimeStoreWorkflowRuntime } from './runtime-store-workflows.js';
+import { persistWorkflowSchedule } from './workflow-schedule-create.js';
+export const createRuntimeStore = (options = {}) => {
+    const services = createRuntimeStoreServices(options);
+    const lifecycle = createRuntimeStoreLifecycle(options.agentManager ? { agentManager: options.agentManager, services } : { services });
+    const runDataMutation = (mutation) => {
+        if (!services.db) {
+            mutation();
+            return;
+        }
+        services.db.transaction(mutation)();
+    };
+    let workflowRuntime;
+    const getWorkflowRuntime = () => {
+        if (!workflowRuntime)
+            throw new Error('Workflow runtime not initialized');
+        return workflowRuntime;
+    };
+    const store = {
+        close: async () => {
+            workflowRuntime?.scheduler.close();
+            await services.teamMemoryDreamScheduler.close();
+            await lifecycle.close();
+        },
+        createWorkspace: (path, name) => {
+            const workspace = services.workspaceStore.createWorkspace(path, name);
+            void lifecycle
+                .startWorkspaceWatch(workspace.id)
+                .catch((error) => logTasksFileWatchStartError(workspace.id, error));
+            return workspace;
+        },
+        listWorkspaces: () => services.workspaceStore.listWorkspaces(),
+        deleteWorkspace: async (workspaceId) => {
+            const workspace = services.workspaceStore.getWorkspaceSnapshot(workspaceId);
+            lifecycle.deleteWorkspaceShell(workspaceId);
+            for (const agent of workspace.agents) {
+                const activeRun = services.agentRuntime.getActiveRunByAgentId(workspaceId, agent.id);
+                if (activeRun)
+                    services.agentRuntime.stopAgentRun(activeRun.runId);
+                services.agentRuntime.deleteAgentLaunchConfig(workspaceId, agent.id);
+            }
+            await services.tasksFileWatcher.stop(workspaceId);
+            services.teamMemoryExport.cancel(workspaceId);
+            runDataMutation(() => {
+                services.dispatchLedgerStore.deleteWorkspaceDispatches(workspaceId);
+                services.teamMemoryStore.deleteWorkspaceMemories(workspaceId);
+                services.teamMemoryDreamStore.deleteWorkspaceDreamRuns(workspaceId);
+                services.workspaceStore.deleteWorkspace(workspaceId);
+            });
+            if (services.settings.getAppState('active_workspace_id')?.value === workspaceId) {
+                services.settings.setAppState('active_workspace_id', null);
+            }
+        },
+        addWorker: (workspaceId, input) => services.workspaceStore.addWorker(workspaceId, input),
+        addWorkerWithLaunch: (workspaceId, input, launchConfig) => {
+            // Atomic spawn: create the worker AND its launch config together so a
+            // failure can never persist a worker with no way to start it. The DB
+            // transaction rolls back the row; the catch prunes the in-memory worker
+            // that addWorker already pushed into the workspace record.
+            let worker;
+            try {
+                runDataMutation(() => {
+                    worker = store.addWorker(workspaceId, input);
+                    store.configureAgentLaunch(workspaceId, worker.id, launchConfig);
+                });
+            }
+            catch (error) {
+                if (worker) {
+                    try {
+                        store.deleteWorker(workspaceId, worker.id);
+                    }
+                    catch {
+                        // The transaction already removed the DB row; this only prunes the
+                        // stale in-memory entry, which may already be gone.
+                    }
+                }
+                throw error;
+            }
+            if (!worker)
+                throw new Error('addWorkerWithLaunch produced no worker');
+            return worker;
+        },
+        renameWorker: (workspaceId, workerId, name) => services.workspaceStore.renameWorker(workspaceId, workerId, name),
+        deleteWorker: (workspaceId, workerId) => {
+            const activeRun = services.agentRuntime.getActiveRunByAgentId(workspaceId, workerId);
+            runDataMutation(() => {
+                services.dispatchLedgerStore.deleteWorkerDispatches(workspaceId, workerId);
+                services.workspaceStore.deleteWorker(workspaceId, workerId);
+            });
+            services.agentRuntime.deleteAgentLaunchConfig(workspaceId, workerId);
+            if (activeRun)
+                services.agentRuntime.stopAgentRun(activeRun.runId);
+        },
+        recordUserInput: services.teamOps.recordUserInput,
+        cancelTask: services.teamOps.cancelTask,
+        dispatchTask: services.teamOps.dispatchTask,
+        dispatchTaskByWorkerName: services.teamOps.dispatchTaskByWorkerName,
+        reportTask: services.teamOps.reportTask,
+        drainReportOutbox: services.teamOps.drainReportOutbox,
+        statusTask: services.teamOps.statusTask,
+        listDispatches: services.dispatchLedgerStore.listWorkspaceDispatches,
+        listWorkers: (workspaceId) => services.workspaceStore.listWorkers(workspaceId),
+        getLastPtyLineForAgent: (workspaceId, agentId) => services.workerOutputTracker?.getLastPtyLine(workspaceId, agentId) ?? null,
+        getWorkspaceSnapshot: (workspaceId) => services.workspaceStore.getWorkspaceSnapshot(workspaceId),
+        getWorker: (workspaceId, workerId) => services.workspaceStore.getWorker(workspaceId, workerId),
+        getAgent: (workspaceId, agentId) => services.workspaceStore.getAgent(workspaceId, agentId),
+        getPtyOutputBus: lifecycle.getPtyOutputBus,
+        listTerminalRuns: lifecycle.listTerminalRuns,
+        closeWorkspaceShell: lifecycle.closeWorkspaceShell,
+        configureAgentLaunch: lifecycle.configureAgentLaunch,
+        peekAgentLaunchConfig: lifecycle.peekAgentLaunchConfig,
+        startAgent: lifecycle.startAgent,
+        autostartConfiguredAgents: lifecycle.autostartConfiguredAgents,
+        startWorkspaceWatch: lifecycle.startWorkspaceWatch,
+        startWorkspaceShell: lifecycle.startWorkspaceShell,
+        getLiveRun: lifecycle.getLiveRun,
+        getActiveRunByAgentId: (workspaceId, agentId) => services.agentRuntime.getActiveRunByAgentId(workspaceId, agentId),
+        registerTasksListener: lifecycle.registerTasksListener,
+        listAgentRuns: (agentId) => services.agentRuntime.listAgentRuns(agentId),
+        listMessagesForRecovery: (workspaceId, sinceMs) => services.messageLogStore.listMessagesForRecovery(workspaceId, sinceMs),
+        recallMessages: (workspaceId, query, options) => services.teamRecallStore.recallMessages(workspaceId, query, options),
+        ...createRuntimeStoreMemoryMethods(services),
+        ...createRuntimeStoreDreamMethods(services),
+        peekAgentToken: (agentId) => services.agentRuntime.peekAgentToken(agentId),
+        pauseTerminalRun: lifecycle.pauseTerminalRun,
+        resizeAgentRun: lifecycle.resizeTerminalRun,
+        resumeTerminalRun: lifecycle.resumeTerminalRun,
+        settings: services.settings,
+        writeRunInput: lifecycle.writeRunInput,
+        getUiToken: () => services.uiAuth.getToken(),
+        stopAgentRun: lifecycle.stopTerminalRun,
+        validateAgentToken: (agentId, token) => services.agentRuntime.validateAgentToken(agentId, token),
+        validateUiToken: (token) => services.uiAuth.validate(token),
+        ...createRuntimeStoreRemoteMethods(services),
+        getWorkflowDispatchAwaiter: () => services.workflowDispatchAwaiter,
+        runWorkflow: (input) => getWorkflowRuntime().runner.runWorkflow(input),
+        startWorkflow: (input) => getWorkflowRuntime().runner.startWorkflow(input),
+        startWorkflowInline: (input) => getWorkflowRuntime().runner.startWorkflowInline(input),
+        stopWorkflowRun: (runId) => getWorkflowRuntime().runner.stopRun(runId),
+        getWorkflowRun: (runId) => services.workflowRunStore.getRun(runId),
+        listWorkspaceWorkflowRuns: (workspaceId) => services.workflowRunStore.listWorkspaceRuns(workspaceId),
+        listWorkflowRunDispatches: (runId) => services.dispatchLedgerStore.listWorkflowRunDispatches(runId),
+        listWorkflowRunLogs: (runId) => services.workflowRunLogStore.listForRun(runId).map((row) => ({
+            id: row.id,
+            ts: row.ts,
+            message: row.message,
+        })),
+        createWorkflowSchedule: (input) => services.workflowScheduleStore.create(input),
+        scheduleWorkflowInline: (input) => persistWorkflowSchedule({
+            workspacePath: services.workspaceStore.getWorkspaceSnapshot(input.workspaceId).summary.path,
+            scheduleStore: services.workflowScheduleStore,
+            ...input,
+        }),
+        updateWorkflowSchedule: (id, input) => services.workflowScheduleStore.update(id, input),
+        getWorkflowSchedule: (id) => services.workflowScheduleStore.get(id),
+        listWorkspaceWorkflowSchedules: (workspaceId) => services.workflowScheduleStore.listForWorkspace(workspaceId),
+        deleteWorkflowSchedule: (id) => services.workflowScheduleStore.deleteSchedule(id),
+    };
+    workflowRuntime = createRuntimeStoreWorkflowRuntime(services, store);
+    return store;
+};

package/dist/src/server/session-capture-claude.d.ts

@@ -0,0 +1,34 @@
+export declare const getClaudeProjectsRoot: (pattern?: string, platform?: NodeJS.Platform) => string;
+/**
+ * Match the directory-name encoding Claude Code itself uses for its project
+ * metadata under `~/.claude/projects/`. Empirically (probed via `claude
+ * --print "x"` in directories named with each character) Claude Code
+ * replaces *every* character outside `[A-Za-z0-9-]` with a single `-`,
+ * one-for-one, preserving literal hyphens.
+ *
+ * The previous regex `[\\/:\s]` only matched `\`, `/`, `:`, and whitespace —
+ * leaving `_`, `.`, parens, brackets, `@`, `#`, `&`, `+`, and any non-ASCII
+ * character (including CJK usernames) intact, while Claude Code's own
+ * encoder replaced them. The mismatch meant Hive looked for sessions under
+ * a different directory than the one Claude Code wrote to, so session
+ * resume silently failed for any workspace path containing those chars.
+ * Windows + CJK Windows usernames (`C:\Users\张三\project`) and
+ * underscored Windows project paths (`C:\my_project`) are the most common
+ * triggers, but the bug is cross-platform.
+ *
+ * Backward compatibility: workspaces whose path contains ONLY chars that
+ * the old regex already matched (`/\:` + whitespace) get the same encoded
+ * dirname as before — no behavior change. Workspaces with any other
+ * special chars previously had broken session resume; the fix moves them
+ * to the correct (working) directory.
+ */
+export declare const encodeClaudeProjectPath: (cwd: string) => string;
+interface ClaudeSessionCaptureDiscriminator {
+    contentIncludes?: string | readonly string[];
+}
+export declare const getClaudeSessionFilePath: (cwd: string, sessionId: string, pattern?: string) => string;
+export declare const hasClaudeSessionFile: (cwd: string, sessionId: string, pattern?: string, discriminator?: ClaudeSessionCaptureDiscriminator) => boolean;
+export declare const captureClaudeSessionId: (cwd: string, knownSessionIds: Set<string>, onCapture: (sessionId: string) => void, timeoutMs?: number, intervalMs?: number, projectsRoot?: string, discriminator?: ClaudeSessionCaptureDiscriminator) => Promise<void>;
+export declare const snapshotClaudeSessionIds: (cwd: string, projectsRoot?: string) => Set<string>;
+export declare const resetClaudeSessionClaimsForTests: () => void;
+export {};

package/dist/src/server/session-capture-claude.js

@@ -0,0 +1,103 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { captureSessionIdWithCoordinator, resetSessionCaptureCoordinatorForTests, } from './claude-session-coordinator.js';
+import { arePathsEqual, expandHomePath } from './platform-path.js';
+const SESSION_FILE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.jsonl$/i;
+const getDefaultProjectsRoot = () => process.env.HIVE_CLAUDE_PROJECTS_DIR ?? join(homedir(), '.claude/projects');
+export const getClaudeProjectsRoot = (pattern, platform = process.platform) => {
+    if (!pattern)
+        return getDefaultProjectsRoot();
+    const markerIndex = pattern.indexOf('{encoded_cwd}');
+    if (markerIndex === -1)
+        return getDefaultProjectsRoot();
+    const root = pattern.slice(0, markerIndex).replace(/[\\/]+$/, '');
+    if (!root)
+        return getDefaultProjectsRoot();
+    const builtInProjectsRoot = join(homedir(), '.claude', 'projects');
+    const expandedRoot = expandHomePath(root);
+    if (root === '~' || arePathsEqual(expandedRoot, builtInProjectsRoot, platform)) {
+        return getDefaultProjectsRoot();
+    }
+    return expandedRoot;
+};
+/**
+ * Match the directory-name encoding Claude Code itself uses for its project
+ * metadata under `~/.claude/projects/`. Empirically (probed via `claude
+ * --print "x"` in directories named with each character) Claude Code
+ * replaces *every* character outside `[A-Za-z0-9-]` with a single `-`,
+ * one-for-one, preserving literal hyphens.
+ *
+ * The previous regex `[\\/:\s]` only matched `\`, `/`, `:`, and whitespace —
+ * leaving `_`, `.`, parens, brackets, `@`, `#`, `&`, `+`, and any non-ASCII
+ * character (including CJK usernames) intact, while Claude Code's own
+ * encoder replaced them. The mismatch meant Hive looked for sessions under
+ * a different directory than the one Claude Code wrote to, so session
+ * resume silently failed for any workspace path containing those chars.
+ * Windows + CJK Windows usernames (`C:\Users\张三\project`) and
+ * underscored Windows project paths (`C:\my_project`) are the most common
+ * triggers, but the bug is cross-platform.
+ *
+ * Backward compatibility: workspaces whose path contains ONLY chars that
+ * the old regex already matched (`/\:` + whitespace) get the same encoded
+ * dirname as before — no behavior change. Workspaces with any other
+ * special chars previously had broken session resume; the fix moves them
+ * to the correct (working) directory.
+ */
+export const encodeClaudeProjectPath = (cwd) => cwd.replace(/[^A-Za-z0-9-]/g, '-');
+const listSessionIds = (cwd, projectsRoot = getDefaultProjectsRoot()) => {
+    const projectDir = join(projectsRoot, encodeClaudeProjectPath(cwd));
+    try {
+        return readdirSync(projectDir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && SESSION_FILE.test(entry.name))
+            .map((entry) => entry.name.replace(/\.jsonl$/i, ''))
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        return [];
+    }
+};
+const includesAny = (content, needles) => {
+    const normalizedNeedles = Array.isArray(needles) ? needles : [needles];
+    return normalizedNeedles.some((needle) => content.includes(needle));
+};
+const sessionFileContainsAny = (cwd, projectsRoot, sessionId, contentIncludes) => {
+    try {
+        const content = readFileSync(join(projectsRoot, encodeClaudeProjectPath(cwd), `${sessionId}.jsonl`), 'utf8');
+        return includesAny(content, contentIncludes);
+    }
+    catch {
+        return false;
+    }
+};
+export const getClaudeSessionFilePath = (cwd, sessionId, pattern) => join(getClaudeProjectsRoot(pattern), encodeClaudeProjectPath(cwd), `${sessionId}.jsonl`);
+export const hasClaudeSessionFile = (cwd, sessionId, pattern, discriminator = {}) => {
+    if (!SESSION_FILE.test(`${sessionId}.jsonl`) ||
+        !existsSync(getClaudeSessionFilePath(cwd, sessionId, pattern))) {
+        return false;
+    }
+    const projectsRoot = getClaudeProjectsRoot(pattern);
+    return discriminator.contentIncludes
+        ? sessionFileContainsAny(cwd, projectsRoot, sessionId, discriminator.contentIncludes)
+        : true;
+};
+export const captureClaudeSessionId = async (cwd, knownSessionIds, onCapture, timeoutMs = 5000, intervalMs = 100, projectsRoot = getDefaultProjectsRoot(), discriminator = {}) => {
+    const contentIncludes = discriminator.contentIncludes;
+    await captureSessionIdWithCoordinator({
+        intervalMs,
+        knownSessionIds,
+        listSessionIds: () => listSessionIds(cwd, projectsRoot),
+        onCapture,
+        projectKey: join(projectsRoot, encodeClaudeProjectPath(cwd)),
+        timeoutMs,
+        ...(contentIncludes
+            ? {
+                matchesSessionId: (sessionId) => sessionFileContainsAny(cwd, projectsRoot, sessionId, contentIncludes),
+            }
+            : {}),
+    });
+};
+export const snapshotClaudeSessionIds = (cwd, projectsRoot = getDefaultProjectsRoot()) => new Set(listSessionIds(cwd, projectsRoot));
+export const resetClaudeSessionClaimsForTests = () => {
+    resetSessionCaptureCoordinatorForTests();
+};

package/dist/src/server/session-capture-codex.d.ts

@@ -0,0 +1,6 @@
+export declare const getCodexHome: (pattern?: string, platform?: NodeJS.Platform) => string;
+export declare const readCodexSessionFirstLine: (filePath: string, maxBytes?: number) => string | null;
+export declare const hasCodexSession: (cwd: string, sessionId: string, pattern?: string, platform?: NodeJS.Platform, codexHome?: string) => boolean;
+export declare const snapshotCodexSessionIds: (cwd: string, codexHome?: string, platform?: NodeJS.Platform) => Set<string>;
+export declare const captureCodexSessionId: (cwd: string, knownSessionIds: Set<string>, onCapture: (sessionId: string) => void, timeoutMs?: number, intervalMs?: number, codexHome?: string) => Promise<void>;
+export declare const codexSessionStoreExists: (codexHome?: string) => boolean;

package/dist/src/server/session-capture-codex.js

@@ -0,0 +1,108 @@
+import { closeSync, existsSync, openSync, readdirSync, readSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { captureSessionIdWithCoordinator } from './claude-session-coordinator.js';
+import { arePathsEqual, expandHomePath, indexOfPathMarker } from './platform-path.js';
+const CODEX_SESSION_FILE = /^rollout-.*\.jsonl$/i;
+const CODEX_SESSIONS_MARKER = '/sessions/';
+const CODEX_HEADER_READ_CHUNK_BYTES = 4096;
+const CODEX_HEADER_MAX_BYTES = 64 * 1024;
+const getDefaultCodexHome = () => process.env.CODEX_HOME ?? join(homedir(), '.codex');
+export const getCodexHome = (pattern, platform = process.platform) => {
+    if (!pattern)
+        return getDefaultCodexHome();
+    const markerIndex = indexOfPathMarker(pattern, CODEX_SESSIONS_MARKER, platform);
+    if (markerIndex === -1)
+        return getDefaultCodexHome();
+    const rawRoot = pattern.slice(0, markerIndex).replace(/[\\/]+$/u, '');
+    const root = expandHomePath(rawRoot);
+    if (arePathsEqual(root, join(homedir(), '.codex'), platform))
+        return getDefaultCodexHome();
+    return root || getDefaultCodexHome();
+};
+const walkSessionFiles = (dir) => {
+    try {
+        return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+            const path = join(dir, entry.name);
+            if (entry.isDirectory())
+                return walkSessionFiles(path);
+            return entry.isFile() && CODEX_SESSION_FILE.test(entry.name) ? [path] : [];
+        });
+    }
+    catch {
+        return [];
+    }
+};
+export const readCodexSessionFirstLine = (filePath, maxBytes = CODEX_HEADER_MAX_BYTES) => {
+    const fd = openSync(filePath, 'r');
+    try {
+        const chunks = [];
+        let totalBytes = 0;
+        let position = 0;
+        let reachedLineEnd = false;
+        while (totalBytes < maxBytes) {
+            const bytesToRead = Math.min(CODEX_HEADER_READ_CHUNK_BYTES, maxBytes - totalBytes);
+            const buffer = Buffer.allocUnsafe(bytesToRead);
+            const bytesRead = readSync(fd, buffer, 0, bytesToRead, position);
+            if (bytesRead === 0) {
+                reachedLineEnd = true;
+                break;
+            }
+            const slice = buffer.subarray(0, bytesRead);
+            const newlineIndex = slice.indexOf(0x0a);
+            if (newlineIndex >= 0) {
+                chunks.push(slice.subarray(0, newlineIndex));
+                reachedLineEnd = true;
+                break;
+            }
+            chunks.push(slice);
+            totalBytes += bytesRead;
+            position += bytesRead;
+        }
+        if (!reachedLineEnd)
+            return null;
+        return Buffer.concat(chunks).toString('utf8').replace(/\r$/, '');
+    }
+    finally {
+        closeSync(fd);
+    }
+};
+const parseCodexSession = (filePath) => {
+    const firstLine = readCodexSessionFirstLine(filePath) ?? '';
+    const parsed = JSON.parse(firstLine);
+    if (!parsed || typeof parsed !== 'object' || !('payload' in parsed))
+        return null;
+    const payload = parsed.payload;
+    if (!payload || typeof payload !== 'object')
+        return null;
+    const id = 'id' in payload && typeof payload.id === 'string' ? payload.id : null;
+    const cwd = 'cwd' in payload && typeof payload.cwd === 'string' ? payload.cwd : null;
+    return id && cwd ? { cwd, id } : null;
+};
+const listSessionIds = (cwd, codexHome = getDefaultCodexHome(), platform = process.platform) => {
+    const sessionsRoot = join(codexHome, 'sessions');
+    return walkSessionFiles(sessionsRoot)
+        .flatMap((filePath) => {
+        try {
+            const session = parseCodexSession(filePath);
+            return session && arePathsEqual(session.cwd, cwd, platform) ? [session.id] : [];
+        }
+        catch {
+            return [];
+        }
+    })
+        .sort((left, right) => left.localeCompare(right));
+};
+export const hasCodexSession = (cwd, sessionId, pattern, platform = process.platform, codexHome = getCodexHome(pattern, platform)) => listSessionIds(cwd, codexHome, platform).includes(sessionId);
+export const snapshotCodexSessionIds = (cwd, codexHome = getDefaultCodexHome(), platform = process.platform) => new Set(listSessionIds(cwd, codexHome, platform));
+export const captureCodexSessionId = async (cwd, knownSessionIds, onCapture, timeoutMs = 5000, intervalMs = 100, codexHome = getDefaultCodexHome()) => {
+    await captureSessionIdWithCoordinator({
+        intervalMs,
+        knownSessionIds,
+        listSessionIds: () => listSessionIds(cwd, codexHome),
+        onCapture,
+        projectKey: join(codexHome, 'sessions', cwd),
+        timeoutMs,
+    });
+};
+export const codexSessionStoreExists = (codexHome = getDefaultCodexHome()) => existsSync(join(codexHome, 'sessions'));

package/dist/src/server/session-capture-gemini.d.ts

@@ -0,0 +1,5 @@
+export declare const getGeminiHome: (pattern?: string, platform?: NodeJS.Platform) => string;
+export declare const hasGeminiSession: (cwd: string, sessionId: string, pattern?: string) => boolean;
+export declare const snapshotGeminiSessionIds: (cwd: string, geminiHome?: string) => Set<string>;
+export declare const captureGeminiSessionId: (cwd: string, knownSessionIds: Set<string>, onCapture: (sessionId: string) => void, timeoutMs?: number, intervalMs?: number, geminiHome?: string) => Promise<void>;
+export declare const geminiSessionStoreExists: (geminiHome?: string) => boolean;

package/dist/src/server/session-capture-gemini.js

@@ -0,0 +1,81 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { captureSessionIdWithCoordinator } from './claude-session-coordinator.js';
+import { arePathsEqual, expandHomePath, indexOfPathMarker } from './platform-path.js';
+const GEMINI_SESSION_FILE = /^session-.*\.json$/i;
+const GEMINI_TMP_MARKER = '/tmp/';
+const getDefaultGeminiHome = () => process.env.HIVE_GEMINI_HOME ?? join(homedir(), '.gemini');
+export const getGeminiHome = (pattern, platform = process.platform) => {
+    if (!pattern)
+        return getDefaultGeminiHome();
+    const markerIndex = indexOfPathMarker(pattern, GEMINI_TMP_MARKER, platform);
+    if (markerIndex === -1)
+        return getDefaultGeminiHome();
+    const rawRoot = pattern.slice(0, markerIndex).replace(/[\\/]+$/u, '');
+    const root = expandHomePath(rawRoot);
+    if (arePathsEqual(root, join(homedir(), '.gemini'), platform))
+        return getDefaultGeminiHome();
+    return root || getDefaultGeminiHome();
+};
+const readProjectRoot = (projectDir) => {
+    try {
+        return readFileSync(join(projectDir, '.project_root'), 'utf8').trim();
+    }
+    catch {
+        return null;
+    }
+};
+const parseGeminiSessionId = (filePath) => {
+    const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    return 'sessionId' in parsed && typeof parsed.sessionId === 'string' ? parsed.sessionId : null;
+};
+const listSessionIds = (cwd, geminiHome = getDefaultGeminiHome()) => {
+    const tmpRoot = join(geminiHome, 'tmp');
+    try {
+        return readdirSync(tmpRoot, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .flatMap((entry) => {
+            const projectDir = join(tmpRoot, entry.name);
+            const projectRoot = readProjectRoot(projectDir);
+            if (projectRoot === null || !arePathsEqual(projectRoot, cwd))
+                return [];
+            const chatsDir = join(projectDir, 'chats');
+            try {
+                return readdirSync(chatsDir, { withFileTypes: true }).flatMap((chat) => {
+                    if (!chat.isFile() || !GEMINI_SESSION_FILE.test(chat.name))
+                        return [];
+                    try {
+                        const sessionId = parseGeminiSessionId(join(chatsDir, chat.name));
+                        return sessionId ? [sessionId] : [];
+                    }
+                    catch {
+                        return [];
+                    }
+                });
+            }
+            catch {
+                return [];
+            }
+        })
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        return [];
+    }
+};
+export const hasGeminiSession = (cwd, sessionId, pattern) => listSessionIds(cwd, getGeminiHome(pattern)).includes(sessionId);
+export const snapshotGeminiSessionIds = (cwd, geminiHome = getDefaultGeminiHome()) => new Set(listSessionIds(cwd, geminiHome));
+export const captureGeminiSessionId = async (cwd, knownSessionIds, onCapture, timeoutMs = 5000, intervalMs = 100, geminiHome = getDefaultGeminiHome()) => {
+    await captureSessionIdWithCoordinator({
+        intervalMs,
+        knownSessionIds,
+        listSessionIds: () => listSessionIds(cwd, geminiHome),
+        onCapture,
+        projectKey: join(geminiHome, 'tmp', cwd),
+        timeoutMs,
+    });
+};
+export const geminiSessionStoreExists = (geminiHome = getDefaultGeminiHome()) => existsSync(join(geminiHome, 'tmp'));

package/dist/src/server/session-capture-opencode.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Resolve the path OpenCode upstream writes `opencode.db` to. Branches
+ * by platform because XDG_DATA_HOME is not a Windows convention — the
+ * previous unconditional ~/.local/share/opencode/opencode.db default
+ * pointed at a path that never exists on Windows, silently breaking
+ * Layer A native session resume for OpenCode workers there.
+ *
+ * Resolution order:
+ *   1. HIVE_OPENCODE_DB_PATH override (any platform, for tests/users).
+ *   2. Windows: %LOCALAPPDATA%\opencode\opencode.db (with a homedir
+ *      fallback when LOCALAPPDATA is missing — some shells strip env).
+ *   3. POSIX: $XDG_DATA_HOME/opencode/opencode.db, falling back to
+ *      ~/.local/share/opencode/opencode.db.
+ *
+ * Exported so the path-resolution rules can be unit-tested without
+ * needing to mock the underlying SQLite open.
+ */
+export declare const getDefaultOpenCodeDbPath: (platform?: NodeJS.Platform) => string;
+export declare const getOpenCodeDbPath: (pattern?: string, platform?: NodeJS.Platform) => string;
+export declare const hasOpenCodeSession: (cwd: string, sessionId: string, pattern?: string, platform?: NodeJS.Platform, dbPath?: string) => boolean;
+export declare const snapshotOpenCodeSessionIds: (cwd: string, dbPath?: string, platform?: NodeJS.Platform) => Set<string>;
+export declare const captureOpenCodeSessionId: (cwd: string, knownSessionIds: Set<string>, onCapture: (sessionId: string) => void, timeoutMs?: number, intervalMs?: number, dbPath?: string, platform?: NodeJS.Platform) => Promise<void>;

package/dist/src/server/session-capture-opencode.js

@@ -0,0 +1,75 @@
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import Database from 'better-sqlite3';
+import { captureSessionIdWithCoordinator } from './claude-session-coordinator.js';
+import { arePathsEqual, expandHomePath } from './platform-path.js';
+/**
+ * Resolve the path OpenCode upstream writes `opencode.db` to. Branches
+ * by platform because XDG_DATA_HOME is not a Windows convention — the
+ * previous unconditional ~/.local/share/opencode/opencode.db default
+ * pointed at a path that never exists on Windows, silently breaking
+ * Layer A native session resume for OpenCode workers there.
+ *
+ * Resolution order:
+ *   1. HIVE_OPENCODE_DB_PATH override (any platform, for tests/users).
+ *   2. Windows: %LOCALAPPDATA%\opencode\opencode.db (with a homedir
+ *      fallback when LOCALAPPDATA is missing — some shells strip env).
+ *   3. POSIX: $XDG_DATA_HOME/opencode/opencode.db, falling back to
+ *      ~/.local/share/opencode/opencode.db.
+ *
+ * Exported so the path-resolution rules can be unit-tested without
+ * needing to mock the underlying SQLite open.
+ */
+export const getDefaultOpenCodeDbPath = (platform = process.platform) => {
+    const override = process.env.HIVE_OPENCODE_DB_PATH;
+    if (override)
+        return override;
+    if (platform === 'win32') {
+        const localAppData = process.env.LOCALAPPDATA ?? join(homedir(), 'AppData', 'Local');
+        return join(localAppData, 'opencode', 'opencode.db');
+    }
+    return join(process.env.XDG_DATA_HOME ?? join(homedir(), '.local', 'share'), 'opencode', 'opencode.db');
+};
+export const getOpenCodeDbPath = (pattern, platform = process.platform) => {
+    if (!pattern)
+        return getDefaultOpenCodeDbPath(platform);
+    const expanded = expandHomePath(pattern);
+    if (arePathsEqual(expanded, join(homedir(), '.local', 'share', 'opencode', 'opencode.db'), platform)) {
+        return getDefaultOpenCodeDbPath(platform);
+    }
+    return expanded;
+};
+const listSessionIds = (cwd, dbPath = getDefaultOpenCodeDbPath(), platform = process.platform) => {
+    if (!existsSync(dbPath))
+        return [];
+    let db;
+    try {
+        db = new Database(dbPath, { fileMustExist: true, readonly: true });
+        return db
+            .prepare(`SELECT id, directory FROM session
+           WHERE time_archived IS NULL
+           ORDER BY rowid ASC`)
+            .all()
+            .filter((row) => arePathsEqual(row.directory, cwd, platform))
+            .map((row) => row.id);
+    }
+    catch {
+        return [];
+    }
+    finally {
+        db?.close();
+    }
+};
+export const hasOpenCodeSession = (cwd, sessionId, pattern, platform = process.platform, dbPath = getOpenCodeDbPath(pattern, platform)) => listSessionIds(cwd, dbPath, platform).includes(sessionId);
+export const snapshotOpenCodeSessionIds = (cwd, dbPath = getDefaultOpenCodeDbPath(), platform = process.platform) => new Set(listSessionIds(cwd, dbPath, platform));
+export const captureOpenCodeSessionId = async (cwd, knownSessionIds, onCapture, timeoutMs = 5000, intervalMs = 100, dbPath = getDefaultOpenCodeDbPath(), platform = process.platform) => {
+    await captureSessionIdWithCoordinator({
+        intervalMs,
+        knownSessionIds,
+        listSessionIds: () => listSessionIds(cwd, dbPath, platform),
+        onCapture,
+        projectKey: `${dbPath}:${cwd}`,
+        timeoutMs,
+    });
+};