@tt-a1i/hive 1.1.5 → 1.2.0

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 All notable user-facing changes will be documented in this file.
 
+## 1.2.0 - 2026-05-18
+
+Opens the active workspace in your editor, terminal, or file manager from
+Hive's topbar.
+
+- Adds an "Open" split button to the topbar that launches the active workspace
+  in a chosen application. Ten targets on macOS (VS Code, VS Code Insiders,
+  Cursor, Windsurf, Finder, Terminal, iTerm2, Ghostty, IntelliJ IDEA, Zed) and
+  six on Windows / Linux (VS Code, VS Code Insiders, Cursor, Windsurf, File
+  Explorer / File Manager, Zed).
+- Persists the preferred target per browser via `localStorage` so the next
+  click jumps to the same app. Stale preferences for apps that aren't valid on
+  the current platform fall back to the OS file manager instead of erroring.
+- Surfaces failures as localized toast notifications. Distinguishes
+  "app not installed", "launcher not on PATH", and other failure modes so a
+  missing Cursor install reads differently from a misconfigured `code` CLI.
+- Backend launches each command via `execFile` with an argv array — no shell
+  is involved, so workspace paths containing spaces, Unicode, or quotes pass
+  through verbatim. Paths containing newlines or NUL bytes are rejected before
+  dispatch.
+- Special-cases Windows `explorer.exe`, which returns exit code 1 even on
+  success: spawn-errors are still surfaced, but a non-zero exit no longer
+  shows a spurious toast.
+
 ## 1.1.5 - 2026-05-18
 
 Custom startup command and close-guard fixes.

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

@@ -1,15 +1,17 @@
 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;
     tasksFileService?: TasksFileService;
     versionService?: VersionService;
 }
-export declare const createApp: ({ store, pickFolderService, tasksFileService, versionService, }: CreateAppOptions) => {
+export declare const createApp: ({ store, pickFolderService, openWorkspaceService, tasksFileService, versionService, }: CreateAppOptions) => {
     server: import("http").Server<typeof IncomingMessage, typeof ServerResponse>;
     store: RuntimeStore;
 };

package/dist/src/server/app.js

@@ -6,6 +6,7 @@ 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 { matchRoute } from './routes.js';
 import { createTasksFileService } from './tasks-file.js';
 import { createTerminalWebSocketServer } from './terminal-ws-server.js';
@@ -75,7 +76,7 @@ const sendJson = (response, statusCode, body) => {
     response.setHeader('content-type', 'application/json; charset=utf-8');
     response.end(JSON.stringify(body));
 };
-export const createApp = ({ store, pickFolderService = pickFolder, tasksFileService = createTasksFileService(), versionService = createVersionService(), }) => {
+export const createApp = ({ store, pickFolderService = pickFolder, openWorkspaceService = (input) => openWorkspace(input), tasksFileService = createTasksFileService(), versionService = createVersionService(), }) => {
     const staticDir = process.env.HIVE_STATIC_DIR ?? getDefaultStaticDir();
     const staticAvailablePromise = canServeStatic(staticDir);
     const server = createServer(async (request, response) => {
@@ -91,6 +92,7 @@ export const createApp = ({ store, pickFolderService = pickFolder, tasksFileServ
                     store,
                     tasksFileService,
                     pickFolderService,
+                    openWorkspaceService,
                     versionService,
                     params: match.params,
                 });

package/dist/src/server/open-target-commands.d.ts

@@ -0,0 +1,53 @@
+import { type ExecFileOptions } from 'node:child_process';
+import { type OpenTargetId, type OpenTargetPlatform, type OpenWorkspaceErrorCode } from '../shared/open-targets.js';
+export type { OpenTargetId, OpenTargetPlatform, OpenWorkspaceErrorCode, } from '../shared/open-targets.js';
+export { getEffectiveOpenTargetId, isOpenTargetId, isOpenTargetSupported, OPEN_TARGET_IDS_BY_PLATFORM, } from '../shared/open-targets.js';
+export declare const resolveOpenTargetPlatform: (platform: NodeJS.Platform) => OpenTargetPlatform;
+export interface OpenAttempt {
+    command: string;
+    args: string[];
+}
+/**
+ * Returns the ordered list of commands to try. First success wins; remaining
+ * entries are fallbacks (e.g. IntelliJ IDEA → IntelliJ IDEA CE on older Macs).
+ * Empty list means the requested target is unsupported on this platform —
+ * callers should have already routed through `getEffectiveOpenTargetId` to
+ * fall back, so this should never happen in practice.
+ */
+export declare const buildOpenAttempts: (targetId: OpenTargetId, path: string, platform: OpenTargetPlatform) => OpenAttempt[];
+export interface OpenCommandSuccess {
+    ok: true;
+    effectiveTargetId: OpenTargetId;
+}
+export interface OpenCommandFailure {
+    ok: false;
+    effectiveTargetId: OpenTargetId;
+    errorCode: OpenWorkspaceErrorCode;
+    stderr: string;
+}
+export type OpenCommandResult = OpenCommandSuccess | OpenCommandFailure;
+interface SpawnResult {
+    stderr: string;
+    stdout: string;
+    status: number | null;
+    signal: string | null;
+    spawnError: NodeJS.ErrnoException | null;
+}
+export type RunOpenCommand = (command: string, args: string[], options: ExecFileOptions) => Promise<SpawnResult>;
+export interface OpenWorkspaceInput {
+    path: string;
+    targetId: OpenTargetId;
+}
+export interface OpenWorkspaceOptions {
+    platform?: NodeJS.Platform;
+    runCommand?: RunOpenCommand;
+}
+/**
+ * Workspace paths originate from the OS folder picker or from manual paste;
+ * the picker output is sandbox-validated at create time, but a path stored
+ * before path-validation existed (or one pasted into a hypothetical migration
+ * future) could contain `\n` / `\0`. Reject those here so we never hand an
+ * ambiguous path to `xdg-open`, where shell wrappers split on newline.
+ */
+export declare const isOpenWorkspacePathSafe: (path: string) => boolean;
+export declare const openWorkspace: (input: OpenWorkspaceInput, options?: OpenWorkspaceOptions) => Promise<OpenCommandResult>;

package/dist/src/server/open-target-commands.js

@@ -0,0 +1,193 @@
+import { execFile } from 'node:child_process';
+import { getDefaultOpenTargetIdForPlatform, getEffectiveOpenTargetId, isOpenTargetId, } from '../shared/open-targets.js';
+export { getEffectiveOpenTargetId, isOpenTargetId, isOpenTargetSupported, OPEN_TARGET_IDS_BY_PLATFORM, } from '../shared/open-targets.js';
+export const resolveOpenTargetPlatform = (platform) => {
+    if (platform === 'darwin')
+        return 'mac';
+    if (platform === 'win32')
+        return 'windows';
+    if (platform === 'linux')
+        return 'linux';
+    return 'other';
+};
+const macAttempts = (targetId, path) => {
+    switch (targetId) {
+        case 'finder':
+            return [{ command: 'open', args: [path] }];
+        case 'vscode':
+            return [{ command: 'open', args: ['-a', 'Visual Studio Code', path] }];
+        case 'vscode-insiders':
+            return [{ command: 'open', args: ['-a', 'Visual Studio Code - Insiders', path] }];
+        case 'cursor':
+            return [{ command: 'open', args: ['-a', 'Cursor', path] }];
+        case 'windsurf':
+            return [{ command: 'open', args: ['-a', 'Windsurf', path] }];
+        case 'terminal':
+            return [{ command: 'open', args: ['-a', 'Terminal', path] }];
+        case 'iterm2':
+            // Bundle name has always been `iTerm.app` even after the iTerm2 rename;
+            // the `iTerm2` fallback in earlier ports is cargo-cult.
+            return [{ command: 'open', args: ['-a', 'iTerm', path] }];
+        case 'ghostty':
+            return [{ command: 'open', args: ['-a', 'Ghostty', path] }];
+        case 'intellijidea':
+            // 2025.3 unified the editions, but installs predating that still ship
+            // `IntelliJ IDEA CE.app` — retry once on the CE bundle.
+            return [
+                { command: 'open', args: ['-a', 'IntelliJ IDEA', path] },
+                { command: 'open', args: ['-a', 'IntelliJ IDEA CE', path] },
+            ];
+        case 'zed':
+            return [{ command: 'open', args: ['-a', 'Zed', path] }];
+    }
+};
+const linuxAttempts = (targetId, path) => {
+    switch (targetId) {
+        case 'finder':
+            return [{ command: 'xdg-open', args: [path] }];
+        case 'vscode':
+            return [{ command: 'code', args: [path] }];
+        case 'vscode-insiders':
+            return [{ command: 'code-insiders', args: [path] }];
+        case 'cursor':
+            return [{ command: 'cursor', args: [path] }];
+        case 'windsurf':
+            return [{ command: 'windsurf', args: [path] }];
+        case 'zed':
+            return [{ command: 'zed', args: [path] }];
+        default:
+            return [{ command: 'xdg-open', args: [path] }];
+    }
+};
+const windowsAttempts = (targetId, path) => {
+    switch (targetId) {
+        case 'finder':
+            return [{ command: 'explorer', args: [path] }];
+        case 'vscode':
+            return [{ command: 'code', args: [path] }];
+        case 'vscode-insiders':
+            return [{ command: 'code-insiders', args: [path] }];
+        case 'cursor':
+            return [{ command: 'cursor', args: [path] }];
+        case 'windsurf':
+            return [{ command: 'windsurf', args: [path] }];
+        case 'zed':
+            return [{ command: 'zed', args: [path] }];
+        default:
+            return [{ command: 'explorer', args: [path] }];
+    }
+};
+/**
+ * Returns the ordered list of commands to try. First success wins; remaining
+ * entries are fallbacks (e.g. IntelliJ IDEA → IntelliJ IDEA CE on older Macs).
+ * Empty list means the requested target is unsupported on this platform —
+ * callers should have already routed through `getEffectiveOpenTargetId` to
+ * fall back, so this should never happen in practice.
+ */
+export const buildOpenAttempts = (targetId, path, platform) => {
+    const effectiveTargetId = getEffectiveOpenTargetId(targetId, platform);
+    if (platform === 'mac')
+        return macAttempts(effectiveTargetId, path);
+    if (platform === 'linux')
+        return linuxAttempts(effectiveTargetId, path);
+    if (platform === 'windows')
+        return windowsAttempts(effectiveTargetId, path);
+    return [{ command: 'open', args: [path] }];
+};
+const defaultRunOpenCommand = (command, args, options) => new Promise((resolve) => {
+    const child = execFile(command, args, options, (error, stdout, stderr) => {
+        const errno = error;
+        resolve({
+            stderr: String(stderr ?? ''),
+            stdout: String(stdout ?? ''),
+            status: typeof errno?.code === 'number' ? errno.code : (child.exitCode ?? 0),
+            signal: typeof errno?.signal === 'string' ? errno.signal : null,
+            spawnError: errno && typeof errno.code === 'string' ? errno : null,
+        });
+    });
+});
+const APP_NOT_INSTALLED_PATTERNS = [
+    /unable to find application/i,
+    /can'?t find/i,
+    /not authorized to send keystrokes/i,
+    /application can'?t be found/i,
+];
+const classifyFailure = (result) => {
+    if (result.spawnError?.code === 'ENOENT')
+        return 'command-not-in-path';
+    const stderr = result.stderr.toLowerCase();
+    if (APP_NOT_INSTALLED_PATTERNS.some((re) => re.test(stderr)))
+        return 'app-not-installed';
+    return 'unknown';
+};
+/**
+ * Workspace paths originate from the OS folder picker or from manual paste;
+ * the picker output is sandbox-validated at create time, but a path stored
+ * before path-validation existed (or one pasted into a hypothetical migration
+ * future) could contain `\n` / `\0`. Reject those here so we never hand an
+ * ambiguous path to `xdg-open`, where shell wrappers split on newline.
+ */
+export const isOpenWorkspacePathSafe = (path) => {
+    if (path.length === 0)
+        return false;
+    for (let i = 0; i < path.length; i++) {
+        const code = path.charCodeAt(i);
+        if (code === 0 || code === 10 || code === 13)
+            return false;
+    }
+    return true;
+};
+export const openWorkspace = async (input, options = {}) => {
+    const platform = resolveOpenTargetPlatform(options.platform ?? process.platform);
+    const run = options.runCommand ?? defaultRunOpenCommand;
+    if (!isOpenTargetId(input.targetId)) {
+        return {
+            ok: false,
+            effectiveTargetId: getDefaultOpenTargetIdForPlatform(platform),
+            errorCode: 'invalid-target',
+            stderr: `Unknown open target: ${String(input.targetId)}`,
+        };
+    }
+    if (!isOpenWorkspacePathSafe(input.path)) {
+        return {
+            ok: false,
+            effectiveTargetId: input.targetId,
+            errorCode: 'invalid-path',
+            stderr: 'Workspace path contains newline or null byte and was rejected.',
+        };
+    }
+    const effectiveTargetId = getEffectiveOpenTargetId(input.targetId, platform);
+    const attempts = buildOpenAttempts(input.targetId, input.path, platform);
+    let lastFailure = null;
+    for (const attempt of attempts) {
+        const result = await run(attempt.command, attempt.args, {});
+        // Windows `explorer.exe` returns exit code 1 even on success — checking
+        // exit code here would surface a spurious error to the user on every
+        // File Explorer open. spawnError still catches the "explorer not on PATH"
+        // case, which is the only real failure mode worth surfacing.
+        if (attempt.command === 'explorer') {
+            if (result.spawnError?.code === 'ENOENT') {
+                lastFailure = result;
+                continue;
+            }
+            return { ok: true, effectiveTargetId };
+        }
+        if (!result.spawnError && (result.status === 0 || result.status === null)) {
+            return { ok: true, effectiveTargetId };
+        }
+        lastFailure = result;
+    }
+    const fallback = lastFailure ?? {
+        stderr: 'No command attempts were made.',
+        stdout: '',
+        status: null,
+        signal: null,
+        spawnError: null,
+    };
+    return {
+        ok: false,
+        effectiveTargetId,
+        errorCode: classifyFailure(fallback),
+        stderr: fallback.stderr.trim() || fallback.stdout.trim() || 'Failed to open workspace.',
+    };
+};

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/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' | 'windsurf' | 'finder' | 'terminal' | 'iterm2' | 'ghostty' | 'intellijidea' | '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,43 @@
+/**
+ * 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, so an "Insiders"
+// menu entry would 100% fail with `app-not-installed` on every platform.
+export const OPEN_TARGET_IDS_BY_PLATFORM = {
+    mac: [
+        'vscode',
+        'vscode-insiders',
+        'cursor',
+        'windsurf',
+        'finder',
+        'terminal',
+        'iterm2',
+        'ghostty',
+        'intellijidea',
+        'zed',
+    ],
+    windows: ['vscode', 'vscode-insiders', 'cursor', 'windsurf', 'finder', 'zed'],
+    linux: ['vscode', 'vscode-insiders', 'cursor', 'windsurf', '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.2.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",
@@ -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/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/web/workspace-picker.test.tsx tests/web/confirm-dialog.test.tsx tests/web/toast.test.tsx tests/web/open-workspace-button.test.tsx --no-file-parallelism --maxWorkers=1 --testTimeout=30000 --hookTimeout=30000",
     "test:watch": "vitest"
   },
   "dependencies": {