@tt-a1i/hive 1.1.5 → 1.3.0

package/dist/src/server/package-version.js

@@ -2,6 +2,21 @@ import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 export const PACKAGE_NAME = '@tt-a1i/hive';
+/**
+ * Canonical argv for the upgrade command. Sharing one source between the
+ * server's install hint (`version-service.ts`) and the CLI upgrade path
+ * (`hive-update.ts`) keeps the two from drifting if the package name ever
+ * moves.
+ */
+export const INSTALL_COMMAND_ARGS = ['install', '-g', `${PACKAGE_NAME}@latest`];
+export const INSTALL_COMMAND_DISPLAY = `npm ${INSTALL_COMMAND_ARGS.join(' ')}`;
+/**
+ * Windows ships npm as `npm.cmd` (a batch shim); Node's `child_process.spawn`
+ * will not resolve `.cmd` without `shell: true` or an explicit suffix, so the
+ * default `'npm'` produces ENOENT on Windows. Use this helper any time you
+ * spawn npm directly.
+ */
+export const getNpmCommand = (platform = process.platform) => platform === 'win32' ? 'npm.cmd' : 'npm';
 export const readPackageVersion = () => {
     let dir = dirname(fileURLToPath(import.meta.url));
     for (let depth = 0; depth < 8; depth += 1) {

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

@@ -1,6 +1,7 @@
 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';
@@ -48,12 +49,17 @@ export interface ConfigureAgentLaunchBody {
     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>;
 }

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

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

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

@@ -0,0 +1,47 @@
+import { isOpenTargetId } from './open-target-commands.js';
+import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
+import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
+export const openWorkspaceRoutes = [
+    route('POST', '/api/workspaces/:workspaceId/open', async ({ openWorkspaceService, params, request, response, store }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');
+        if (!workspaceId)
+            return;
+        requireUiTokenFromRequest(request, store.validateUiToken);
+        const body = await readJsonBody(request);
+        if (!isOpenTargetId(body.target_id)) {
+            sendJson(response, 400, { error: 'Unknown open target', target_id: body.target_id });
+            return;
+        }
+        // store.getWorkspaceSnapshot throws raw Error("Workspace not found: ...")
+        // for missing workspaces — translate that to 404 here rather than letting
+        // app.ts catch it as a generic 500.
+        let workspacePath;
+        try {
+            workspacePath = store.getWorkspaceSnapshot(workspaceId).summary.path;
+        }
+        catch {
+            sendJson(response, 404, { error: 'Workspace not found' });
+            return;
+        }
+        const result = await openWorkspaceService({
+            path: workspacePath,
+            targetId: body.target_id,
+        });
+        if (result.ok) {
+            sendJson(response, 200, {
+                ok: true,
+                effective_target_id: result.effectiveTargetId,
+            });
+            return;
+        }
+        // Drop stderr from the wire response — defense in depth. The frontend
+        // never renders raw stderr (toast text is localized via error_code), so
+        // there's no reason to ship the OS-level message to the browser where
+        // it would live in the devtools network log.
+        sendJson(response, 502, {
+            ok: false,
+            effective_target_id: result.effectiveTargetId,
+            error_code: result.errorCode,
+        });
+    }),
+];

package/dist/src/server/routes.js

@@ -1,6 +1,7 @@
 import { matchPath } from './route-helpers.js';
 import { dispatchRoutes } from './routes-dispatches.js';
 import { fsRoutes } from './routes-fs.js';
+import { openWorkspaceRoutes } from './routes-open-workspace.js';
 import { runtimeRoutes } from './routes-runtime.js';
 import { settingsRoutes } from './routes-settings.js';
 import { taskRoutes } from './routes-tasks.js';
@@ -10,6 +11,7 @@ import { versionRoutes } from './routes-version.js';
 import { workspaceRoutes } from './routes-workspaces.js';
 const routes = [
     ...workspaceRoutes,
+    ...openWorkspaceRoutes,
     ...dispatchRoutes,
     ...versionRoutes,
     ...uiRoutes,

package/dist/src/server/version-service.js

@@ -27,7 +27,10 @@ export const compareVersions = (left, right) => {
 };
 const buildVersionInfo = (currentVersion, latestVersion) => ({
     current_version: currentVersion,
-    install_hint: `npm install -g ${PACKAGE_NAME}@latest`,
+    // Show `hive update` as the primary upgrade path now that the subcommand
+    // exists; it prints the npm fallback if its own spawn fails, so users
+    // running on Windows / Linux without a working npm in PATH still recover.
+    install_hint: 'hive update',
     latest_version: latestVersion,
     package_name: PACKAGE_NAME,
     release_url: `https://www.npmjs.com/package/${PACKAGE_NAME}/v/${latestVersion}`,

package/dist/src/server/workspace-shell-runtime.js

@@ -1,5 +1,7 @@
 import { basename } from 'node:path';
 const WORKSPACE_SHELL_SUFFIX = ':shell';
+const WORKSPACE_SHELL_LABEL = 'Shell';
+const EXITED_SHELL_RETENTION_MS = 5000;
 export const getWorkspaceShellAgentId = (workspaceId) => `${workspaceId}${WORKSPACE_SHELL_SUFFIX}`;
 export const isWorkspaceShellAgentId = (agentId) => agentId.endsWith(WORKSPACE_SHELL_SUFFIX);
 const shouldUseLoginShell = (command) => {
@@ -20,10 +22,10 @@ export const resolveWorkspaceShellLaunch = (env = process.env, platform = proces
 };
 export const createWorkspaceShellRuntime = (agentManager) => {
     const labelsByRunId = new Map();
-    const nextShellNumberByWorkspaceId = new Map();
     const workspaceIdsByRunId = new Map();
     const runIdsByWorkspaceId = new Map();
     const startedAtByRunId = new Map();
+    const exitCleanupTimersByRunId = new Map();
     const requireManager = () => {
         if (!agentManager)
             throw new Error('Agent manager is required for workspace shell terminals');
@@ -43,6 +45,10 @@ export const createWorkspaceShellRuntime = (agentManager) => {
         }
     };
     const detachRun = (runId) => {
+        const exitCleanupTimer = exitCleanupTimersByRunId.get(runId);
+        if (exitCleanupTimer)
+            clearTimeout(exitCleanupTimer);
+        exitCleanupTimersByRunId.delete(runId);
         const workspaceId = workspaceIdsByRunId.get(runId);
         if (workspaceId) {
             const retained = (runIdsByWorkspaceId.get(workspaceId) ?? []).filter((id) => id !== runId);
@@ -61,11 +67,27 @@ export const createWorkspaceShellRuntime = (agentManager) => {
         startedAtByRunId.set(runId, startedAt);
         runIdsByWorkspaceId.set(workspaceId, [...(runIdsByWorkspaceId.get(workspaceId) ?? []), runId]);
     };
-    const nextLabel = (workspaceId) => {
-        const next = nextShellNumberByWorkspaceId.get(workspaceId) ?? 1;
-        nextShellNumberByWorkspaceId.set(workspaceId, next + 1);
-        return `Shell ${next}`;
+    const forgetShellRun = (runId) => {
+        detachRun(runId);
+        try {
+            requireManager().removeRun(runId);
+        }
+        catch {
+            // The PTY manager may have already dropped the run.
+        }
+    };
+    const handleShellExit = (runId) => {
+        if (!hasRun(runId) || exitCleanupTimersByRunId.has(runId))
+            return;
+        const timer = setTimeout(() => {
+            exitCleanupTimersByRunId.delete(runId);
+            if (hasRun(runId))
+                forgetShellRun(runId);
+        }, EXITED_SHELL_RETENTION_MS);
+        timer.unref?.();
+        exitCleanupTimersByRunId.set(runId, timer);
     };
+    const isListedRun = (run) => run.status === 'starting' || run.status === 'running';
     const stopPtyRun = (runId) => {
         requireManager().stopRun(runId);
     };
@@ -92,7 +114,9 @@ export const createWorkspaceShellRuntime = (agentManager) => {
             workspaceIdsByRunId.clear();
             startedAtByRunId.clear();
             labelsByRunId.clear();
-            nextShellNumberByWorkspaceId.clear();
+            for (const timer of exitCleanupTimersByRunId.values())
+                clearTimeout(timer);
+            exitCleanupTimersByRunId.clear();
         },
         closeRun(workspaceId, runId) {
             if (workspaceIdsByRunId.get(runId) !== workspaceId)
@@ -110,7 +134,6 @@ export const createWorkspaceShellRuntime = (agentManager) => {
                 }
             }
             runIdsByWorkspaceId.delete(workspaceId);
-            nextShellNumberByWorkspaceId.delete(workspaceId);
         },
         getLiveRun(runId) {
             if (!hasRun(runId))
@@ -122,6 +145,8 @@ export const createWorkspaceShellRuntime = (agentManager) => {
             return (runIdsByWorkspaceId.get(workspaceId) ?? []).flatMap((runId) => {
                 try {
                     const run = toLiveRun(runId);
+                    if (!isListedRun(run))
+                        return [];
                     return [
                         {
                             agent_id: getWorkspaceShellAgentId(workspaceId),
@@ -163,8 +188,9 @@ export const createWorkspaceShellRuntime = (agentManager) => {
                     TERM: 'xterm-256color',
                     TERM_PROGRAM: 'hive-shell',
                 },
+                onExit: ({ runId }) => handleShellExit(runId),
             });
-            attachRun(workspace.id, run.runId, nextLabel(workspace.id), startedAt);
+            attachRun(workspace.id, run.runId, WORKSPACE_SHELL_LABEL, startedAt);
             return { ...run, startedAt };
         },
         stopRun(runId) {

package/dist/src/shared/open-targets.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Cross-cutting types for the "Open workspace in editor/app" feature.
+ * Both the server (command construction in `src/server/open-target-commands.ts`)
+ * and the web client (button + preference store in `web/src/workspace/open-targets.ts`)
+ * pull the union and platform whitelist from here so they cannot drift.
+ */
+export type OpenTargetId = 'vscode' | 'vscode-insiders' | 'cursor' | 'finder' | 'terminal' | 'ghostty' | 'zed';
+export type OpenTargetPlatform = 'mac' | 'windows' | 'linux' | 'other';
+export declare const OPEN_TARGET_IDS_BY_PLATFORM: Record<OpenTargetPlatform, readonly OpenTargetId[]>;
+export declare const isOpenTargetId: (value: unknown) => value is OpenTargetId;
+export declare const isOpenTargetSupported: (targetId: OpenTargetId, platform: OpenTargetPlatform) => boolean;
+/**
+ * The id the server will actually attempt to launch. If the user's saved
+ * preference is unsupported on the current platform (e.g. they picked iTerm2
+ * on a Mac, then opened Hive on Windows), fall back to the platform default
+ * rather than erroring out — a stale preference shouldn't break the button.
+ */
+export declare const getEffectiveOpenTargetId: (targetId: OpenTargetId, platform: OpenTargetPlatform) => OpenTargetId;
+export declare const getDefaultOpenTargetIdForPlatform: (platform: OpenTargetPlatform) => OpenTargetId;
+export type OpenWorkspaceErrorCode = 'invalid-path' | 'invalid-target' | 'app-not-installed' | 'command-not-in-path' | 'unknown';

package/dist/src/shared/open-targets.js

@@ -0,0 +1,36 @@
+/**
+ * Cross-cutting types for the "Open workspace in editor/app" feature.
+ * Both the server (command construction in `src/server/open-target-commands.ts`)
+ * and the web client (button + preference store in `web/src/workspace/open-targets.ts`)
+ * pull the union and platform whitelist from here so they cannot drift.
+ */
+// Note: there is no `cursor-insiders` here. Cursor stopped shipping a separate
+// Nightly bundle / `cursor-nightly` binary in March 2024; the pre-release
+// channel is now an in-app toggle on the regular Cursor.app.
+//
+// IntelliJ IDEA, Windsurf, and iTerm2 were intentionally dropped after 1.3.0:
+// IntelliJ users typically launch from JetBrains Toolbox rather than a folder
+// picker; Windsurf overlaps with Cursor/VS Code; iTerm2 overlaps with the
+// built-in macOS Terminal entry.
+export const OPEN_TARGET_IDS_BY_PLATFORM = {
+    mac: ['vscode', 'vscode-insiders', 'cursor', 'finder', 'terminal', 'ghostty', 'zed'],
+    windows: ['vscode', 'vscode-insiders', 'cursor', 'finder', 'zed'],
+    linux: ['vscode', 'vscode-insiders', 'cursor', 'finder', 'zed'],
+    other: ['vscode', 'vscode-insiders', 'finder'],
+};
+const ALL_TARGET_IDS = new Set(OPEN_TARGET_IDS_BY_PLATFORM.mac);
+export const isOpenTargetId = (value) => typeof value === 'string' && ALL_TARGET_IDS.has(value);
+export const isOpenTargetSupported = (targetId, platform) => OPEN_TARGET_IDS_BY_PLATFORM[platform].includes(targetId);
+/**
+ * The id the server will actually attempt to launch. If the user's saved
+ * preference is unsupported on the current platform (e.g. they picked iTerm2
+ * on a Mac, then opened Hive on Windows), fall back to the platform default
+ * rather than erroring out — a stale preference shouldn't break the button.
+ */
+export const getEffectiveOpenTargetId = (targetId, platform) => isOpenTargetSupported(targetId, platform) ? targetId : getDefaultOpenTargetIdForPlatform(platform);
+export const getDefaultOpenTargetIdForPlatform = (platform) => {
+    // `finder` exists for every platform and never fails closed.
+    if (platform === 'mac' || platform === 'windows' || platform === 'linux')
+        return 'finder';
+    return 'vscode';
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tt-a1i/hive",
-  "version": "1.1.5",
+  "version": "1.3.0",
   "description": "Browser-native hive-mind for CLI coding agents — Claude Code, Codex, Gemini, and OpenCode collaborate as real PTY processes via a team protocol.",
   "type": "module",
   "packageManager": "pnpm@10.30.3",
@@ -17,7 +17,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/tt-a1i/hive.git"
+    "url": "git+https://github.com/tt-a1i/hive-private.git"
   },
   "bugs": {
     "url": "https://github.com/tt-a1i/hive/issues"
@@ -60,7 +60,7 @@
     "postinstall": "node scripts/fix-runtime-artifacts.mjs",
     "release:dry": "pnpm check && pnpm build && pnpm test && pnpm pack:check && pnpm pack:smoke",
     "test": "vitest run",
-    "test:windows": "vitest run tests/unit/agent-command-resolver.test.ts tests/unit/session-capture-multi-cli.test.ts tests/unit/claude-session-support.test.ts tests/unit/worker-name-generator.test.ts tests/server/fs-pick-folder.test.ts tests/server/fs-browse.test.ts tests/server/schema-version.test.ts tests/server/runtime-rehydration.test.ts tests/web/workspace-picker.test.tsx tests/web/confirm-dialog.test.tsx tests/web/toast.test.tsx --no-file-parallelism --maxWorkers=1 --testTimeout=30000 --hookTimeout=30000",
+    "test:windows": "vitest run tests/unit/agent-command-resolver.test.ts tests/unit/session-capture-multi-cli.test.ts tests/unit/claude-session-support.test.ts tests/unit/worker-name-generator.test.ts tests/unit/open-target-commands.test.ts tests/unit/sw-template-substitution.test.ts tests/unit/build-sw-plugin.test.ts tests/server/fs-pick-folder.test.ts tests/server/fs-browse.test.ts tests/server/schema-version.test.ts tests/server/runtime-rehydration.test.ts tests/server/open-workspace-route.test.ts tests/server/static-pwa.test.ts tests/web/workspace-picker.test.tsx tests/web/confirm-dialog.test.tsx tests/web/toast.test.tsx tests/web/open-workspace-button.test.tsx tests/web/register-service-worker.test.ts tests/web/use-shortcut-action.test.ts tests/web/update-available-toast.test.tsx tests/web/runtime-offline-page.test.tsx tests/web/use-terminal-panel-height.test.ts tests/web/use-terminal-panel-tabs.test.ts tests/web/terminal-tabs.test.tsx tests/web/terminal-bottom-panel.test.tsx --no-file-parallelism --maxWorkers=1 --testTimeout=60000 --hookTimeout=60000",
     "test:watch": "vitest"
   },
   "dependencies": {