npm - hivehq - Versions diffs - 2.0.0 - Mend

hivehq 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (883) hide show

package/dist/src/server/agent-startup-instructions.js ADDED Viewed

@@ -0,0 +1,36 @@
+import { FEATURE_FLAGS_ALL_OFF } from './feature-flags.js';
+import { getHiveTeamRules } from './hive-team-guidance.js';
+import { TASKS_RELATIVE_PATH } from './tasks-file.js';
+export const buildAgentSessionBindingMarker = ({ agent, workspace, }) => `Hive session binding: workspace_id=${workspace.id}; agent_id=${agent.id}`;
+export const buildAgentLegacyIdentityMarker = ({ agent, workspace, }) => `You are ${agent.name} (${agent.role}) in workspace ${workspace.name}.`;
+export const buildAgentStartupInstructions = ({ agent, memoryDigest, workspace, flags = FEATURE_FLAGS_ALL_OFF, }) => {
+    const { workflowsEnabled } = flags;
+    const lines = [
+        '<hive-message kind="startup">',
+        '',
+        buildAgentLegacyIdentityMarker({ agent, workspace }),
+        `Current workspace: ${workspace.name}`,
+        `Project path: ${workspace.path}`,
+        buildAgentSessionBindingMarker({ agent, workspace }),
+        '',
+        // agent.description is the role contract — it follows the user's chosen
+        // language / custom edit and is intentionally left as authored.
+        `Your role: ${agent.description}`,
+        '',
+    ];
+    if (memoryDigest) {
+        lines.push(memoryDigest, '');
+    }
+    if (agent.role === 'orchestrator') {
+        lines.push('Your responsibilities:', '- Respond to the user directly; clarify the goal and break it into dispatchable tasks', `- Maintain ${TASKS_RELATIVE_PATH}`, '- Dispatch by worker name and drive the next step from each report', '', 'Available team commands:', '- team list', '- team recall "<query>" [--limit <n>] [--window <n>]', '- team memory add "<body>" [--kind fact|preference|decision|pitfall|procedure_ref] [--tag <tag>]', '- team memory show <memory-id>', '- team memory search "<query>" [--limit <n>]', '- team memory forget <memory-id>', '- team send "<worker-name>" "<task>"', '- team spawn <role> [--name <n>] [--cli claude|codex|opencode|gemini|hermes] [--ephemeral]', '- team cancel --dispatch <id> "<reason>"', ...(workflowsEnabled
+            ? [
+                '- team workflow run --stdin   (fan-out / staged work — see .hive/PROTOCOL.md for the DSL)',
+            ]
+            : []), '', 'Always dispatch by worker name, never by worker id.', 'Always cancel an open dispatch by its dispatch id.', 'Search memory before adding: use `team memory search "<query>"` to avoid duplicates.', 'Use `team memory add` only for rare, evidence-backed workspace facts/decisions/pitfalls that should help future Hive agents across sessions.', 'Nothing worth saving is a normal outcome; do not add memory just to prove you used it.', 'Use `team memory forget` only to archive obsolete workspace memory; it does not physically delete evidence.', '', 'Hive worker dispatch rules:', ...getHiveTeamRules(agent, flags));
+    }
+    else {
+        lines.push('Available team commands:', '- team report "<result>" [--dispatch <id>] [--artifact <path>]    report done / failed / blocked', '- team report --stdin [--dispatch <id>] [--artifact <path>]       same, body read from stdin (multi-line / quotes / special chars)', '- team status "<state>" [--artifact <path>]                       mid-task progress / standby / connected status', '- team status --stdin [--artifact <path>]                         same, body read from stdin', '- team recall "<query>" [--limit <n>] [--window <n>]               search prior team messages/reports in this workspace', '- team memory show <memory-id>                                     inspect a memory entry and its evidence', '- team memory search "<query>" [--limit <n>]                         search active workspace memory', '- team list                                                       list the workspace workers (with status)', '- team --help                                                     command syntax only; NOT a way to report', '', 'Syntax notes:', '- The body is the first positional argument; flag order is free: `team report "result" --dispatch X` and `team report --dispatch X "result"` are both valid.', "- Long bodies (multi-line / quotes / shell metacharacters) always go through `--stdin`, piped in via your shell (POSIX: a quoted heredoc `<<'EOF' … EOF` to stop $var / backtick expansion; Windows cmd: `type body.txt |` or `< body.txt`; PowerShell: `Get-Content -Raw -Encoding utf8 body.txt |`). `--stdin` only reads from stdin and relies on no shell syntax of its own.", '- On error the CLI also prints USAGE — fix the arguments against it.', '', 'When a task is done you MUST run `team report "<result>"`.', 'Failure, blocked, or partial completion are also reported with `team report "<current state and reason>"`.', 'When no task is in progress, report connection / standby / blocked state with `team status "<state>"`.', 'Use `team recall "<query>"` when prior team messages or reports may contain useful evidence.', 'Use `team memory search "<query>"` to look up active durable workspace memory.', 'Include durable findings in `team report`; workers cannot add or forget memory.', 'Do not call team send; workers cannot dispatch to each other.', '', 'Hive worker boundaries:', ...getHiveTeamRules(agent, flags));
+    }
+    lines.push('', '</hive-message>', '');
+    return lines.join('\n');
+};

package/dist/src/server/agent-stdin-dispatcher.d.ts ADDED Viewed

@@ -0,0 +1,52 @@
+import type { AgentManager } from './agent-manager.js';
+import type { AgentLaunchConfigInput } from './agent-run-store.js';
+import type { LiveAgentRun } from './agent-runtime-types.js';
+import { type FeatureFlags } from './feature-flags.js';
+import type { LiveRunRegistry } from './live-run-registry.js';
+import { type TeamMemoryInjectionService } from './team-memory-injection.js';
+interface AgentStdinDispatcherInput {
+    agentManager: AgentManager | undefined;
+    getLaunchConfig: (workspaceId: string, agentId: string) => AgentLaunchConfigInput | undefined;
+    getWorkspaceId: (agentId: string) => string | undefined;
+    registry: LiveRunRegistry;
+    syncRun: (run: LiveAgentRun) => LiveAgentRun;
+    memoryInjection?: TeamMemoryInjectionService;
+    /** Resolves the live experimental flags. The orchestrator reminder tail
+     *  appended to every injected message reads `workflowsEnabled` from it.
+     *  Optional; omitted → all flags off. */
+    getFlags?: () => FeatureFlags;
+}
+export declare const buildOrchestratorReportPayload: (workerName: string, text: string, artifacts: string[], flags?: FeatureFlags) => string;
+export declare const buildOrchestratorStatusPayload: (workerName: string, text: string, artifacts: string[], flags?: FeatureFlags) => string;
+export declare const buildOrchestratorUserInputPayload: (text: string, flags?: FeatureFlags) => string;
+export declare const buildWorkerDispatchPayload: (fromAgentName: string, workerDescription: string, dispatchId: string, text: string, memoryDigest?: string | null) => string;
+export declare const buildWorkerCancelPayload: (dispatchId: string, reason: string) => string;
+export declare const createAgentStdinDispatcher: ({ agentManager, getLaunchConfig, getWorkspaceId, registry, syncRun, memoryInjection, getFlags, }: AgentStdinDispatcherInput) => {
+    writeReportPrompt(workspaceId: string, workerName: string, text: string, artifacts: string[], input?: {
+        requireActiveRun?: boolean;
+    }): void;
+    writeStatusPrompt(workspaceId: string, workerName: string, text: string, artifacts: string[], input?: {
+        requireActiveRun?: boolean;
+    }): void;
+    writeSendPrompt(workspaceId: string, workerId: string, dispatchId: string, fromAgentName: string, workerDescription: string, text: string): Promise<void>;
+    writeCancelPrompt(workspaceId: string, workerId: string, dispatchId: string, reason: string, input?: {
+        requireActiveRun?: boolean;
+    }): void;
+    writeUserInputPrompt(workspaceId: string, text: string): void;
+    /** Generic: deliver an opaque text block to a specific agent's PTY.
+     *  Used by the workflow runner to notify the triggering orchestrator
+     *  when a run finishes (mirrors Claude Code's <task-notification>). */
+    writeSystemMessageToAgent(workspaceId: string, agentId: string, text: string): void;
+    /** Awaitable report delivery — same payload as writeReportPrompt but the
+     *  promise is returned so the caller can persist the report to the
+     *  redelivery outbox if the orchestrator PTY write rejects. */
+    deliverReportToOrchestrator(workspaceId: string, workerName: string, text: string, artifacts: string[], input?: {
+        requireActiveRun?: boolean;
+    }): Promise<void>;
+    /** Awaitable opaque delivery — used to drain the report outbox so an entry
+     *  is marked delivered only after the PTY write actually resolves. */
+    deliverSystemMessageToAgent(workspaceId: string, agentId: string, text: string, input?: {
+        requireActiveRun?: boolean;
+    }): Promise<void>;
+};
+export {};

package/dist/src/server/agent-stdin-dispatcher.js ADDED Viewed

@@ -0,0 +1,224 @@
+import { FEATURE_FLAGS_ALL_OFF } from './feature-flags.js';
+import { buildOrchestratorReminderTail, buildWorkerReminderTail } from './hive-team-guidance.js';
+import { PtyInactiveError } from './http-errors.js';
+import { createPostStartInputWriter } from './post-start-input-writer.js';
+import { buildDispatchMemoryDigestSafely, logMemoryDigestInjection, rollbackMemoryDigestInjection, } from './team-memory-injection.js';
+export const buildOrchestratorReportPayload = (workerName, text, artifacts, flags = FEATURE_FLAGS_ALL_OFF) => {
+    const lines = [`<hive-message kind="report" from="@${workerName}">`, text];
+    for (const artifact of artifacts)
+        lines.push(`artifact: ${artifact}`);
+    lines.push('</hive-message>', '', buildOrchestratorReminderTail(flags), '');
+    return lines.join('\n');
+};
+export const buildOrchestratorStatusPayload = (workerName, text, artifacts, flags = FEATURE_FLAGS_ALL_OFF) => {
+    const lines = [`<hive-message kind="status" from="@${workerName}">`, text];
+    for (const artifact of artifacts)
+        lines.push(`artifact: ${artifact}`);
+    lines.push('</hive-message>', '', buildOrchestratorReminderTail(flags), '');
+    return lines.join('\n');
+};
+export const buildOrchestratorUserInputPayload = (text, flags = FEATURE_FLAGS_ALL_OFF) => [text, '', buildOrchestratorReminderTail(flags), ''].join('\n');
+export const buildWorkerDispatchPayload = (fromAgentName, workerDescription, dispatchId, text, memoryDigest) => [
+    `<hive-message kind="dispatch" from="@${fromAgentName}">`,
+    '',
+    `Your role: ${workerDescription}`,
+    '',
+    'You must:',
+    `- When the task is done, failed, blocked, or partially done, run \`team report "<result>" --dispatch ${dispatchId}\``,
+    '- Do not do unrelated work; report as soon as you are done',
+    '',
+    `dispatch_id: ${dispatchId}`,
+    '',
+    ...(memoryDigest ? [memoryDigest, ''] : []),
+    'Task:',
+    text,
+    '</hive-message>',
+    '',
+    buildWorkerReminderTail(dispatchId),
+    '',
+].join('\n');
+export const buildWorkerCancelPayload = (dispatchId, reason) => [
+    `<hive-message kind="cancel" dispatch="${dispatchId}">`,
+    '',
+    'Stop working on this dispatch and do not call team report for it.',
+    '',
+    'Cancellation reason:',
+    reason,
+    '</hive-message>',
+    '',
+].join('\n');
+export const createAgentStdinDispatcher = ({ agentManager, getLaunchConfig, getWorkspaceId, registry, syncRun, memoryInjection, getFlags, }) => {
+    const flags = () => getFlags?.() ?? FEATURE_FLAGS_ALL_OFF;
+    const chains = new Map();
+    const getChain = (agentId) => {
+        let chain = chains.get(agentId);
+        if (!chain) {
+            chain = { busy: false, queue: [] };
+            chains.set(agentId, chain);
+        }
+        return chain;
+    };
+    const resolveActiveRun = (workspaceId, agentId) => registry
+        .list()
+        .filter((item) => item.agentId === agentId && getWorkspaceId(item.agentId) === workspaceId)
+        .sort((left, right) => right.startedAt - left.startedAt)
+        .find((item) => {
+        const status = syncRun(item).status;
+        return status === 'starting' || status === 'running';
+    });
+    // Synchronously enforce requireActiveRun (so writeSendPrompt still throws in
+    // the caller's stack when there is no live run), then return a thunk that
+    // re-resolves the run at EXECUTION time and performs the actual write,
+    // returning a promise that settles when the paste→submit sequence is done.
+    const prepareWrite = (workspaceId, agentId, text, input) => {
+        if (!resolveActiveRun(workspaceId, agentId)) {
+            if (input.requireActiveRun) {
+                throw new PtyInactiveError(`No active run for agent: ${agentId}`);
+            }
+            return () => Promise.resolve();
+        }
+        return () => {
+            const run = resolveActiveRun(workspaceId, agentId);
+            if (!run) {
+                if (input.requireActiveRun) {
+                    throw new PtyInactiveError(`No active run for agent: ${agentId}`);
+                }
+                return Promise.resolve();
+            }
+            try {
+                const config = getLaunchConfig(workspaceId, agentId);
+                if (agentManager && config) {
+                    return (createPostStartInputWriter(agentManager, config.interactiveCommand ?? config.command)(run.runId, text).catch((error) => {
+                        throw new PtyInactiveError(error instanceof Error ? error.message : String(error));
+                    }) ?? Promise.resolve());
+                }
+                agentManager?.writeInput(run.runId, text);
+                return Promise.resolve();
+            }
+            catch (error) {
+                throw new PtyInactiveError(error instanceof Error ? error.message : String(error));
+            }
+        };
+    };
+    const settle = (agentId, promise) => promise.finally(() => {
+        const chain = chains.get(agentId);
+        if (!chain)
+            return;
+        chain.busy = false;
+        drain(agentId);
+    });
+    const runQueuedWrite = (agentId, write) => {
+        try {
+            void settle(agentId, write.run()).then(write.resolve, write.reject);
+        }
+        catch (error) {
+            write.reject(error);
+            const chain = chains.get(agentId);
+            if (chain)
+                chain.busy = false;
+            drain(agentId);
+        }
+    };
+    function drain(agentId) {
+        const chain = chains.get(agentId);
+        if (!chain)
+            return;
+        if (chain.busy)
+            return;
+        const next = chain.queue.shift();
+        if (!next) {
+            chains.delete(agentId);
+            return;
+        }
+        chain.busy = true;
+        runQueuedWrite(agentId, next);
+    }
+    const writeToActiveAgentRun = (workspaceId, agentId, text, input = {}) => {
+        const thunk = prepareWrite(workspaceId, agentId, text, input);
+        const chain = getChain(agentId);
+        if (chain.busy) {
+            return new Promise((resolve, reject) => {
+                chain.queue.push({ reject, resolve, run: thunk });
+            });
+        }
+        chain.busy = true;
+        try {
+            return settle(agentId, thunk()); // uncontended: run now; immediate failures still throw
+        }
+        catch (error) {
+            chain.busy = false;
+            drain(agentId);
+            throw error;
+        }
+    };
+    const swallowQueuedFailure = (promise) => {
+        void promise.catch(() => {
+            // Deferred prompt writes can fail if the PTY exits while queued. Calls
+            // that require foreground error reporting use writeSendPrompt's promise.
+        });
+    };
+    return {
+        writeReportPrompt(workspaceId, workerName, text, artifacts, input = {}) {
+            swallowQueuedFailure(writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorReportPayload(workerName, text, artifacts, flags()), input));
+        },
+        writeStatusPrompt(workspaceId, workerName, text, artifacts, input = {}) {
+            swallowQueuedFailure(writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorStatusPayload(workerName, text, artifacts, flags()), input));
+        },
+        writeSendPrompt(workspaceId, workerId, dispatchId, fromAgentName, workerDescription, text) {
+            if (!resolveActiveRun(workspaceId, workerId)) {
+                throw new PtyInactiveError(`No active run for agent: ${workerId}`);
+            }
+            const memoryDigest = buildDispatchMemoryDigestSafely({
+                memoryInjection,
+                taskText: text,
+                workerDescription,
+                workspaceId,
+            });
+            const injectionIds = logMemoryDigestInjection({
+                agentId: workerId,
+                contextType: 'dispatch',
+                dispatchId,
+                memoryDigest,
+                memoryInjection,
+                workspaceId,
+            });
+            const rollback = () => rollbackMemoryDigestInjection({
+                injectionIds,
+                memoryInjection,
+            });
+            try {
+                return writeToActiveAgentRun(workspaceId, workerId, buildWorkerDispatchPayload(fromAgentName, workerDescription, dispatchId, text, injectionIds ? memoryDigest?.text : null), { requireActiveRun: true }).catch((error) => {
+                    rollback();
+                    throw error;
+                });
+            }
+            catch (error) {
+                rollback();
+                throw error;
+            }
+        },
+        writeCancelPrompt(workspaceId, workerId, dispatchId, reason, input = {}) {
+            swallowQueuedFailure(writeToActiveAgentRun(workspaceId, workerId, buildWorkerCancelPayload(dispatchId, reason), input));
+        },
+        writeUserInputPrompt(workspaceId, text) {
+            swallowQueuedFailure(writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorUserInputPayload(text, flags())));
+        },
+        /** Generic: deliver an opaque text block to a specific agent's PTY.
+         *  Used by the workflow runner to notify the triggering orchestrator
+         *  when a run finishes (mirrors Claude Code's <task-notification>). */
+        writeSystemMessageToAgent(workspaceId, agentId, text) {
+            swallowQueuedFailure(writeToActiveAgentRun(workspaceId, agentId, text));
+        },
+        /** Awaitable report delivery — same payload as writeReportPrompt but the
+         *  promise is returned so the caller can persist the report to the
+         *  redelivery outbox if the orchestrator PTY write rejects. */
+        deliverReportToOrchestrator(workspaceId, workerName, text, artifacts, input = {}) {
+            return writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorReportPayload(workerName, text, artifacts, flags()), input);
+        },
+        /** Awaitable opaque delivery — used to drain the report outbox so an entry
+         *  is marked delivered only after the PTY write actually resolves. */
+        deliverSystemMessageToAgent(workspaceId, agentId, text, input = {}) {
+            return writeToActiveAgentRun(workspaceId, agentId, text, input);
+        },
+    };
+};

package/dist/src/server/agent-tokens.d.ts ADDED Viewed

@@ -0,0 +1,15 @@
+export interface AgentTokenRegistry {
+    /**
+     * Mint a fresh token for this agent. A stale token from a prior run of the same agent
+     * is overwritten; subsequent validate() calls with the stale token will return false.
+     */
+    issue: (agentId: string) => string;
+    peek: (agentId: string) => string | undefined;
+    /**
+     * Revoke only if the currently registered token matches. Prevents a late onExit from
+     * an old run from wiping the fresh token of a new run.
+     */
+    revokeIfMatches: (agentId: string, token: string) => void;
+    validate: (agentId: string, token: string | undefined) => boolean;
+}
+export declare const createAgentTokenRegistry: () => AgentTokenRegistry;

package/dist/src/server/agent-tokens.js ADDED Viewed

@@ -0,0 +1,25 @@
+import { randomUUID } from 'node:crypto';
+export const createAgentTokenRegistry = () => {
+    const tokens = new Map();
+    return {
+        issue(agentId) {
+            const token = randomUUID();
+            tokens.set(agentId, token);
+            return token;
+        },
+        peek(agentId) {
+            return tokens.get(agentId);
+        },
+        revokeIfMatches(agentId, token) {
+            if (tokens.get(agentId) === token) {
+                tokens.delete(agentId);
+            }
+        },
+        validate(agentId, token) {
+            if (!token)
+                return false;
+            const expected = tokens.get(agentId);
+            return expected !== undefined && expected === token;
+        },
+    };
+};

package/dist/src/server/app-state-store.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+import type { Database } from 'better-sqlite3';
+export type AppStateValue = string | null;
+export interface AppStateRecord {
+    key: string;
+    value: AppStateValue;
+}
+export declare const createAppStateStore: (db: Database) => {
+    get: (key: string) => AppStateRecord | undefined;
+    set: (key: string, value: AppStateValue) => void;
+};

package/dist/src/server/app-state-store.js ADDED Viewed

@@ -0,0 +1,12 @@
+export const createAppStateStore = (db) => {
+    const get = (key) => {
+        const row = db.prepare('SELECT key, value FROM app_state WHERE key = ?').get(key);
+        return row ? { key: row.key, value: row.value } : undefined;
+    };
+    const set = (key, value) => {
+        db.prepare(`INSERT INTO app_state (key, value, updated_at)
+       VALUES (?, ?, ?)
+       ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`).run(key, value, Date.now());
+    };
+    return { get, set };
+};

package/dist/src/server/app.d.ts ADDED Viewed

@@ -0,0 +1,20 @@
+import { type IncomingMessage, type ServerResponse } from 'node:http';
+import { type PickFolderResponse } from './fs-pick-folder.js';
+import type { OpenWorkspaceService } from './route-types.js';
+import type { RuntimeStore } from './runtime-store.js';
+import { type TasksFileService } from './tasks-file.js';
+import { type VersionService } from './version-service.js';
+interface CreateAppOptions {
+    store: RuntimeStore;
+    pickFolderService?: () => Promise<PickFolderResponse>;
+    openWorkspaceService?: OpenWorkspaceService;
+    packageVersionReader?: () => string;
+    tasksFileService?: TasksFileService;
+    versionService?: VersionService;
+}
+export declare const createApp: ({ store, pickFolderService, openWorkspaceService, packageVersionReader, tasksFileService, versionService, }: CreateAppOptions) => {
+    server: import("http").Server<typeof IncomingMessage, typeof ServerResponse>;
+    store: RuntimeStore;
+    closeWebSockets: () => void;
+};
+export type { CreateAppOptions };

package/dist/src/server/app.js ADDED Viewed

@@ -0,0 +1,211 @@
+import { constants } from 'node:fs';
+import { access, readFile } from 'node:fs/promises';
+import { createServer } from 'node:http';
+import { dirname, extname, join, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { pickFolder } from './fs-pick-folder.js';
+import { HttpError } from './http-errors.js';
+import { assertLocalRequest } from './local-request-guard.js';
+import { openWorkspace } from './open-target-commands.js';
+import { readPackageVersion } from './package-version.js';
+import { matchRoute } from './routes.js';
+import { createTasksFileService } from './tasks-file.js';
+import { createTerminalWebSocketServer } from './terminal-ws-server.js';
+import { createVersionService } from './version-service.js';
+const getDefaultStaticDir = () => {
+    const moduleDir = dirname(fileURLToPath(import.meta.url));
+    if (moduleDir.includes(`${sep}dist${sep}src${sep}`)) {
+        return resolve(moduleDir, '../../../web/dist');
+    }
+    return resolve(moduleDir, '../../web/dist');
+};
+const isReservedPath = (pathname) => /^\/(api|ws)(\/|$)/.test(pathname);
+const canServeStatic = async (staticDir) => {
+    try {
+        await access(join(staticDir, 'index.html'), constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const getStaticAssetPath = (staticDir, pathname) => {
+    const staticRoot = resolve(staticDir);
+    if (pathname === '/' || extname(pathname) === '')
+        return join(staticRoot, 'index.html');
+    const candidate = resolve(staticRoot, `.${pathname}`);
+    if (candidate === staticRoot || candidate.startsWith(`${staticRoot}${sep}`))
+        return candidate;
+    return undefined;
+};
+const CONTENT_TYPES = {
+    '.css': 'text/css; charset=utf-8',
+    '.html': 'text/html; charset=utf-8',
+    '.ico': 'image/x-icon',
+    '.jpeg': 'image/jpeg',
+    '.jpg': 'image/jpeg',
+    '.js': 'text/javascript; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.map': 'application/json; charset=utf-8',
+    '.png': 'image/png',
+    '.svg': 'image/svg+xml; charset=utf-8',
+    '.ttf': 'font/ttf',
+    '.wasm': 'application/wasm',
+    '.webmanifest': 'application/manifest+json; charset=utf-8',
+    '.webp': 'image/webp',
+    '.woff2': 'font/woff2',
+};
+// PWA boot files must bypass HTTP caching: `sw.js` because the browser does its
+// own byte-diff update check, and the manifest because Chrome consults it on
+// every install/uninstall transition. Without these, SW updates can stall on a
+// stale cached copy and the install prompt won't reflect a renamed app.
+const PWA_BOOT_CACHE_CONTROL = {
+    '/manifest.webmanifest': 'max-age=0, must-revalidate',
+    '/sw.js': 'no-store',
+};
+const sendStatic = async (response, staticDir, pathname, request) => {
+    if (request.method !== 'GET' && request.method !== 'HEAD')
+        return false;
+    const filePath = getStaticAssetPath(staticDir, pathname);
+    if (!filePath)
+        return false;
+    try {
+        const content = await readFile(filePath);
+        response.setHeader('content-type', CONTENT_TYPES[extname(filePath)] ?? 'application/octet-stream');
+        const cacheControl = PWA_BOOT_CACHE_CONTROL[pathname];
+        if (cacheControl !== undefined)
+            response.setHeader('cache-control', cacheControl);
+        response.statusCode = 200;
+        response.end(request.method === 'HEAD' ? undefined : content);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const sendJson = (response, statusCode, body) => {
+    response.statusCode = statusCode;
+    response.setHeader('content-type', 'application/json; charset=utf-8');
+    response.end(JSON.stringify(body));
+};
+const escapeHtml = (value) => value
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#39;');
+const createVersionMismatchBody = (runtimeVersion, installedVersion) => `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Restart Hive</title>
+    <style>
+      :root { color-scheme: dark; font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
+      body { align-items: center; background: #0d0f12; color: #f4f4f5; display: flex; justify-content: center; margin: 0; min-height: 100vh; }
+      main { border: 1px solid rgba(255,255,255,.12); border-radius: 14px; background: #17191d; box-shadow: 0 18px 64px rgba(0,0,0,.4); max-width: 520px; padding: 28px; }
+      h1 { font-size: 22px; line-height: 1.2; margin: 0 0 10px; }
+      p { color: #a1a1aa; font-size: 14px; line-height: 1.6; margin: 0 0 14px; }
+      code { background: rgba(255,255,255,.08); border: 1px solid rgba(255,255,255,.1); border-radius: 6px; color: #e5e7eb; padding: 2px 6px; }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>Restart Hive</h1>
+      <p>Hive was updated on disk while this runtime process was still running.</p>
+      <p>Running runtime: <code>${escapeHtml(runtimeVersion)}</code><br />Installed package: <code>${escapeHtml(installedVersion)}</code></p>
+      <p>Stop the current <code>hive</code> process and start it again to load the new UI and API together.</p>
+    </main>
+  </body>
+</html>`;
+const readVersionMismatch = (runtimeVersion, packageVersionReader) => {
+    const installedVersion = packageVersionReader();
+    if (runtimeVersion === 'unknown' ||
+        installedVersion === 'unknown' ||
+        installedVersion === runtimeVersion) {
+        return null;
+    }
+    return { installedVersion, runtimeVersion };
+};
+const sendVersionMismatchJson = (response, mismatch) => {
+    sendJson(response, 409, {
+        code: 'runtime_version_mismatch',
+        current_version: mismatch.runtimeVersion,
+        error: 'Hive was updated on disk. Restart the running hive process to use the new version.',
+        installed_version: mismatch.installedVersion,
+    });
+};
+const sendVersionMismatchPage = (response, request, mismatch) => {
+    response.statusCode = 409;
+    response.setHeader('content-type', 'text/html; charset=utf-8');
+    response.setHeader('cache-control', 'no-store');
+    response.end(request.method === 'HEAD'
+        ? undefined
+        : createVersionMismatchBody(mismatch.runtimeVersion, mismatch.installedVersion));
+};
+export const createApp = ({ store, pickFolderService = pickFolder, openWorkspaceService = (input) => openWorkspace(input), packageVersionReader = readPackageVersion, tasksFileService = createTasksFileService(), versionService = createVersionService(), }) => {
+    const staticDir = process.env.HIVE_STATIC_DIR ?? getDefaultStaticDir();
+    const runtimeVersion = packageVersionReader();
+    const staticAvailablePromise = canServeStatic(staticDir);
+    const server = createServer(async (request, response) => {
+        const method = request.method ?? 'GET';
+        const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+        try {
+            assertLocalRequest(request);
+            const match = matchRoute(method, url.pathname);
+            if (match) {
+                await match.handler({
+                    request,
+                    response,
+                    store,
+                    tasksFileService,
+                    pickFolderService,
+                    openWorkspaceService,
+                    versionService,
+                    params: match.params,
+                });
+                return;
+            }
+            if (isReservedPath(url.pathname)) {
+                const mismatch = readVersionMismatch(runtimeVersion, packageVersionReader);
+                if (mismatch) {
+                    sendVersionMismatchJson(response, mismatch);
+                    return;
+                }
+                sendJson(response, 404, { error: 'Not found' });
+                return;
+            }
+            if (await staticAvailablePromise) {
+                const mismatch = readVersionMismatch(runtimeVersion, packageVersionReader);
+                if (mismatch) {
+                    sendVersionMismatchPage(response, request, mismatch);
+                    return;
+                }
+                const served = await sendStatic(response, staticDir, url.pathname, request);
+                if (served)
+                    return;
+            }
+            sendJson(response, 404, { error: 'Not found' });
+        }
+        catch (error) {
+            if (error instanceof HttpError) {
+                sendJson(response, error.statusCode, { error: error.message });
+                return;
+            }
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            sendJson(response, 500, { error: message });
+        }
+    });
+    const wsServer = createTerminalWebSocketServer(server, store, tasksFileService);
+    return {
+        server,
+        store,
+        // Tear-down for the WebSocket layer. Callers must invoke this
+        // BEFORE awaiting `server.close()` if they want a prompt return:
+        // `server.close()` waits on every existing socket, and Node's
+        // `closeAllConnections()` does NOT terminate already-upgraded
+        // WebSocket clients. Without this hook a Ctrl+C in the Hive
+        // runtime hangs as long as any browser tab is connected.
+        closeWebSockets: wsServer.close,
+    };
+};

package/dist/src/server/claude-command-defaults.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export declare const CLAUDE_DEFAULT_YOLO_ARGS: string[];

package/dist/src/server/claude-command-defaults.js ADDED Viewed

@@ -0,0 +1,5 @@
+export const CLAUDE_DEFAULT_YOLO_ARGS = [
+    '--dangerously-skip-permissions',
+    '--permission-mode=bypassPermissions',
+    '--disallowedTools=Task',
+];

package/dist/src/server/claude-session-coordinator.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+export declare const captureSessionIdWithCoordinator: ({ intervalMs, knownSessionIds, listSessionIds, onCapture, projectKey, timeoutMs, matchesSessionId, }: {
+    intervalMs?: number;
+    knownSessionIds: Set<string>;
+    listSessionIds: () => string[];
+    matchesSessionId?: (sessionId: string) => boolean;
+    onCapture: (sessionId: string) => void;
+    projectKey: string;
+    timeoutMs?: number;
+}) => Promise<void>;
+export declare const resetSessionCaptureCoordinatorForTests: () => void;