hivehq 2.0.0

package/dist/src/server/routes-workflow-schedules.js

@@ -0,0 +1,58 @@
+import { validateCronNextRunAt } from './cron-util.js';
+import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
+import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
+import { serializeWorkflowSchedule } from './workflow-http-serializers.js';
+// Schedules are CREATED by the orchestrator agent (`team workflow schedule`),
+// which persists the workflow source so cron can fire it with no orchestrator
+// in the loop. The UI only LISTS / PAUSES / RESUMES / DELETES them — there is
+// no human create route here.
+export const workflowScheduleRoutes = [
+    route('GET', '/api/workspaces/:workspaceId/workflow-schedules', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Missing workspaceId');
+        if (!workspaceId)
+            return;
+        sendJson(response, 200, {
+            schedules: store.listWorkspaceWorkflowSchedules(workspaceId).map(serializeWorkflowSchedule),
+        });
+    }),
+    route('PATCH', '/api/workflow-schedules/:scheduleId', async ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const scheduleId = getRequiredParam(response, params, 'scheduleId', 'Missing scheduleId');
+        if (!scheduleId)
+            return;
+        const existing = store.getWorkflowSchedule(scheduleId);
+        if (!existing) {
+            sendJson(response, 404, { error: `Schedule not found: ${scheduleId}` });
+            return;
+        }
+        const body = await readJsonBody(request);
+        const update = {};
+        if (typeof body.cron === 'string') {
+            update.cron = body.cron;
+            update.nextRunAt = validateCronNextRunAt(body.cron);
+        }
+        if (body.args !== undefined)
+            update.args = body.args;
+        if (typeof body.enabled === 'boolean')
+            update.enabled = body.enabled;
+        store.updateWorkflowSchedule(scheduleId, update);
+        const refreshed = store.getWorkflowSchedule(scheduleId);
+        sendJson(response, 200, {
+            schedule: refreshed ? serializeWorkflowSchedule(refreshed) : null,
+        });
+    }),
+    route('DELETE', '/api/workflow-schedules/:scheduleId', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const scheduleId = getRequiredParam(response, params, 'scheduleId', 'Missing scheduleId');
+        if (!scheduleId)
+            return;
+        const existing = store.getWorkflowSchedule(scheduleId);
+        if (!existing) {
+            sendJson(response, 404, { error: `Schedule not found: ${scheduleId}` });
+            return;
+        }
+        store.deleteWorkflowSchedule(scheduleId);
+        sendJson(response, 200, { ok: true });
+    }),
+];

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

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

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

@@ -0,0 +1,83 @@
+import { getRequiredParam, route, sendJson } from './route-helpers.js';
+import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
+import { serializeWorkflowDispatch, serializeWorkflowRun } from './workflow-http-serializers.js';
+// Workflows are authored and fired by the orchestrator agent (`team workflow
+// run` / `team workflow schedule`), never from a human script library — so the
+// UI surface here is purely OBSERVABILITY + run control (list / get / stop /
+// per-agent dispatch timeline / narrator logs). There is no list-scripts,
+// start-by-path, template-install, or source-editor route.
+export const workflowRoutes = [
+    route('GET', '/api/workspaces/:workspaceId/workflows/runs', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Missing workspaceId');
+        if (!workspaceId)
+            return;
+        sendJson(response, 200, {
+            runs: store.listWorkspaceWorkflowRuns(workspaceId).map(serializeWorkflowRun),
+        });
+    }),
+    route('GET', '/api/workflows/runs/:runId', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const runId = getRequiredParam(response, params, 'runId', 'Missing runId');
+        if (!runId)
+            return;
+        const run = store.getWorkflowRun(runId);
+        if (!run) {
+            sendJson(response, 404, { error: `Workflow run not found: ${runId}` });
+            return;
+        }
+        sendJson(response, 200, { run: serializeWorkflowRun(run) });
+    }),
+    route('POST', '/api/workflows/runs/:runId/stop', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const runId = getRequiredParam(response, params, 'runId', 'Missing runId');
+        if (!runId)
+            return;
+        const run = store.getWorkflowRun(runId);
+        if (!run) {
+            sendJson(response, 404, { error: `Workflow run not found: ${runId}` });
+            return;
+        }
+        const stopped = store.stopWorkflowRun(runId);
+        sendJson(response, stopped ? 202 : 409, {
+            ok: stopped,
+            ...(stopped ? {} : { error: `Run is not running (status=${run.status})` }),
+        });
+    }),
+    route('GET', '/api/workflows/runs/:runId/dispatches', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const runId = getRequiredParam(response, params, 'runId', 'Missing runId');
+        if (!runId)
+            return;
+        const run = store.getWorkflowRun(runId);
+        if (!run) {
+            sendJson(response, 404, { error: `Workflow run not found: ${runId}` });
+            return;
+        }
+        /* TIER 2 #6 — enrich `submitted` dispatches with the worker's
+           lastPtyLine so the Drawer can show what each ephemeral worker is
+           currently doing (without forcing the user to jump to the
+           worker's terminal pane). For reported/cancelled rows the report
+           text is already authoritative, no need to also surface PTY noise. */
+        const dispatches = store.listWorkflowRunDispatches(runId).map((d) => {
+            if (d.status !== 'submitted')
+                return d;
+            const lastPtyLine = store.getLastPtyLineForAgent(run.workspaceId, d.toAgentId);
+            return lastPtyLine === null ? d : { ...d, lastPtyLine };
+        });
+        sendJson(response, 200, { dispatches: dispatches.map(serializeWorkflowDispatch) });
+    }),
+    /* TIER 2 #3 — narrator lane. Drawer polls this alongside dispatches.
+       Same auth path; same 404 semantics. */
+    route('GET', '/api/workflows/runs/:runId/logs', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const runId = getRequiredParam(response, params, 'runId', 'Missing runId');
+        if (!runId)
+            return;
+        if (!store.getWorkflowRun(runId)) {
+            sendJson(response, 404, { error: `Workflow run not found: ${runId}` });
+            return;
+        }
+        sendJson(response, 200, { logs: store.listWorkflowRunLogs(runId) });
+    }),
+];

package/dist/src/server/routes-workspace-memory-dreams.d.ts

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

package/dist/src/server/routes-workspace-memory-dreams.js

@@ -0,0 +1,105 @@
+import { BadRequestError, ConflictError } from './http-errors.js';
+import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
+import { serializeDreamRun } from './team-memory-dream-http-serializers.js';
+import { DreamRunAlreadyRunningError, DreamRunNotFoundError, DreamRunRevertDataError, DreamRunRevertStatusError, DreamWorkspaceMissingError, } from './team-memory-dream-store.js';
+import { readWorkspaceMemoryDreamEnabled, readWorkspaceMemoryEnabled, workspaceMemoryDreamEnabledKey, workspaceMemoryEnabledKey, } from './team-memory-feature.js';
+import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
+const DREAM_RUN_LIST_MAX_LIMIT = 50;
+const requireWorkspace = (response, store, workspaceId) => {
+    if (store.listWorkspaces().some((workspace) => workspace.id === workspaceId))
+        return true;
+    sendJson(response, 404, { error: `Workspace not found: ${workspaceId}` });
+    return false;
+};
+const requireDreamEnabled = (store, workspaceId) => {
+    const memoryEnabled = readWorkspaceMemoryEnabled(store.settings.getAppState(workspaceMemoryEnabledKey(workspaceId))?.value);
+    const dreamEnabled = readWorkspaceMemoryDreamEnabled(store.settings.getAppState(workspaceMemoryDreamEnabledKey(workspaceId))?.value);
+    if (!memoryEnabled)
+        throw new ConflictError('Workspace memory is disabled');
+    if (!dreamEnabled)
+        throw new ConflictError('Workspace memory dream is disabled');
+};
+const hasRequestBody = (request) => {
+    const rawContentLength = request.headers['content-length'];
+    const contentLength = Array.isArray(rawContentLength) ? rawContentLength[0] : rawContentLength;
+    return contentLength !== undefined && Number(contentLength) > 0;
+};
+const parseLimit = (value) => {
+    if (value === null)
+        return 20;
+    if (!/^(0|[1-9][0-9]*)$/.test(value)) {
+        throw new BadRequestError('limit must be a non-negative integer');
+    }
+    return Math.min(Number(value), DREAM_RUN_LIST_MAX_LIMIT);
+};
+export const workspaceMemoryDreamRoutes = [
+    route('GET', '/api/ui/workspaces/:workspaceId/memory/dream-runs', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Missing workspaceId');
+        if (!workspaceId)
+            return;
+        if (!requireWorkspace(response, store, workspaceId))
+            return;
+        const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+        const runs = store.listMemoryDreamRuns(workspaceId, parseLimit(url.searchParams.get('limit')));
+        sendJson(response, 200, { ok: true, runs: runs.map(serializeDreamRun) });
+    }),
+    route('POST', '/api/ui/workspaces/:workspaceId/memory/dream-runs', async ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Missing workspaceId');
+        if (!workspaceId)
+            return;
+        if (!requireWorkspace(response, store, workspaceId))
+            return;
+        requireDreamEnabled(store, workspaceId);
+        if (hasRequestBody(request))
+            await readJsonBody(request);
+        try {
+            const run = await store.runMemoryDream(workspaceId);
+            sendJson(response, 200, { ok: true, run: serializeDreamRun(run) });
+        }
+        catch (error) {
+            if (error instanceof DreamRunAlreadyRunningError) {
+                sendJson(response, 409, { error: 'Workspace already has a running dream run' });
+                return;
+            }
+            if (error instanceof DreamWorkspaceMissingError) {
+                sendJson(response, 404, { error: `Workspace not found: ${error.workspaceId}` });
+                return;
+            }
+            throw error;
+        }
+    }),
+    route('POST', '/api/ui/workspaces/:workspaceId/memory/dream-runs/:runId/revert', async ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Missing workspaceId');
+        const runId = getRequiredParam(response, params, 'runId', 'Missing runId');
+        if (!workspaceId || !runId)
+            return;
+        if (!requireWorkspace(response, store, workspaceId))
+            return;
+        if (hasRequestBody(request))
+            await readJsonBody(request);
+        try {
+            const run = store.revertMemoryDream(workspaceId, runId);
+            sendJson(response, 200, { ok: true, run: serializeDreamRun(run) });
+        }
+        catch (error) {
+            if (error instanceof DreamRunNotFoundError) {
+                sendJson(response, 404, { error: `Dream run not found: ${error.runId}` });
+                return;
+            }
+            if (error instanceof DreamRunRevertDataError) {
+                sendJson(response, 409, { error: 'Dream run cannot be reverted from stored data' });
+                return;
+            }
+            if (error instanceof DreamRunRevertStatusError) {
+                sendJson(response, 409, {
+                    error: `Dream run has status ${error.actualStatus}; expected ${error.expectedStatus}`,
+                });
+                return;
+            }
+            throw error;
+        }
+    }),
+];

package/dist/src/server/routes-workspace-memory.d.ts

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

package/dist/src/server/routes-workspace-memory.js

@@ -0,0 +1,215 @@
+import { MEMORY_QUERY_MAX_CHARS, MEMORY_SEARCH_MAX_LIMIT } from '../shared/team-memory.js';
+import { BadRequestError } from './http-errors.js';
+import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
+import { readWorkspaceMemoryDreamEnabled, readWorkspaceMemoryEnabled, serializeWorkspaceMemoryDreamEnabled, serializeWorkspaceMemoryEnabled, workspaceMemoryDreamEnabledKey, workspaceMemoryEnabledKey, } from './team-memory-feature.js';
+import { serializeMemoryEntry, serializeMemoryInjection } from './team-memory-http-serializers.js';
+import { MemoryEntryNotFoundError, MemoryEntryStatusError, } from './team-memory-store.js';
+import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
+const MEMORY_STATUSES = ['active', 'candidate', 'archived', 'rejected'];
+const parseLimit = (value) => {
+    if (value === null)
+        return MEMORY_SEARCH_MAX_LIMIT;
+    if (!/^(0|[1-9][0-9]*)$/.test(value)) {
+        throw new BadRequestError('limit must be a non-negative integer');
+    }
+    return Math.min(Number(value), MEMORY_SEARCH_MAX_LIMIT);
+};
+const parseStatuses = (value) => {
+    if (value === null)
+        return ['active'];
+    if (value === 'all')
+        return MEMORY_STATUSES;
+    if (MEMORY_STATUSES.includes(value))
+        return [value];
+    throw new BadRequestError('status must be active, candidate, archived, rejected, or all');
+};
+const parseQuery = (value) => {
+    const query = value?.trim() ?? '';
+    if ([...query].length > MEMORY_QUERY_MAX_CHARS) {
+        throw new BadRequestError(`query must be ${MEMORY_QUERY_MAX_CHARS} characters or fewer`);
+    }
+    return query;
+};
+const requireBoolean = (value, field) => {
+    if (typeof value !== 'boolean')
+        throw new BadRequestError(`${field} must be a boolean`);
+    return value;
+};
+const sendMemoryMutationError = (response, error) => {
+    if (error instanceof MemoryEntryNotFoundError) {
+        sendJson(response, 404, { error: `Memory entry not found: ${error.memoryId}` });
+        return true;
+    }
+    if (error instanceof MemoryEntryStatusError) {
+        sendJson(response, 409, {
+            error: `Memory entry has status ${error.actualStatus}; expected ${Array.isArray(error.expectedStatus)
+                ? error.expectedStatus.join(' or ')
+                : error.expectedStatus}`,
+        });
+        return true;
+    }
+    return false;
+};
+const getMemoryId = (response, params) => getRequiredParam(response, params, 'memoryId', 'Missing memoryId');
+const requireWorkspace = (response, store, workspaceId) => {
+    if (store.listWorkspaces().some((workspace) => workspace.id === workspaceId))
+        return true;
+    sendJson(response, 404, { error: `Workspace not found: ${workspaceId}` });
+    return false;
+};
+export const workspaceMemoryRoutes = [
+    route('GET', '/api/ui/workspaces/:workspaceId/memory', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Missing workspaceId');
+        if (!workspaceId)
+            return;
+        if (!requireWorkspace(response, store, workspaceId))
+            return;
+        const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+        const statuses = parseStatuses(url.searchParams.get('status'));
+        const limit = parseLimit(url.searchParams.get('limit'));
+        const query = parseQuery(url.searchParams.get('query'));
+        const memories = query
+            ? store.searchMemoryEntries(workspaceId, query, {
+                includeDisabled: true,
+                limit,
+                statuses,
+            })
+            : store.listMemoryEntries(workspaceId, { limit, statuses });
+        sendJson(response, 200, { memories: memories.map(serializeMemoryEntry), ok: true });
+    }),
+    route('GET', '/api/ui/workspaces/:workspaceId/memory/injections', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Missing workspaceId');
+        if (!workspaceId)
+            return;
+        if (!requireWorkspace(response, store, workspaceId))
+            return;
+        const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+        const dispatchId = url.searchParams.get('dispatch_id')?.trim();
+        if (!dispatchId)
+            throw new BadRequestError('Missing dispatch_id');
+        sendJson(response, 200, {
+            injections: store
+                .listMemoryInjectionsForDispatch(workspaceId, dispatchId)
+                .map(serializeMemoryInjection),
+            ok: true,
+        });
+    }),
+    route('GET', '/api/ui/workspaces/:workspaceId/memory/settings', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Missing workspaceId');
+        if (!workspaceId)
+            return;
+        if (!requireWorkspace(response, store, workspaceId))
+            return;
+        sendJson(response, 200, {
+            dream_enabled: readWorkspaceMemoryDreamEnabled(store.settings.getAppState(workspaceMemoryDreamEnabledKey(workspaceId))?.value),
+            enabled: readWorkspaceMemoryEnabled(store.settings.getAppState(workspaceMemoryEnabledKey(workspaceId))?.value),
+            ok: true,
+        });
+    }),
+    route('PUT', '/api/ui/workspaces/:workspaceId/memory/settings', async ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Missing workspaceId');
+        if (!workspaceId)
+            return;
+        if (!requireWorkspace(response, store, workspaceId))
+            return;
+        const body = await readJsonBody(request);
+        if (body.enabled !== undefined) {
+            store.settings.setAppState(workspaceMemoryEnabledKey(workspaceId), serializeWorkspaceMemoryEnabled(requireBoolean(body.enabled, 'enabled')));
+        }
+        if (body.dream_enabled !== undefined) {
+            store.settings.setAppState(workspaceMemoryDreamEnabledKey(workspaceId), serializeWorkspaceMemoryDreamEnabled(requireBoolean(body.dream_enabled, 'dream_enabled')));
+        }
+        sendJson(response, 200, {
+            dream_enabled: readWorkspaceMemoryDreamEnabled(store.settings.getAppState(workspaceMemoryDreamEnabledKey(workspaceId))?.value),
+            enabled: readWorkspaceMemoryEnabled(store.settings.getAppState(workspaceMemoryEnabledKey(workspaceId))?.value),
+            ok: true,
+        });
+    }),
+    route('PATCH', '/api/ui/workspaces/:workspaceId/memory/:memoryId', async ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Missing workspaceId');
+        const memoryId = getMemoryId(response, params);
+        if (!workspaceId || !memoryId)
+            return;
+        if (!requireWorkspace(response, store, workspaceId))
+            return;
+        const body = await readJsonBody(request);
+        try {
+            let memory = store.getMemoryEntry(workspaceId, memoryId);
+            if (!memory)
+                throw new MemoryEntryNotFoundError(memoryId, workspaceId);
+            if (body.pinned !== undefined) {
+                memory = store.setMemoryPinned(workspaceId, memoryId, requireBoolean(body.pinned, 'pinned'));
+            }
+            if (body.disabled !== undefined) {
+                memory = store.setMemoryDisabled(workspaceId, memoryId, requireBoolean(body.disabled, 'disabled'));
+            }
+            sendJson(response, 200, { memory: serializeMemoryEntry(memory), ok: true });
+        }
+        catch (error) {
+            if (!sendMemoryMutationError(response, error))
+                throw error;
+        }
+    }),
+    route('POST', '/api/ui/workspaces/:workspaceId/memory/:memoryId/approve', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Missing workspaceId');
+        const memoryId = getMemoryId(response, params);
+        if (!workspaceId || !memoryId)
+            return;
+        if (!requireWorkspace(response, store, workspaceId))
+            return;
+        try {
+            sendJson(response, 200, {
+                memory: serializeMemoryEntry(store.approveMemoryCandidate(workspaceId, memoryId)),
+                ok: true,
+            });
+        }
+        catch (error) {
+            if (!sendMemoryMutationError(response, error))
+                throw error;
+        }
+    }),
+    route('POST', '/api/ui/workspaces/:workspaceId/memory/:memoryId/reject', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Missing workspaceId');
+        const memoryId = getMemoryId(response, params);
+        if (!workspaceId || !memoryId)
+            return;
+        if (!requireWorkspace(response, store, workspaceId))
+            return;
+        try {
+            sendJson(response, 200, {
+                memory: serializeMemoryEntry(store.rejectMemoryCandidate(workspaceId, memoryId)),
+                ok: true,
+            });
+        }
+        catch (error) {
+            if (!sendMemoryMutationError(response, error))
+                throw error;
+        }
+    }),
+    route('POST', '/api/ui/workspaces/:workspaceId/memory/:memoryId/archive', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Missing workspaceId');
+        const memoryId = getMemoryId(response, params);
+        if (!workspaceId || !memoryId)
+            return;
+        if (!requireWorkspace(response, store, workspaceId))
+            return;
+        try {
+            sendJson(response, 200, {
+                memory: serializeMemoryEntry(store.archiveMemoryEntry(workspaceId, memoryId)),
+                ok: true,
+            });
+        }
+        catch (error) {
+            if (!sendMemoryMutationError(response, error))
+                throw error;
+        }
+    }),
+];

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

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

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

@@ -0,0 +1,177 @@
+import { resolveCommandPresetLaunchConfig, resolveStartupCommandLaunchConfig, } from './agent-launch-resolver.js';
+import { autostartAgent, autostartOrchestrator } from './orchestrator-autostart.js';
+import { seedOrchestratorLaunchConfig } from './orchestrator-launch.js';
+import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
+import { authenticateCliAgent, requireCommandForRole } from './team-authz.js';
+import { enrichTeamList } from './team-list-enrichment.js';
+import { serializeTeamListItem } from './team-list-serializer.js';
+import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
+import { validateWorkspacePath } from './workspace-path-validation.js';
+import { getOrchestratorId } from './workspace-store-support.js';
+const getSerializedWorker = (workspaceId, workerId, store) => {
+    const worker = store.listWorkers(workspaceId).find((item) => item.id === workerId);
+    if (!worker) {
+        throw new Error(`Worker not found: ${workerId}`);
+    }
+    const [enriched] = enrichTeamList(workspaceId, store, [worker]);
+    if (!enriched)
+        throw new Error(`Worker enrichment failed: ${workerId}`);
+    return serializeTeamListItem(enriched);
+};
+const getRuntimePort = (request) => String(request.socket.localPort ?? '');
+export const workspaceRoutes = [
+    route('GET', '/api/workspaces', ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        sendJson(response, 200, store.listWorkspaces());
+    }),
+    route('POST', '/api/workspaces', async ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const body = await readJsonBody(request);
+        const startupCommand = typeof body.startup_command === 'string' ? body.startup_command : null;
+        const workspacePath = validateWorkspacePath(body.path);
+        const workspace = store.createWorkspace(workspacePath, body.name);
+        seedOrchestratorLaunchConfig(store, store.settings, workspace.id, body.command_preset_id ?? null, startupCommand);
+        const autostart = body.autostart_orchestrator !== false;
+        if (!autostart) {
+            sendJson(response, 201, {
+                ...workspace,
+                orchestrator_start: { ok: false, error: null, run_id: null },
+            });
+            return;
+        }
+        // Spawn failure must NOT block workspace creation — see AGENTS.md §1
+        // (no try/catch fallbacks in production code, but `autostartOrchestrator`
+        // captures the failure as a structured result instead of throwing).
+        const orchestratorStart = await autostartOrchestrator(store, workspace.id, getOrchestratorId(workspace.id), getRuntimePort(request));
+        sendJson(response, 201, { ...workspace, orchestrator_start: orchestratorStart });
+    }),
+    route('DELETE', '/api/workspaces/:workspaceId', async ({ params, request, response, store }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');
+        if (!workspaceId) {
+            return;
+        }
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        await store.deleteWorkspace(workspaceId);
+        response.statusCode = 204;
+        response.end();
+    }),
+    route('GET', '/api/ui/workspaces/:workspaceId/team', ({ params, request, response, store }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');
+        if (!workspaceId) {
+            return;
+        }
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        sendJson(response, 200, enrichTeamList(workspaceId, store, store.listWorkers(workspaceId)).map(serializeTeamListItem));
+    }),
+    route('GET', '/api/workspaces/:workspaceId/team', ({ params, request, response, store }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');
+        if (!workspaceId) {
+            return;
+        }
+        const agentId = request.headers['x-hive-agent-id'];
+        const token = request.headers['x-hive-agent-token'];
+        const agent = authenticateCliAgent({
+            fromAgentId: typeof agentId === 'string' ? agentId : undefined,
+            getAgent: store.getAgent,
+            token: typeof token === 'string' ? token : undefined,
+            validateToken: store.validateAgentToken,
+            workspaceId,
+        });
+        requireCommandForRole(agent, 'list');
+        // The orchestrator polling `team list` is its natural post-restart wakeup:
+        // flush any reports a prior outage stranded back into its stdin now that
+        // it is reachable again. Cheap (indexed, usually empty) and a safe no-op
+        // for non-orchestrator callers.
+        store.drainReportOutbox(workspaceId);
+        sendJson(response, 200, enrichTeamList(workspaceId, store, store.listWorkers(workspaceId)).map(serializeTeamListItem));
+    }),
+    route('POST', '/api/workspaces/:workspaceId/workers', async ({ params, request, response, store }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');
+        if (!workspaceId) {
+            return;
+        }
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const body = await readJsonBody(request);
+        const presetId = body.command_preset_id ?? null;
+        const startupCommand = typeof body.startup_command === 'string' ? body.startup_command : null;
+        const launchConfig = startupCommand?.trim()
+            ? resolveStartupCommandLaunchConfig(store.settings, startupCommand, presetId)
+            : presetId
+                ? resolveCommandPresetLaunchConfig(store.settings, presetId)
+                : undefined;
+        if (presetId && !startupCommand?.trim() && !launchConfig) {
+            throw new Error(`Command preset not found: ${presetId}`);
+        }
+        const worker = store.addWorker(workspaceId, body);
+        if (launchConfig) {
+            try {
+                store.configureAgentLaunch(workspaceId, worker.id, launchConfig);
+            }
+            catch (error) {
+                store.deleteWorker(workspaceId, worker.id);
+                throw error;
+            }
+        }
+        const agentStart = body.autostart === true
+            ? await autostartAgent(store, workspaceId, worker.id, getRuntimePort(request), {
+                missingConfigError: 'No worker launch config available',
+            })
+            : { ok: false, error: null, run_id: null };
+        sendJson(response, 201, {
+            ...getSerializedWorker(workspaceId, worker.id, store),
+            agent_start: agentStart,
+        });
+    }),
+    route('DELETE', '/api/workspaces/:workspaceId/workers/:workerId', ({ params, request, response, store }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id and worker id are required');
+        const workerId = getRequiredParam(response, params, 'workerId', 'Workspace id and worker id are required');
+        if (!workspaceId || !workerId) {
+            return;
+        }
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        store.deleteWorker(workspaceId, workerId);
+        response.statusCode = 204;
+        response.end();
+    }),
+    route('PATCH', '/api/workspaces/:workspaceId/workers/:workerId', async ({ params, request, response, store }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id and worker id are required');
+        const workerId = getRequiredParam(response, params, 'workerId', 'Workspace id and worker id are required');
+        if (!workspaceId || !workerId) {
+            return;
+        }
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const body = await readJsonBody(request);
+        if (typeof body.name !== 'string') {
+            sendJson(response, 400, { error: 'name is required' });
+            return;
+        }
+        store.renameWorker(workspaceId, workerId, body.name);
+        sendJson(response, 200, getSerializedWorker(workspaceId, workerId, store));
+    }),
+    route('POST', '/api/workspaces/:workspaceId/user-input', async ({ params, request, response, store }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');
+        if (!workspaceId) {
+            return;
+        }
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const body = await readJsonBody(request);
+        store.recordUserInput(workspaceId, `${workspaceId}:orchestrator`, body.text);
+        sendJson(response, 202, { ok: true });
+    }),
+    route('POST', '/api/workspaces/:workspaceId/agents/:agentId/start', async ({ params, request, response, store }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id and agent id are required');
+        const agentId = getRequiredParam(response, params, 'agentId', 'Workspace id and agent id are required');
+        if (!workspaceId || !agentId) {
+            return;
+        }
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        if (agentId === getOrchestratorId(workspaceId) &&
+            !store.peekAgentLaunchConfig(workspaceId, agentId)) {
+            seedOrchestratorLaunchConfig(store, store.settings, workspaceId);
+        }
+        const run = await store.startAgent(workspaceId, agentId, {
+            hivePort: getRuntimePort(request),
+        });
+        sendJson(response, 201, { run_id: run.runId });
+    }),
+];