hivehq 2.0.0

package/dist/src/server/report-outbox-store.js

@@ -0,0 +1,33 @@
+const rowToEntry = (row) => ({
+    id: row.id,
+    workspaceId: row.workspace_id,
+    targetAgentId: row.target_agent_id,
+    dispatchId: row.dispatch_id,
+    payload: row.payload,
+    createdAt: row.created_at,
+    deliveredAt: row.delivered_at,
+});
+export const createReportOutboxStore = (db) => {
+    // INSERT OR IGNORE on the UNIQUE dispatch_id: a dispatch reports once, so a
+    // second enqueue for the same dispatch (e.g. a retry path) is a no-op rather
+    // than a duplicate the orchestrator would see twice.
+    const enqueue = (input) => {
+        db.prepare(`INSERT OR IGNORE INTO report_outbox
+        (workspace_id, target_agent_id, dispatch_id, payload, created_at)
+       VALUES (?, ?, ?, ?, ?)`).run(input.workspaceId, input.targetAgentId, input.dispatchId, input.payload, Date.now());
+    };
+    const listPending = (workspaceId, targetAgentId) => db
+        .prepare(`SELECT id, workspace_id, target_agent_id, dispatch_id, payload, created_at, delivered_at
+           FROM report_outbox
+           WHERE workspace_id = ? AND target_agent_id = ? AND delivered_at IS NULL
+           ORDER BY created_at ASC, id ASC`)
+        .all(workspaceId, targetAgentId).map(rowToEntry);
+    const markDelivered = (id) => {
+        db.prepare(`UPDATE report_outbox SET delivered_at = ? WHERE id = ? AND delivered_at IS NULL`).run(Date.now(), id);
+    };
+    const pendingCount = (workspaceId, targetAgentId) => db
+        .prepare(`SELECT COUNT(*) AS n FROM report_outbox
+           WHERE workspace_id = ? AND target_agent_id = ? AND delivered_at IS NULL`)
+        .get(workspaceId, targetAgentId).n;
+    return { enqueue, listPending, markDelivered, pendingCount };
+};

package/dist/src/server/restart-policy-support.d.ts

@@ -0,0 +1,30 @@
+import type { AgentSummary, WorkspaceSummary } from '../shared/types.js';
+import type { PersistedAgentRun } from './agent-run-store.js';
+import type { FeatureFlags } from './feature-flags.js';
+import type { MessageLogHandle, MessageLogRecord, RecoveryMessage } from './message-log-store.js';
+import type { TeamMemoryInjectionService } from './team-memory-injection.js';
+export interface RestartPolicyInput {
+    deleteMessage: (handle: MessageLogHandle) => void;
+    getWorkspaceSnapshot: (workspaceId: string) => {
+        agents: AgentSummary[];
+        summary: WorkspaceSummary;
+    };
+    insertMessage: (record: MessageLogRecord) => MessageLogHandle;
+    listAgentRuns: (agentId: string) => PersistedAgentRun[];
+    listMessagesForRecovery: (workspaceId: string, sinceMs: number) => RecoveryMessage[];
+    readTasks: (workspacePath: string) => string;
+    /** Resolves the live experimental flags, threaded into the recovery handover
+     *  prompt so it matches a fresh startup. Optional; omitted → all off. */
+    getFlags?: () => FeatureFlags;
+    memoryInjection?: TeamMemoryInjectionService;
+}
+export declare const findPreviousRun: (runs: PersistedAgentRun[], currentRunId: string) => PersistedAgentRun | undefined;
+export declare const writeSystemMessage: ({ deleteMessage, insertMessage, record, runId, text, writeToRun, onWriteFailure, }: {
+    deleteMessage: RestartPolicyInput["deleteMessage"];
+    insertMessage: RestartPolicyInput["insertMessage"];
+    onWriteFailure?: () => void;
+    record: MessageLogRecord;
+    runId: string;
+    text: string;
+    writeToRun: (runId: string, text: string) => Promise<void>;
+}) => void;

package/dist/src/server/restart-policy-support.js

@@ -0,0 +1,21 @@
+export const findPreviousRun = (runs, currentRunId) => runs.find((run) => run.runId !== currentRunId);
+export const writeSystemMessage = ({ deleteMessage, insertMessage, record, runId, text, writeToRun, onWriteFailure, }) => {
+    const handle = insertMessage(record);
+    try {
+        void writeToRun(runId, text).catch(() => {
+            onWriteFailure?.();
+            try {
+                deleteMessage(handle);
+            }
+            catch {
+                // The runtime may already be closing; the failed post-start write is
+                // non-critical once the run is gone.
+            }
+        });
+    }
+    catch (error) {
+        onWriteFailure?.();
+        deleteMessage(handle);
+        throw error;
+    }
+};

package/dist/src/server/restart-policy.d.ts

@@ -0,0 +1,18 @@
+import type { WorkspaceSummary } from '../shared/types.js';
+import type { AgentLaunchConfigInput } from './agent-run-store.js';
+import { type RestartPolicyInput } from './restart-policy-support.js';
+export interface RestartPolicy {
+    injectPostStartMessage: (input: {
+        agentId: string;
+        runId: string;
+        startConfig: AgentLaunchConfigInput;
+        workspace: WorkspaceSummary;
+        writeToRun: (runId: string, text: string) => Promise<void>;
+    }) => boolean;
+    /** Record that `runId` was killed at the user's request (Stop button), so a
+     *  subsequent restart does not inject the crash-recovery handover for a run
+     *  the user deliberately ended. */
+    markUserStopped: (runId: string) => void;
+}
+export declare const createNoopRestartPolicy: () => RestartPolicy;
+export declare const createRestartPolicy: ({ deleteMessage, getWorkspaceSnapshot, insertMessage, listAgentRuns, listMessagesForRecovery, memoryInjection, readTasks, getFlags, }: RestartPolicyInput) => RestartPolicy;

package/dist/src/server/restart-policy.js

@@ -0,0 +1,77 @@
+import { FEATURE_FLAGS_ALL_OFF } from './feature-flags.js';
+import { buildRecoverySummary } from './recovery-summary.js';
+import { findPreviousRun, writeSystemMessage, } from './restart-policy-support.js';
+import { createSystemRecoverySummaryMessage } from './runtime-message-builders.js';
+import { buildMemoryDigestSafely, logMemoryDigestInjection, rollbackMemoryDigestInjection, } from './team-memory-injection.js';
+const RECOVERY_WINDOW_MS = 60 * 60 * 1000;
+export const createNoopRestartPolicy = () => ({
+    injectPostStartMessage() {
+        return false;
+    },
+    markUserStopped() { },
+});
+export const createRestartPolicy = ({ deleteMessage, getWorkspaceSnapshot, insertMessage, listAgentRuns, listMessagesForRecovery, memoryInjection, readTasks, getFlags, }) => {
+    // Runs the user killed via the Stop button. A deliberate stop is otherwise
+    // byte-identical to a crash (both end status 'error'), so without this a
+    // stop+Restart would inject the "could not recover" handover with stale open
+    // tasks the user may have meant to abandon. In-process only: after a runtime
+    // restart this is empty, which is correct — that case IS a recovery.
+    const userStoppedRuns = new Set();
+    return {
+        markUserStopped(runId) {
+            userStoppedRuns.add(runId);
+        },
+        injectPostStartMessage({ agentId, runId, startConfig, workspace, writeToRun }) {
+            const previousRun = findPreviousRun(listAgentRuns(agentId), runId);
+            if (!previousRun)
+                return false;
+            // Consume the marker whether or not we end up skipping, so it never
+            // lingers to suppress a later genuine crash on the same run id.
+            const wasUserStopped = userStoppedRuns.delete(previousRun.runId);
+            const snapshot = getWorkspaceSnapshot(workspace.id);
+            const agent = snapshot.agents.find((item) => item.id === agentId);
+            if (!agent)
+                return false;
+            const workers = snapshot.agents.filter((item) => item.role !== 'orchestrator' && item.id !== agentId);
+            const tasksContent = readTasks(snapshot.summary.path);
+            if (startConfig.resumedSessionId)
+                return true;
+            // Deliberate stop + restart: start fresh, no crash handover.
+            if (wasUserStopped)
+                return false;
+            const memoryDigest = buildMemoryDigestSafely({
+                contextType: 'recovery',
+                memoryInjection,
+                workspaceId: workspace.id,
+            });
+            const injectionIds = logMemoryDigestInjection({
+                agentId,
+                contextType: 'recovery',
+                memoryDigest,
+                memoryInjection,
+                workspaceId: workspace.id,
+            });
+            const auditedMemoryDigest = injectionIds ? memoryDigest : null;
+            const text = buildRecoverySummary({
+                agent,
+                allTaskMessages: listMessagesForRecovery(workspace.id, 0),
+                memoryDigest: auditedMemoryDigest?.text,
+                messages: listMessagesForRecovery(workspace.id, Date.now() - RECOVERY_WINDOW_MS),
+                tasksContent,
+                workers,
+                workspace,
+                flags: getFlags?.() ?? FEATURE_FLAGS_ALL_OFF,
+            });
+            writeSystemMessage({
+                deleteMessage,
+                insertMessage,
+                record: createSystemRecoverySummaryMessage(workspace.id, agentId, text),
+                runId,
+                text,
+                writeToRun,
+                onWriteFailure: () => rollbackMemoryDigestInjection({ injectionIds, memoryInjection }),
+            });
+            return true;
+        },
+    };
+};

package/dist/src/server/role-template-store.d.ts

@@ -0,0 +1,45 @@
+import type { Database } from 'better-sqlite3';
+export type RoleTemplateType = 'orchestrator' | 'coder' | 'reviewer' | 'tester' | 'custom';
+export interface RoleTemplateRecord {
+    id: string;
+    name: string;
+    roleType: RoleTemplateType;
+    description: string;
+    defaultCommand: string;
+    defaultArgs: string[];
+    defaultEnv: Record<string, string>;
+    isBuiltin: boolean;
+}
+export interface RoleTemplateInput {
+    name: string;
+    roleType: RoleTemplateType;
+    description: string;
+    defaultCommand: string;
+    defaultArgs: string[];
+    defaultEnv: Record<string, string>;
+}
+export declare const createRoleTemplateStore: (db: Database) => {
+    create: (input: RoleTemplateInput) => {
+        isBuiltin: boolean;
+        name: string;
+        roleType: RoleTemplateType;
+        description: string;
+        defaultCommand: string;
+        defaultArgs: string[];
+        defaultEnv: Record<string, string>;
+        id: `${string}-${string}-${string}-${string}-${string}`;
+    };
+    list: () => RoleTemplateRecord[];
+    remove: (id: string) => void;
+    update: (id: string, input: RoleTemplateInput) => {
+        name: string;
+        roleType: RoleTemplateType;
+        description: string;
+        defaultCommand: string;
+        defaultArgs: string[];
+        defaultEnv: Record<string, string>;
+        id: string;
+        isBuiltin: boolean;
+    };
+    findByName: (name: string) => RoleTemplateRecord | undefined;
+};

package/dist/src/server/role-template-store.js

@@ -0,0 +1,76 @@
+import { randomUUID } from 'node:crypto';
+import { ConflictError } from './http-errors.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 serializeArgs = (args) => JSON.stringify(args);
+const serializeEnv = (env) => JSON.stringify(env);
+const toRecord = (row) => ({
+    id: row.id,
+    name: row.name,
+    roleType: row.role_type,
+    description: row.description,
+    defaultCommand: row.default_command,
+    defaultArgs: parseStringArray(row.default_args),
+    defaultEnv: parseEnv(row.default_env),
+    isBuiltin: row.is_builtin === 1,
+});
+export const createRoleTemplateStore = (db) => {
+    const list = () => {
+        return db
+            .prepare(`SELECT id, name, role_type, description, default_command, default_args, default_env, is_builtin
+         FROM role_templates ORDER BY is_builtin DESC, created_at ASC`)
+            .all()
+            .map((row) => toRecord(row));
+    };
+    /* TIER 2 #4 — case-insensitive lookup by template name. The workflow
+       runner uses this to resolve `agent('...', { agentType: 'security-reviewer' })`
+       against the workspace's custom role library so workflows can target
+       curated roles instead of always re-rolling fresh claude defaults. */
+    const findByName = (name) => {
+        const needle = name.trim().toLowerCase();
+        if (!needle)
+            return undefined;
+        return list().find((template) => template.name.trim().toLowerCase() === needle);
+    };
+    const create = (input) => {
+        const record = { id: randomUUID(), ...input, isBuiltin: false };
+        const now = Date.now();
+        db.prepare(`INSERT INTO role_templates (
+         id, name, role_type, description, default_command, default_args, default_env,
+         is_builtin, created_at, updated_at
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, ?)`).run(record.id, record.name, record.roleType, record.description, record.defaultCommand, serializeArgs(record.defaultArgs), serializeEnv(record.defaultEnv), now, now);
+        return record;
+    };
+    const update = (id, input) => {
+        const current = list().find((template) => template.id === id);
+        if (!current)
+            throw new Error(`Role template not found: ${id}`);
+        if (current.isBuiltin)
+            throw new ConflictError(`Builtin role template is read-only: ${id}`);
+        db.prepare(`UPDATE role_templates
+       SET name = ?, role_type = ?, description = ?, default_command = ?, default_args = ?, default_env = ?, updated_at = ?
+       WHERE id = ?`).run(input.name, input.roleType, input.description, input.defaultCommand, serializeArgs(input.defaultArgs), serializeEnv(input.defaultEnv), Date.now(), id);
+        return { ...current, ...input };
+    };
+    const remove = (id) => {
+        const current = list().find((template) => template.id === id);
+        if (!current)
+            throw new Error(`Role template not found: ${id}`);
+        if (current.isBuiltin)
+            throw new ConflictError(`Builtin role template is read-only: ${id}`);
+        db.prepare('DELETE FROM role_templates WHERE id = ?').run(id);
+    };
+    return { create, list, remove, update, findByName };
+};

package/dist/src/server/role-templates.d.ts

@@ -0,0 +1,7 @@
+import type { WorkerRole } from '../shared/types.js';
+export declare const ORCHESTRATOR_ROLE_DESCRIPTION: string;
+export declare const CODER_ROLE_DESCRIPTION: string;
+export declare const REVIEWER_ROLE_DESCRIPTION: string;
+export declare const TESTER_ROLE_DESCRIPTION: string;
+export declare const CUSTOM_ROLE_DESCRIPTION: string;
+export declare const getDefaultRoleDescription: (role: WorkerRole | "orchestrator") => string;

package/dist/src/server/role-templates.js

@@ -0,0 +1,54 @@
+import { TASKS_RELATIVE_PATH } from './tasks-file.js';
+export const ORCHESTRATOR_ROLE_DESCRIPTION = [
+    '你是 Hive 的 Orchestrator，负责直接响应用户并组织右侧真实成员协作。',
+    '工作方式：',
+    '- 澄清目标，把需求拆成可派发的小任务。',
+    `- 维护 ${TASKS_RELATIVE_PATH}，让当前计划、进度和阻塞可追踪。`,
+    '- 根据成员汇报推进下一步，不把选择题无谓丢回给用户。',
+].join('\n');
+export const CODER_ROLE_DESCRIPTION = [
+    '你是实现型 Coder，负责把明确任务落成最小正确代码改动。',
+    '工作方式：',
+    '- 先阅读相关文件和现有模式，再动手。',
+    '- 优先小步修改，避免无关重构和范围扩张。',
+    '- 改动后运行能覆盖风险的验证命令；不能验证时说明原因。',
+    '交付说明要包含：改动文件、验证结果、剩余风险或阻塞。',
+].join('\n');
+export const REVIEWER_ROLE_DESCRIPTION = [
+    '你是监工型 Reviewer，负责质量审查，不替代 Orchestrator，也不默认改代码。',
+    '工作方式：',
+    '- 优先找真实 bug、回归风险、边界条件和测试缺口。',
+    '- 发现问题时给出严重度、文件/行号、触发条件和最小修复建议。',
+    '- 没有高风险问题时明确说清剩余风险和未验证范围。',
+    '交付说明按严重度排序，先列 blocking 问题。',
+].join('\n');
+export const TESTER_ROLE_DESCRIPTION = [
+    '你是验证型 Tester，负责复现、测试和证据化验证。',
+    '工作方式：',
+    '- 先明确要验证的行为、入口和失败条件。',
+    '- 优先跑真实命令或真实链路；必要时补充最小测试。',
+    '- 记录命令、结果、关键输出和不能覆盖的场景。',
+    '交付说明要区分通过、失败、未验证和建议下一步。',
+].join('\n');
+export const CUSTOM_ROLE_DESCRIPTION = [
+    '你是自定义成员。请把这段改成该成员的行为契约。',
+    '建议包含：',
+    '- 目标：这个成员主要负责什么。',
+    '- 边界：哪些事可以做，哪些事不要做。',
+    '- 工作方式：如何调查、修改、验证或审查。',
+    '- 完成标准：交付时需要说明哪些结果、风险和阻塞。',
+].join('\n');
+export const getDefaultRoleDescription = (role) => {
+    switch (role) {
+        case 'orchestrator':
+            return ORCHESTRATOR_ROLE_DESCRIPTION;
+        case 'coder':
+            return CODER_ROLE_DESCRIPTION;
+        case 'reviewer':
+            return REVIEWER_ROLE_DESCRIPTION;
+        case 'tester':
+            return TESTER_ROLE_DESCRIPTION;
+        case 'custom':
+            return CUSTOM_ROLE_DESCRIPTION;
+    }
+};

package/dist/src/server/route-helpers.d.ts

@@ -0,0 +1,9 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { RouteDefinition } from './route-types.js';
+export declare const sendJson: (response: ServerResponse, statusCode: number, body: unknown) => void;
+export declare const readJsonBody: <T>(request: IncomingMessage, options?: {
+    limitBytes?: number;
+}) => Promise<T>;
+export declare const getRequiredParam: (response: ServerResponse, params: Record<string, string>, key: string, error: string) => string | null;
+export declare const route: (method: string, path: string, handler: RouteDefinition["handler"]) => RouteDefinition;
+export declare const matchPath: (pattern: string, pathname: string) => Record<string, string> | null;

package/dist/src/server/route-helpers.js

@@ -0,0 +1,61 @@
+import { PayloadTooLargeError } from './http-errors.js';
+const DEFAULT_JSON_BODY_LIMIT_BYTES = 1024 * 1024;
+export const sendJson = (response, statusCode, body) => {
+    response.statusCode = statusCode;
+    response.setHeader('content-type', 'application/json; charset=utf-8');
+    response.end(JSON.stringify(body));
+};
+export const readJsonBody = async (request, options = {}) => {
+    const limitBytes = options.limitBytes ?? DEFAULT_JSON_BODY_LIMIT_BYTES;
+    const rawContentLength = request.headers['content-length'];
+    const contentLength = Array.isArray(rawContentLength) ? rawContentLength[0] : rawContentLength;
+    if (contentLength && Number(contentLength) > limitBytes) {
+        throw new PayloadTooLargeError('Request body too large');
+    }
+    const chunks = [];
+    let totalBytes = 0;
+    for await (const chunk of request) {
+        const buffer = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+        totalBytes += buffer.byteLength;
+        if (totalBytes > limitBytes) {
+            throw new PayloadTooLargeError('Request body too large');
+        }
+        chunks.push(buffer);
+    }
+    return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+};
+export const getRequiredParam = (response, params, key, error) => {
+    const value = params[key];
+    if (value) {
+        return value;
+    }
+    sendJson(response, 400, { error });
+    return null;
+};
+export const route = (method, path, handler) => ({
+    method,
+    path,
+    handler,
+});
+export const matchPath = (pattern, pathname) => {
+    const patternParts = pattern.split('/').filter(Boolean);
+    const pathParts = pathname.split('/').filter(Boolean);
+    if (patternParts.length !== pathParts.length) {
+        return null;
+    }
+    const params = {};
+    for (const [index, patternPart] of patternParts.entries()) {
+        const pathPart = pathParts[index];
+        if (!pathPart) {
+            return null;
+        }
+        if (patternPart.startsWith(':')) {
+            params[patternPart.slice(1)] = decodeURIComponent(pathPart);
+            continue;
+        }
+        if (patternPart !== pathPart) {
+            return null;
+        }
+    }
+    return params;
+};

package/dist/src/server/route-types.d.ts

@@ -0,0 +1,121 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { WorkerRole } from '../shared/types.js';
+import type { PickFolderResponse } from './fs-pick-folder.js';
+import type { OpenCommandResult, OpenWorkspaceInput as OpenWorkspaceServiceInput } from './open-target-commands.js';
+import type { RuntimeStore } from './runtime-store.js';
+import type { TasksFileService } from './tasks-file.js';
+import type { VersionService } from './version-service.js';
+export interface SendTaskBody {
+    hive_port?: string;
+    project_id: string;
+    from_agent_id: string;
+    token?: string;
+    to: string;
+    text: string;
+}
+export interface SpawnAgentBody {
+    hive_port?: string;
+    project_id: string;
+    from_agent_id: string;
+    token?: string;
+    role?: string;
+    name?: string;
+    cli?: string;
+    /** Opt-in: auto-dismiss the worker after its next dispatch report. Default
+     *  false → persistent member (lives until explicit `team dismiss`). */
+    ephemeral?: boolean;
+}
+export interface DismissAgentBody {
+    hive_port?: string;
+    project_id: string;
+    from_agent_id: string;
+    token?: string;
+    name: string;
+}
+export interface WorkflowRunBody {
+    hive_port?: string;
+    project_id: string;
+    from_agent_id: string;
+    token?: string;
+    source: string;
+    name?: string;
+    args?: unknown;
+}
+export interface WorkflowControlBody {
+    project_id: string;
+    from_agent_id: string;
+    token?: string;
+    run_id: string;
+}
+export interface WorkflowScheduleBody {
+    project_id: string;
+    from_agent_id: string;
+    token?: string;
+    source: string;
+    name: string;
+    cron: string;
+    args?: unknown;
+}
+export interface ReportTaskBody {
+    dispatch_id?: string;
+    project_id: string;
+    from_agent_id: string;
+    token?: string;
+    result: string;
+    status?: 'success' | 'failed';
+    artifacts?: unknown[];
+}
+export interface CancelTaskBody {
+    dispatch_id?: string;
+    project_id: string;
+    from_agent_id: string;
+    token?: string;
+    reason?: string;
+}
+export interface CreateWorkspaceBody {
+    path: string;
+    name: string;
+    /** Default true. When false, skip orchestrator PTY spawn after creation. */
+    autostart_orchestrator?: boolean;
+    /** Optional command preset. With startup_command, this selects the CLI interaction driver. */
+    command_preset_id?: string | null;
+    /** Optional full startup command. When set, it overrides the executable only. */
+    startup_command?: string | null;
+}
+export interface CreateWorkerBody {
+    autostart?: boolean;
+    command_preset_id?: string | null;
+    description?: string;
+    name: string;
+    role: WorkerRole;
+    /** Optional full startup command. When set, it overrides the executable only. */
+    startup_command?: string | null;
+}
+export interface UserInputBody {
+    text: string;
+}
+export interface ConfigureAgentLaunchBody {
+    command: string;
+    args?: string[];
+    command_preset_id?: string | null;
+}
+export interface OpenWorkspaceBody {
+    target_id: string;
+}
+export type OpenWorkspaceService = (input: OpenWorkspaceServiceInput) => Promise<OpenCommandResult>;
+export interface RouteContext {
+    request: IncomingMessage;
+    response: ServerResponse;
+    store: RuntimeStore;
+    tasksFileService: TasksFileService;
+    pickFolderService: () => Promise<PickFolderResponse>;
+    openWorkspaceService: OpenWorkspaceService;
+    versionService: VersionService;
+    params: Record<string, string>;
+}
+export interface RouteDefinition {
+    method: string;
+    path: string;
+    handler: (context: RouteContext) => Promise<void> | void;
+}
+export type { WorkerRole };

package/dist/src/server/route-types.js

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

package/dist/src/server/routes-dispatches.d.ts

@@ -0,0 +1,2 @@
+import type { RouteDefinition } from './route-types.js';
+export declare const dispatchRoutes: RouteDefinition[];

package/dist/src/server/routes-dispatches.js

@@ -0,0 +1,54 @@
+import { serializeDispatchRecord } from './dispatch-ledger-serializer.js';
+import { getRequiredParam, route, sendJson } from './route-helpers.js';
+import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
+const DISPATCH_STATUSES = new Set(['queued', 'submitted', 'reported', 'cancelled']);
+const MAX_DISPATCH_LIMIT = 100;
+const MAX_DISPATCH_OFFSET = 100_000;
+const readBoundedInt = (response, value, name, fallback, max) => {
+    if (value === null)
+        return fallback;
+    if (!/^(0|[1-9][0-9]*)$/.test(value)) {
+        sendJson(response, 400, { error: `${name} must be a non-negative integer` });
+        return null;
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed > max) {
+        sendJson(response, 400, { error: `${name} must be between 0 and ${max}` });
+        return null;
+    }
+    return parsed;
+};
+const isDispatchStatus = (value) => DISPATCH_STATUSES.has(value);
+export const dispatchRoutes = [
+    route('GET', '/api/ui/workspaces/:workspaceId/dispatches', ({ params, request, response, store }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');
+        if (!workspaceId) {
+            return;
+        }
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+        if (url.searchParams.has('status')) {
+            sendJson(response, 400, { error: 'Use state instead of status for dispatch filtering' });
+            return;
+        }
+        const state = url.searchParams.get('state');
+        if (state !== null && !isDispatchStatus(state)) {
+            sendJson(response, 400, {
+                error: 'state must be queued, submitted, reported, or cancelled',
+            });
+            return;
+        }
+        const limit = readBoundedInt(response, url.searchParams.get('limit'), 'limit', MAX_DISPATCH_LIMIT, MAX_DISPATCH_LIMIT);
+        if (limit === null)
+            return;
+        const offset = readBoundedInt(response, url.searchParams.get('offset'), 'offset', 0, MAX_DISPATCH_OFFSET);
+        if (offset === null)
+            return;
+        const options = {
+            limit,
+            offset,
+            ...(state ? { status: state } : {}),
+        };
+        sendJson(response, 200, store.listDispatches(workspaceId, options).map(serializeDispatchRecord));
+    }),
+];

package/dist/src/server/routes-fs.d.ts

@@ -0,0 +1,2 @@
+import type { RouteDefinition } from './route-types.js';
+export declare const fsRoutes: RouteDefinition[];

package/dist/src/server/routes-fs.js

@@ -0,0 +1,24 @@
+import { browseDirectory, probeDirectory } from './fs-browse.js';
+import { route, sendJson } from './route-helpers.js';
+import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
+const readPathParam = (request) => {
+    const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+    return url.searchParams.get('path') ?? '';
+};
+export const fsRoutes = [
+    route('GET', '/api/fs/browse', async ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const body = await browseDirectory(readPathParam(request));
+        sendJson(response, body.ok ? 200 : 400, body);
+    }),
+    route('GET', '/api/fs/probe', async ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const body = await probeDirectory(readPathParam(request));
+        sendJson(response, 200, body);
+    }),
+    route('POST', '/api/fs/pick-folder', async ({ pickFolderService, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const body = await pickFolderService();
+        sendJson(response, 200, body);
+    }),
+];

package/dist/src/server/routes-marketplace.d.ts

@@ -0,0 +1,2 @@
+import type { RouteDefinition } from './route-types.js';
+export declare const marketplaceRoutes: RouteDefinition[];