hivehq 2.0.0

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

@@ -0,0 +1,68 @@
+const claimedByProjectKey = new Map();
+const pollersByProjectKey = new Map();
+const waitersByProjectKey = new Map();
+const clearPollerIfIdle = (projectKey) => {
+    if ((waitersByProjectKey.get(projectKey)?.length ?? 0) > 0)
+        return;
+    const poller = pollersByProjectKey.get(projectKey);
+    if (poller)
+        clearInterval(poller);
+    pollersByProjectKey.delete(projectKey);
+    claimedByProjectKey.delete(projectKey);
+};
+const flushWaiters = (projectKey, listSessionIds) => {
+    const waiters = waitersByProjectKey.get(projectKey);
+    if (!waiters?.length)
+        return clearPollerIfIdle(projectKey);
+    const claimedSessionIds = claimedByProjectKey.get(projectKey) ?? new Set();
+    claimedByProjectKey.set(projectKey, claimedSessionIds);
+    const availableSessionIds = listSessionIds().filter((sessionId) => !claimedSessionIds.has(sessionId));
+    const remainingWaiters = [];
+    for (const waiter of waiters) {
+        const nextSessionId = availableSessionIds.find((sessionId) => !waiter.knownSessionIds.has(sessionId) &&
+            (!waiter.matchesSessionId || waiter.matchesSessionId(sessionId)));
+        if (!nextSessionId) {
+            remainingWaiters.push(waiter);
+            continue;
+        }
+        claimedSessionIds.add(nextSessionId);
+        availableSessionIds.splice(availableSessionIds.indexOf(nextSessionId), 1);
+        waiter.onCapture(nextSessionId);
+        waiter.resolve();
+    }
+    waitersByProjectKey.set(projectKey, remainingWaiters);
+    clearPollerIfIdle(projectKey);
+};
+export const captureSessionIdWithCoordinator = async ({ intervalMs = 100, knownSessionIds, listSessionIds, onCapture, projectKey, timeoutMs = 5000, matchesSessionId, }) => {
+    await new Promise((resolve) => {
+        let timeout;
+        const waiter = {
+            knownSessionIds,
+            ...(matchesSessionId ? { matchesSessionId } : {}),
+            onCapture,
+            resolve: () => {
+                clearTimeout(timeout);
+                resolve();
+            },
+        };
+        timeout = setTimeout(() => {
+            waitersByProjectKey.set(projectKey, (waitersByProjectKey.get(projectKey) ?? []).filter((candidate) => candidate !== waiter));
+            clearPollerIfIdle(projectKey);
+            resolve();
+        }, timeoutMs);
+        timeout.unref?.();
+        waitersByProjectKey.set(projectKey, [...(waitersByProjectKey.get(projectKey) ?? []), waiter]);
+        if (!pollersByProjectKey.has(projectKey)) {
+            pollersByProjectKey.set(projectKey, setInterval(() => flushWaiters(projectKey, listSessionIds), intervalMs));
+            pollersByProjectKey.get(projectKey)?.unref?.();
+        }
+        flushWaiters(projectKey, listSessionIds);
+    });
+};
+export const resetSessionCaptureCoordinatorForTests = () => {
+    for (const poller of pollersByProjectKey.values())
+        clearInterval(poller);
+    pollersByProjectKey.clear();
+    waitersByProjectKey.clear();
+    claimedByProjectKey.clear();
+};

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

@@ -0,0 +1 @@
+export { withPresetResumeArgs } from './preset-launch-support.js';

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

@@ -0,0 +1 @@
+export { withPresetResumeArgs } from './preset-launch-support.js';

package/dist/src/server/command-preset-defaults.d.ts

@@ -0,0 +1,11 @@
+import type { SessionIdCaptureConfig } from './session-capture.js';
+export interface BuiltinCommandPresetDefaults {
+    id: string;
+    displayName: string;
+    command: string;
+    resumeArgsTemplate: string | null;
+    sessionIdCapture: SessionIdCaptureConfig | null;
+    yoloArgsTemplate: string[] | null;
+}
+export declare const BUILTIN_COMMAND_PRESETS: BuiltinCommandPresetDefaults[];
+export declare const getBuiltinCommandPreset: (id: string) => BuiltinCommandPresetDefaults | undefined;

package/dist/src/server/command-preset-defaults.js

@@ -0,0 +1,63 @@
+import { CLAUDE_DEFAULT_YOLO_ARGS } from './claude-command-defaults.js';
+const CODEX_DEFAULT_YOLO_ARGS = ['--dangerously-bypass-approvals-and-sandbox'];
+const OPENCODE_DEFAULT_YOLO_ARGS = [];
+const GEMINI_DEFAULT_YOLO_ARGS = ['--yolo'];
+const HERMES_DEFAULT_YOLO_ARGS = ['--yolo'];
+export const BUILTIN_COMMAND_PRESETS = [
+    {
+        command: 'claude',
+        displayName: 'Claude Code (CC)',
+        id: 'claude',
+        resumeArgsTemplate: '--resume {session_id}',
+        sessionIdCapture: {
+            pattern: '~/.claude/projects/{encoded_cwd}/*.jsonl',
+            source: 'claude_project_jsonl_dir',
+        },
+        yoloArgsTemplate: CLAUDE_DEFAULT_YOLO_ARGS,
+    },
+    {
+        command: 'codex',
+        displayName: 'Codex',
+        id: 'codex',
+        resumeArgsTemplate: 'resume {session_id}',
+        sessionIdCapture: {
+            pattern: '~/.codex/sessions/**/*.jsonl',
+            source: 'codex_session_jsonl_dir',
+        },
+        yoloArgsTemplate: CODEX_DEFAULT_YOLO_ARGS,
+    },
+    {
+        command: 'opencode',
+        displayName: 'OpenCode',
+        id: 'opencode',
+        resumeArgsTemplate: '--session {session_id}',
+        sessionIdCapture: {
+            pattern: '~/.local/share/opencode/opencode.db',
+            source: 'opencode_session_db',
+        },
+        yoloArgsTemplate: OPENCODE_DEFAULT_YOLO_ARGS,
+    },
+    {
+        command: 'gemini',
+        displayName: 'Gemini',
+        id: 'gemini',
+        resumeArgsTemplate: '--resume {session_id}',
+        sessionIdCapture: {
+            pattern: '~/.gemini/tmp/*/chats/*.json',
+            source: 'gemini_session_json_dir',
+        },
+        yoloArgsTemplate: GEMINI_DEFAULT_YOLO_ARGS,
+    },
+    {
+        command: 'hermes',
+        displayName: 'Hermes',
+        id: 'hermes',
+        resumeArgsTemplate: '--resume {session_id}',
+        sessionIdCapture: {
+            pattern: String.raw `Session:\s*([A-Za-z0-9_-]+)`,
+            source: 'stdout_regex',
+        },
+        yoloArgsTemplate: HERMES_DEFAULT_YOLO_ARGS,
+    },
+];
+export const getBuiltinCommandPreset = (id) => BUILTIN_COMMAND_PRESETS.find((preset) => preset.id === id);

package/dist/src/server/command-preset-store.d.ts

@@ -0,0 +1,49 @@
+import type { Database } from 'better-sqlite3';
+import { type SessionIdCaptureConfig } from './session-capture.js';
+export interface CommandPresetRecord {
+    id: string;
+    displayName: string;
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+    resumeArgsTemplate: string | null;
+    sessionIdCapture: SessionIdCaptureConfig | null;
+    yoloArgsTemplate: string[] | null;
+    isBuiltin: boolean;
+}
+export interface CommandPresetInput {
+    displayName: string;
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+    resumeArgsTemplate: string | null;
+    sessionIdCapture: SessionIdCaptureConfig | null;
+    yoloArgsTemplate: string[] | null;
+}
+export declare const createCommandPresetStore: (db: Database) => {
+    create: (input: CommandPresetInput) => {
+        isBuiltin: boolean;
+        displayName: string;
+        command: string;
+        args: string[];
+        env: Record<string, string>;
+        resumeArgsTemplate: string | null;
+        sessionIdCapture: SessionIdCaptureConfig | null;
+        yoloArgsTemplate: string[] | null;
+        id: `${string}-${string}-${string}-${string}-${string}`;
+    };
+    get: (id: string) => CommandPresetRecord | undefined;
+    list: () => CommandPresetRecord[];
+    remove: (id: string) => void;
+    update: (id: string, input: CommandPresetInput) => {
+        displayName: string;
+        command: string;
+        args: string[];
+        env: Record<string, string>;
+        resumeArgsTemplate: string | null;
+        sessionIdCapture: SessionIdCaptureConfig | null;
+        yoloArgsTemplate: string[] | null;
+        id: string;
+        isBuiltin: boolean;
+    };
+};

package/dist/src/server/command-preset-store.js

@@ -0,0 +1,83 @@
+import { randomUUID } from 'node:crypto';
+import { ConflictError } from './http-errors.js';
+import { parseSessionIdCapture } from './session-capture.js';
+const parseStringArray = (value) => {
+    if (!value)
+        return [];
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) && parsed.every((item) => typeof item === 'string') ? parsed : [];
+};
+const parseEnv = (value) => {
+    if (!value)
+        return {};
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+        ? Object.fromEntries(Object.entries(parsed).filter((entry) => typeof entry[1] === 'string'))
+        : {};
+};
+const parseJsonBlob = (value) => {
+    if (!value)
+        return null;
+    return parseSessionIdCapture(JSON.parse(value));
+};
+const serializeArgs = (args) => JSON.stringify(args);
+const serializeEnv = (env) => JSON.stringify(env);
+const serializeBlob = (value) => value ? JSON.stringify(value) : null;
+const serializeYolo = (value) => (value ? JSON.stringify(value) : null);
+const toRecord = (row) => ({
+    id: row.id,
+    displayName: row.display_name,
+    command: row.command,
+    args: parseStringArray(row.args),
+    env: parseEnv(row.env),
+    resumeArgsTemplate: row.resume_args_template,
+    sessionIdCapture: parseJsonBlob(row.session_id_capture),
+    yoloArgsTemplate: parseStringArray(row.yolo_args_template),
+    isBuiltin: row.is_builtin === 1,
+});
+export const createCommandPresetStore = (db) => {
+    const get = (id) => {
+        const row = db
+            .prepare(`SELECT id, display_name, command, args, env, resume_args_template, session_id_capture, yolo_args_template, is_builtin
+         FROM command_presets WHERE id = ?`)
+            .get(id);
+        return row ? toRecord(row) : undefined;
+    };
+    const list = () => {
+        return db
+            .prepare(`SELECT id, display_name, command, args, env, resume_args_template, session_id_capture, yolo_args_template, is_builtin
+         FROM command_presets ORDER BY is_builtin DESC, created_at ASC`)
+            .all()
+            .map((row) => toRecord(row));
+    };
+    const create = (input) => {
+        const record = { id: randomUUID(), ...input, isBuiltin: false };
+        const now = Date.now();
+        db.prepare(`INSERT INTO command_presets (
+         id, display_name, command, args, env, resume_args_template, session_id_capture,
+         yolo_args_template, is_builtin, created_at, updated_at
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?)`).run(record.id, record.displayName, record.command, serializeArgs(record.args), serializeEnv(record.env), record.resumeArgsTemplate, serializeBlob(record.sessionIdCapture), serializeYolo(record.yoloArgsTemplate), now, now);
+        return record;
+    };
+    const update = (id, input) => {
+        const current = list().find((preset) => preset.id === id);
+        if (!current)
+            throw new Error(`Command preset not found: ${id}`);
+        if (current.isBuiltin)
+            throw new ConflictError(`Builtin command preset is read-only: ${id}`);
+        db.prepare(`UPDATE command_presets
+       SET display_name = ?, command = ?, args = ?, env = ?, resume_args_template = ?,
+           session_id_capture = ?, yolo_args_template = ?, updated_at = ?
+       WHERE id = ?`).run(input.displayName, input.command, serializeArgs(input.args), serializeEnv(input.env), input.resumeArgsTemplate, serializeBlob(input.sessionIdCapture), serializeYolo(input.yoloArgsTemplate), Date.now(), id);
+        return { ...current, ...input };
+    };
+    const remove = (id) => {
+        const current = list().find((preset) => preset.id === id);
+        if (!current)
+            throw new Error(`Command preset not found: ${id}`);
+        if (current.isBuiltin)
+            throw new ConflictError(`Builtin command preset is read-only: ${id}`);
+        db.prepare('DELETE FROM command_presets WHERE id = ?').run(id);
+    };
+    return { create, get, list, remove, update };
+};

package/dist/src/server/cron-util.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Validate a 5-field cron string and return its next fire time (ms-epoch).
+ * Throws BadRequestError on an unparseable expression. Shared by the UI
+ * schedule PATCH route and the agent `team workflow schedule` route so cron
+ * validation behaves identically on both paths. UTC, like the scheduler.
+ */
+export declare const validateCronNextRunAt: (cron: string) => number;

package/dist/src/server/cron-util.js

@@ -0,0 +1,19 @@
+import { CronExpressionParser } from 'cron-parser';
+import { BadRequestError } from './http-errors.js';
+/**
+ * Validate a 5-field cron string and return its next fire time (ms-epoch).
+ * Throws BadRequestError on an unparseable expression. Shared by the UI
+ * schedule PATCH route and the agent `team workflow schedule` route so cron
+ * validation behaves identically on both paths. UTC, like the scheduler.
+ */
+export const validateCronNextRunAt = (cron) => {
+    try {
+        return CronExpressionParser.parse(cron, { currentDate: new Date(), tz: 'UTC' })
+            .next()
+            .toDate()
+            .getTime();
+    }
+    catch (error) {
+        throw new BadRequestError(`Invalid cron expression: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};

package/dist/src/server/dispatch-ledger-serializer.d.ts

@@ -0,0 +1,15 @@
+import type { DispatchRecord } from './dispatch-ledger-store.js';
+export declare const serializeDispatchRecord: (record: DispatchRecord) => {
+    artifacts: string[];
+    created_at: number;
+    delivered_at: number | null;
+    from_agent_id: string | null;
+    id: string;
+    reported_at: number | null;
+    report_text: string | null;
+    state: import("./dispatch-ledger-store.js").DispatchStatus;
+    submitted_at: number | null;
+    text: string;
+    to_agent_id: string;
+    workspace_id: string;
+};

package/dist/src/server/dispatch-ledger-serializer.js

@@ -0,0 +1,14 @@
+export const serializeDispatchRecord = (record) => ({
+    artifacts: record.artifacts,
+    created_at: record.createdAt,
+    delivered_at: record.deliveredAt,
+    from_agent_id: record.fromAgentId,
+    id: record.id,
+    reported_at: record.reportedAt,
+    report_text: record.reportText,
+    state: record.status,
+    submitted_at: record.submittedAt,
+    text: record.text,
+    to_agent_id: record.toAgentId,
+    workspace_id: record.workspaceId,
+});

package/dist/src/server/dispatch-ledger-store.d.ts

@@ -0,0 +1,108 @@
+import type { Database } from 'better-sqlite3';
+export type DispatchStatus = 'queued' | 'submitted' | 'reported' | 'cancelled';
+export interface DispatchRecord {
+    artifacts: string[];
+    createdAt: number;
+    deliveredAt: number | null;
+    fromAgentId: string | null;
+    id: string;
+    label: string | null;
+    phase: string | null;
+    reportedAt: number | null;
+    reportText: string | null;
+    sequence: number | null;
+    status: DispatchStatus;
+    stepIndex: number | null;
+    submittedAt: number | null;
+    text: string;
+    toAgentId: string;
+    workflowRunId: string | null;
+    workspaceId: string;
+}
+interface CreateDispatchInput {
+    fromAgentId?: string;
+    label?: string;
+    phase?: string;
+    stepIndex?: number;
+    text: string;
+    toAgentId: string;
+    workflowRunId?: string;
+    workspaceId: string;
+}
+interface ReportDispatchInput {
+    artifacts: string[];
+    dispatchId?: string;
+    reportText: string;
+    toAgentId: string;
+    workspaceId: string;
+}
+interface CancelDispatchInput {
+    dispatchId: string;
+    reason: string;
+    workspaceId: string;
+}
+export interface ListDispatchesOptions {
+    limit?: number;
+    offset?: number;
+    status?: DispatchStatus;
+}
+export declare const createDispatchLedgerStore: (db: Database) => {
+    createDispatch: (input: CreateDispatchInput) => DispatchRecord;
+    deleteDispatch: (dispatchId: string) => void;
+    deleteWorkerDispatches: (workspaceId: string, workerId: string) => void;
+    deleteWorkspaceDispatches: (workspaceId: string) => void;
+    findOpenDispatch: (workspaceId: string, toAgentId: string, dispatchId?: string) => DispatchRecord | undefined;
+    findOpenDispatchById: (workspaceId: string, dispatchId: string) => DispatchRecord | undefined;
+    listOpenDispatchKinds: () => Array<{
+        type: "send";
+        worker_id: string;
+        workspace_id: string;
+    }>;
+    listOpenDispatchIdsForRun: (runId: string) => string[];
+    listOpenWorkflowDispatchesForWorker: (workspaceId: string, workerId: string) => Array<{
+        dispatchId: string;
+        runId: string;
+    }>;
+    listWorkflowRunDispatches: (runId: string) => DispatchRecord[];
+    listWorkspaceDispatches: (workspaceId: string, options?: ListDispatchesOptions) => DispatchRecord[];
+    markCancelled: (input: CancelDispatchInput) => {
+        reportedAt: number;
+        reportText: string;
+        status: "cancelled";
+        artifacts: string[];
+        createdAt: number;
+        deliveredAt: number | null;
+        fromAgentId: string | null;
+        id: string;
+        label: string | null;
+        phase: string | null;
+        sequence: number | null;
+        stepIndex: number | null;
+        submittedAt: number | null;
+        text: string;
+        toAgentId: string;
+        workflowRunId: string | null;
+        workspaceId: string;
+    } | undefined;
+    markReportedByWorker: (input: ReportDispatchInput) => {
+        artifacts: string[];
+        reportedAt: number;
+        reportText: string;
+        status: "reported";
+        createdAt: number;
+        deliveredAt: number | null;
+        fromAgentId: string | null;
+        id: string;
+        label: string | null;
+        phase: string | null;
+        sequence: number | null;
+        stepIndex: number | null;
+        submittedAt: number | null;
+        text: string;
+        toAgentId: string;
+        workflowRunId: string | null;
+        workspaceId: string;
+    } | undefined;
+    markSubmitted: (dispatchId: string) => void;
+};
+export {};