@kabmo-labs/kabmo 0.0.1 → 0.1.0

package/src/server/lib/updates/install-steps.ts

@@ -0,0 +1,81 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Running one update step, and reading a child's output as it arrives.
+ *
+ * Split out of `./install` because the parent file sits at the repository's
+ * per-file ceiling and this half is a self-contained child-process concern: a
+ * synchronous probe used for git facts, one step runner, and the streaming
+ * drain both the Kabmo and the oh-my-pi update paths share.
+ */
+
+/** A client rebuild is slow, but a hung child is worse. */
+export const STEP_TIMEOUT_MS = 600_000;
+/** Cap on the captured output returned to the console. */
+export const OUTPUT_LIMIT = 20_000;
+
+export interface UpdateStep {
+  label: string;
+  cmd: string[];
+  cwd: string;
+}
+
+export function runSync(cmd: string[], cwd?: string): { ok: boolean; out: string } {
+  try {
+    const proc = Bun.spawnSync({
+      cmd,
+      cwd,
+      stdin: 'ignore',
+      stdout: 'pipe',
+      stderr: 'pipe',
+      timeout: 15_000,
+    });
+    return { ok: proc.exitCode === 0, out: proc.stdout.toString().trim() };
+  } catch {
+    return { ok: false, out: '' };
+  }
+}
+
+/**
+ * Drain a child's stdout/stderr, forwarding each chunk to `sink` as it arrives
+ * and returning the whole decoded text. Exported because the omp update path
+ * needs the same streaming read: buffering with `new Response(stream).text()`
+ * emits nothing until the process exits, which is exactly what makes an update
+ * look hung.
+ */
+export async function pumpStream(stream: ReadableStream<Uint8Array>, sink?: (chunk: string) => void): Promise<string> {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let text = '';
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    const chunk = decoder.decode(value, { stream: true });
+    if (chunk.length === 0) continue;
+    text += chunk;
+    sink?.(chunk);
+  }
+  return text;
+}
+
+export async function runStep(step: UpdateStep, onLine?: (chunk: string) => void): Promise<{ ok: boolean; exitCode: number | null; output: string }> {
+  const proc = Bun.spawn({
+    cmd: step.cmd,
+    cwd: step.cwd,
+    stdin: 'ignore',
+    stdout: 'pipe',
+    stderr: 'pipe',
+    timeout: STEP_TIMEOUT_MS,
+    env: { ...Bun.env, PAGER: 'cat', FORCE_COLOR: '0' },
+  });
+  const [stdout, stderr] = await Promise.all([pumpStream(proc.stdout, onLine), pumpStream(proc.stderr, onLine)]);
+  const exitCode = await proc.exited;
+  return { ok: exitCode === 0, exitCode, output: `${stdout}${stderr}`.trim() };
+}
+
+export function tail(text: string): string {
+  return text.length > OUTPUT_LIMIT ? `…\n${text.slice(-OUTPUT_LIMIT)}` : text;
+}

package/src/server/lib/updates/install.ts

@@ -27,6 +27,8 @@ import {
   type InstallMethodInfo,
 } from '@/server/lib/updates/install-method';
 import { isNewer } from '@/shared/lib/updates/semver';
+import { copyAt, resolveInstalledCopy, type InstalledCopy } from '@/server/lib/updates/installed-cli';
+import { runStep, runSync, tail, type UpdateStep } from '@/server/lib/updates/install-steps';
 
 /**
  * Package root of the running copy — the directory holding its `package.json`.
@@ -37,10 +39,6 @@ import { isNewer } from '@/shared/lib/updates/semver';
  * checkout. `packageDir()` finds the real one in both.
  */
 const DEFAULT_PKG_ROOT = packageDir();
-/** A client rebuild is slow, but a hung child is worse. */
-const STEP_TIMEOUT_MS = 600_000;
-/** Cap on the captured output returned to the console. */
-const OUTPUT_LIMIT = 20_000;
 
 export interface KabmoVersionInfo {
   /** Version on disk right now (`package.json`), null when unreadable. */
@@ -62,12 +60,6 @@ export interface InstallContext extends InstallMethodInfo {
   bunBin: string;
 }
 
-export interface UpdateStep {
-  label: string;
-  cmd: string[];
-  cwd: string;
-}
-
 export interface UpdateOptions {
   /** Reinstall even when the installed version is already the latest. */
   force?: boolean;
@@ -97,22 +89,14 @@ export interface KabmoUpdateResult {
   releaseUrl: string | null;
   /** Captured command output (tail), for non-streaming callers. */
   output: string;
-}
-
-function runSync(cmd: string[], cwd?: string): { ok: boolean; out: string } {
-  try {
-    const proc = Bun.spawnSync({
-      cmd,
-      cwd,
-      stdin: 'ignore',
-      stdout: 'pipe',
-      stderr: 'pipe',
-      timeout: 15_000,
-    });
-    return { ok: proc.exitCode === 0, out: proc.stdout.toString().trim() };
-  } catch {
-    return { ok: false, out: '' };
-  }
+  /**
+   * The copy that now sits on disk — what a restart must launch.
+   *
+   * Not the copy that is RUNNING: a rename installs a different package
+   * beside it, so respawning from the running directory relaunches the build
+   * the update just replaced (measured on the 4.23.1 → 0.0.1 move).
+   */
+  installed: InstalledCopy | null;
 }
 
 /** Version installed on disk — not the one the running process imported. */
@@ -199,47 +183,6 @@ export function planUpdateSteps({ method, version, pkgRoot, bunBin, packageName
   ];
 }
 
-/**
- * Drain a child's stdout/stderr, forwarding each chunk to `sink` as it arrives
- * and returning the whole decoded text. Exported because the omp update path
- * needs the same streaming read: buffering with `new Response(stream).text()`
- * emits nothing until the process exits, which is exactly what makes an update
- * look hung.
- */
-export async function pumpStream(stream: ReadableStream<Uint8Array>, sink?: (chunk: string) => void): Promise<string> {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let text = '';
-  for (;;) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    const chunk = decoder.decode(value, { stream: true });
-    if (chunk.length === 0) continue;
-    text += chunk;
-    sink?.(chunk);
-  }
-  return text;
-}
-
-async function runStep(step: UpdateStep, onLine?: (chunk: string) => void): Promise<{ ok: boolean; exitCode: number | null; output: string }> {
-  const proc = Bun.spawn({
-    cmd: step.cmd,
-    cwd: step.cwd,
-    stdin: 'ignore',
-    stdout: 'pipe',
-    stderr: 'pipe',
-    timeout: STEP_TIMEOUT_MS,
-    env: { ...Bun.env, PAGER: 'cat', FORCE_COLOR: '0' },
-  });
-  const [stdout, stderr] = await Promise.all([pumpStream(proc.stdout, onLine), pumpStream(proc.stderr, onLine)]);
-  const exitCode = await proc.exited;
-  return { ok: exitCode === 0, exitCode, output: `${stdout}${stderr}`.trim() };
-}
-
-function tail(text: string): string {
-  return text.length > OUTPUT_LIMIT ? `…\n${text.slice(-OUTPUT_LIMIT)}` : text;
-}
-
 /**
  * Bring this install to the newest release. Never throws: every failure mode
  * (no release, unsupported install, dirty work tree, failing step) comes back
@@ -260,6 +203,7 @@ export async function updateKabmo({ force = false, pkgRoot = DEFAULT_PKG_ROOT, o
     version: null,
     releaseUrl: null,
     output: '',
+    installed: null,
   } satisfies Omit<KabmoUpdateResult, 'success' | 'message'>;
   const fail = (message: string, patch: Partial<KabmoUpdateResult> = {}): KabmoUpdateResult => ({
     success: false,
@@ -336,10 +280,18 @@ export async function updateKabmo({ force = false, pkgRoot = DEFAULT_PKG_ROOT, o
     }
   }
 
+  // Read back AFTER the steps: a global install puts the package where the
+  // installer decided, and a checkout IS the package. A null here leaves the
+  // restart on this process's own copy, which is the honest fallback.
+  const installed = context.method === 'git'
+    ? copyAt(root)
+    : resolveInstalledCopy(info.package ?? KABMO_PACKAGE, context.bunBin) ?? copyAt(root);
+
   return {
     success: true,
     ...base,
     ...resolved,
+    installed,
     updated: true,
     version: info.latest,
     message: info.renamed

package/src/server/lib/updates/installed-cli.test.ts

@@ -0,0 +1,222 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The copy an update INSTALLED, and how a restart reaches it.
+ *
+ * The bug these pin is a rename, not a version bump: `bun add -g
+ * @kabmo-labs/kabmo` installs a second package beside `ompchamber`, so a
+ * restart resolved from the RUNNING copy relaunched the build the update just
+ * replaced — measured on the 4.23.1 → 0.0.1 move, where the log showed
+ * `.../node_modules/ompchamber/src/cli/ompchamber.js restart --port 3001` and
+ * the console came back as the old version.
+ *
+ * Three facts are pinned here, each of which failed independently:
+ *
+ * 1. The CLI file comes from the package's own `bin` map, so a copy that names
+ *    its bin something other than `kabmo.js` still resolves.
+ * 2. A copy is found through Bun's global layout, asked of the installer.
+ * 3. The credential marker follows the TARGET package's spelling, because the
+ *    rename renamed the variable too.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { copyAt, globalNodeModules, nodeModulesForBinDir, resolveInstalledCopy } from '@/server/lib/updates/installed-cli';
+import { restartInvocation, scheduleSelfRestart } from '@/server/lib/lifecycle/restart';
+import { writeInstanceRecord } from '@/server/lib/lifecycle/instance';
+import { executableStub } from '@/test-support/executable-stub';
+
+function fixture(manifest: Record<string, unknown>, files: string[]): string {
+  const root = mkdtempSync(join(tmpdir(), 'installed-cli-'));
+  writeFileSync(join(root, 'package.json'), JSON.stringify(manifest));
+  for (const file of files) {
+    mkdirSync(join(root, file, '..'), { recursive: true });
+    writeFileSync(join(root, file), '#!/usr/bin/env bun\n');
+  }
+  return root;
+}
+
+describe('copyAt', () => {
+  test('resolves the current package through its own bin', () => {
+    const root = fixture(
+      { name: '@kabmo-labs/kabmo', bin: { kabmo: './src/cli/kabmo.js' } },
+      ['src/cli/kabmo.js'],
+    );
+    try {
+      const copy = copyAt(root);
+      expect(copy?.packageName).toBe('@kabmo-labs/kabmo');
+      expect(copy?.bin).toBe('kabmo');
+      // The file name is the package's own, never a guess.
+      expect(copy?.cli.endsWith(join('src', 'cli', 'kabmo.js'))).toBe(true);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test('the bridge release registers both names, and its own one wins', () => {
+    // `ompchamber@4.23.x` ships both bins; resolving to whichever key came
+    // first would restart a renamed install through the legacy spelling.
+    const root = fixture(
+      { name: 'ompchamber', bin: { kabmo: './src/cli/kabmo.js', ompchamber: './src/cli/ompchamber.js' } },
+      ['src/cli/kabmo.js', 'src/cli/ompchamber.js'],
+    );
+    try {
+      expect(copyAt(root)?.bin).toBe('ompchamber');
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test('a string bin is registered under the unscoped package name', () => {
+    const root = fixture({ name: '@kabmo-labs/kabmo', bin: './bin/kabmo.js' }, ['bin/kabmo.js']);
+    try {
+      expect(copyAt(root)).toMatchObject({ bin: 'kabmo', packageName: '@kabmo-labs/kabmo' });
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test('a declared bin that is not on disk is not a copy', () => {
+    const root = fixture({ name: '@kabmo-labs/kabmo', bin: { kabmo: './src/cli/kabmo.js' } }, []);
+    try {
+      expect(copyAt(root)).toBeNull();
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test('a directory with no manifest is not a copy', () => {
+    const root = mkdtempSync(join(tmpdir(), 'installed-cli-empty-'));
+    try {
+      expect(copyAt(root)).toBeNull();
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('nodeModulesForBinDir', () => {
+  test('the packages sit one layout step from the bin directory', () => {
+    // `<BUN_INSTALL>/bin` → `<BUN_INSTALL>/install/global/node_modules`, the
+    // shape `detectInstallMethod` recognizes as a Bun global install. Built
+    // with `join`, not written POSIX: `node:path` emits the PLATFORM separator,
+    // so a literal expectation fails on Windows with the same path spelled
+    // `\home\u\...` (measured on the Windows CI leg).
+    const installRoot = join(tmpdir(), 'kabmo-bun-install');
+    expect(nodeModulesForBinDir(join(installRoot, 'bin')))
+      .toBe(join(installRoot, 'install', 'global', 'node_modules'));
+  });
+});
+
+describe('globalNodeModules', () => {
+  // A COMPILED stub, not a shell script: `Bun.spawn` cannot start a script on
+  // Windows (only `.com`/`.exe` are tried), and this suite runs there. The path
+  // is baked into the source rather than passed through the environment,
+  // because a child does not inherit a `Bun.env` assignment made in-process —
+  // and baking it keeps the source constant, so the compiled fixture is cached.
+  const binDir = join(tmpdir(), 'kabmo-fake-bun-bin');
+  const stubSource = `console.log(${JSON.stringify(binDir)});\n`;
+
+  test('asks the installer and maps its answer', async () => {
+    mkdirSync(binDir, { recursive: true });
+    const bun = await executableStub(stubSource, 'fake-bun-pm-bin');
+    try {
+      expect(globalNodeModules(bun)).toBe(nodeModulesForBinDir(binDir));
+    } finally {
+      rmSync(binDir, { recursive: true, force: true });
+    }
+  });
+
+  test('a package that is not installed resolves to null', async () => {
+    const bun = await executableStub('process.exit(1);\n', 'fake-bun-no-answer');
+    expect(resolveInstalledCopy('@kabmo-labs/definitely-absent', bun)).toBeNull();
+  });
+});
+
+describe('restartInvocation', () => {
+  test('runs the installed copy and names its credential marker', () => {
+    const root = fixture(
+      { name: '@kabmo-labs/kabmo', bin: { kabmo: './src/cli/kabmo.js' } },
+      ['src/cli/kabmo.js'],
+    );
+    try {
+      const invocation = restartInvocation(3001, root);
+      expect(invocation?.cmd.slice(-3)).toEqual(['restart', '--port', '3001']);
+      expect(invocation?.cmd[1].endsWith(join('src', 'cli', 'kabmo.js'))).toBe(true);
+      // The renamed build reads KABMO_PASSWORD_HANDOVER; setting only the old
+      // spelling would hand it a payload it never looks for.
+      expect(invocation?.handoverEnv).toBe('KABMO_PASSWORD_HANDOVER');
+      expect(invocation?.root).toBe(root);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test('a pre-rename copy keeps the old marker', () => {
+    const root = fixture(
+      { name: 'ompchamber', bin: { ompchamber: './src/cli/ompchamber.js' } },
+      ['src/cli/ompchamber.js'],
+    );
+    try {
+      expect(restartInvocation(3001, root)?.handoverEnv).toBe('OMPCHAMBER_PASSWORD_HANDOVER');
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test('a root with no runnable copy yields no invocation', () => {
+    const root = mkdtempSync(join(tmpdir(), 'installed-cli-empty-'));
+    try {
+      expect(restartInvocation(3001, root)).toBeNull();
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('scheduleSelfRestart target', () => {
+  test('consults the INSTALLED copy, not the one this process runs from', () => {
+    // A rename installs a second package beside the running one, so restarting
+    // from this process's own root relaunches the build the update replaced.
+    // The refusal names the root it consulted, which is how this is observable
+    // without arming a spawn.
+    const dataDir = mkdtempSync(join(tmpdir(), 'restart-target-'));
+    const previous = Bun.env.KABMO_DATA_DIR;
+    Bun.env.KABMO_DATA_DIR = dataDir;
+    writeInstanceRecord({
+      pid: process.pid,
+      port: 4204,
+      host: 'localhost',
+      mode: 'prod',
+      launchMode: 'daemon',
+      tray: false,
+      tls: false,
+      auth: false,
+      startedAt: '2026-10-01T10:00:00.000Z',
+      version: '0.0.1',
+    });
+    // A root with no runnable copy: the plan refuses and says WHICH root.
+    const installedRoot = mkdtempSync(join(tmpdir(), 'installed-copy-'));
+    try {
+      const plan = scheduleSelfRestart('update', {
+        root: installedRoot,
+        packageName: '@kabmo-labs/kabmo',
+        bin: 'kabmo',
+        cli: join(installedRoot, 'src', 'cli', 'kabmo.js'),
+      });
+      expect(plan.restarting).toBe(false);
+      expect(plan.message).toContain(installedRoot);
+    } finally {
+      if (previous === undefined) delete Bun.env.KABMO_DATA_DIR;
+      else Bun.env.KABMO_DATA_DIR = previous;
+      rmSync(installedRoot, { recursive: true, force: true });
+      rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+});

package/src/server/lib/updates/installed-cli.ts

@@ -0,0 +1,139 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Where an installed copy of the product lives on disk, and which CLI file
+ * restarts it.
+ *
+ * The restart after an update must launch the copy the update INSTALLED, not
+ * the one that is running. That distinction did not exist until the rename:
+ * `bun add -g @kabmo-labs/kabmo` installs a DIFFERENT package beside
+ * `ompchamber`, so a server that resolved the restart from its own directory
+ * kept respawning the pre-rename build — measured on the 4.23.1 → 0.0.1 move,
+ * where the log read `.../node_modules/ompchamber/src/cli/ompchamber.js restart
+ * --port 3001` and the console came back as 4.23.1 while the update reported
+ * success. The same mistake returns in the other direction for a later rename,
+ * which is why the rule lives here rather than in a comment.
+ *
+ * The CLI file comes from the package's own `bin` map, never from a guessed
+ * filename: a package ships whatever it registers, so a hard-coded
+ * `kabmo.js` finds nothing in a copy that names its bin something else.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+
+import { resolveBunBin } from '@/server/lib/lifecycle/bun';
+
+export interface InstalledCopy {
+  /** Package root: the directory holding this copy's `package.json` and `src/`. */
+  root: string;
+  /** `name` from that `package.json` (`ompchamber` before the rename, `@kabmo-labs/kabmo` after). */
+  packageName: string;
+  /** The bin key this copy registers — the name a user types. */
+  bin: string;
+  /** Absolute path to that bin's script. */
+  cli: string;
+}
+
+interface Manifest {
+  name?: unknown;
+  bin?: unknown;
+}
+
+function readManifest(root: string): Manifest | null {
+  try {
+    return JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')) as Manifest;
+  } catch {
+    return null;
+  }
+}
+
+/** `@kabmo-labs/kabmo` → `kabmo`: the name a package's own bin is registered under. */
+function unscoped(name: string): string {
+  return name.slice(name.lastIndexOf('/') + 1);
+}
+
+function binEntries(manifest: Manifest): Array<[string, string]> {
+  const { bin } = manifest;
+  // A string `bin` is registered under the package's own (unscoped) name.
+  if (typeof bin === 'string' && bin.length > 0) {
+    const name = typeof manifest.name === 'string' ? unscoped(manifest.name) : '';
+    return name.length > 0 ? [[name, bin]] : [];
+  }
+  if (!bin || typeof bin !== 'object') return [];
+  return Object.entries(bin as Record<string, unknown>).flatMap(([key, value]) =>
+    typeof value === 'string' && value.length > 0 ? [[key, value] as [string, string]] : [],
+  );
+}
+
+/**
+ * The copy rooted at `root`, or null when no package (or no runnable bin) is
+ * there.
+ *
+ * The bin is preferred by NAME — `@kabmo-labs/kabmo` → `kabmo`, `ompchamber` →
+ * `ompchamber` — so a package that registers several scripts (the bridge
+ * release registers both) resolves to its own CLI instead of whichever key
+ * happens to come first.
+ */
+export function copyAt(root: string): InstalledCopy | null {
+  const resolved = resolve(root);
+  const manifest = readManifest(resolved);
+  if (!manifest) return null;
+
+  const packageName = typeof manifest.name === 'string' ? manifest.name : '';
+  const entries = binEntries(manifest);
+  const own = unscoped(packageName);
+  const ordered = [...entries.filter(([bin]) => bin === own), ...entries.filter(([bin]) => bin !== own)];
+
+  for (const [bin, script] of ordered) {
+    const cli = resolve(resolved, script);
+    if (existsSync(cli)) return { root: resolved, packageName, bin, cli };
+  }
+  return null;
+}
+
+/**
+ * The package directory behind a Bun bin directory.
+ *
+ * `bun pm bin -g` answers `<BUN_INSTALL>/bin`, and the packages sit one layout
+ * step away — the same `install/global/node_modules` shape
+ * `detectInstallMethod` matches. Named rather than inlined because the step is
+ * the one fact this module exists to get right.
+ */
+export function nodeModulesForBinDir(binDir: string): string {
+  return join(dirname(binDir), 'install', 'global', 'node_modules');
+}
+
+/**
+ * Bun's global `node_modules`, asked from the installer itself.
+ *
+ * `BUN_INSTALL` is the fallback for a Bun too old to answer `bun pm bin -g`; a
+ * host with neither still resolves the documented default, so the caller's own
+ * existence check decides.
+ */
+export function globalNodeModules(bunBin: string = resolveBunBin()): string {
+  try {
+    const probe = Bun.spawnSync({
+      cmd: [bunBin, 'pm', 'bin', '-g'],
+      stdin: 'ignore',
+      stdout: 'pipe',
+      stderr: 'ignore',
+      timeout: 15_000,
+    });
+    const binDir = probe.exitCode === 0 ? probe.stdout.toString().trim() : '';
+    if (binDir.length > 0) return nodeModulesForBinDir(binDir);
+  } catch {
+    // Fall through to the environment, then to the documented default.
+  }
+  const installRoot = (Bun.env.BUN_INSTALL ?? '').trim();
+  return join(installRoot.length > 0 ? resolve(installRoot) : join(homedir(), '.bun'), 'install', 'global', 'node_modules');
+}
+
+/** The global copy of `packageName`, or null when it is not installed. */
+export function resolveInstalledCopy(packageName: string, bunBin: string = resolveBunBin()): InstalledCopy | null {
+  return copyAt(join(globalNodeModules(bunBin), packageName));
+}

package/src/server/lib/updates/omp.ts

@@ -16,7 +16,7 @@
 
 import { invalidateOmpCliCache, resolveOmpBin } from '@/server/lib/omp/core/cli';
 import { fetchNpmLatest, OMP_PACKAGE } from '@/server/lib/updates/npm';
-import { pumpStream } from '@/server/lib/updates/install';
+import { pumpStream } from '@/server/lib/updates/install-steps';
 import { isNewer } from '@/shared/lib/updates/semver';
 import type { UpdateTargetInfo } from '@/shared/types/updates';
 

package/src/server/routes/folders/batch-delete.ts

@@ -0,0 +1,68 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * POST /api/folders/batch-delete — unregister several workspaces in one request.
+ *
+ * Same semantics as `POST /api/folders/:folderId/delete`, which is what the
+ * workspace's own `⋯` menu performs: the sidebar registration goes, and a bound
+ * folder is tombstoned so the omp-project sync cannot re-add it on the next
+ * boot. Transcript files are NOT touched — removing a workspace has never meant
+ * removing the sessions on disk, and the sessions are separately selectable in
+ * the sidebar's session mode when that IS what the user wants.
+ *
+ * One request rather than N because a batch delete is one user action, and the
+ * confirmation dialog should report one summary instead of N answers.
+ */
+
+import { json } from '@/server/lib/remix-compat';
+import type { ActionFunctionArgs } from '@/server/lib/remix-compat';
+import { methodNotAllowed, parseJsonBody } from '@/server/lib/route-adapter';
+import { getDb } from '@/server/db.server';
+import { deleteWorkspaceFolder } from '@/shared/lib/workspace/project-settings';
+import { syncDiscoveryRootsWatch } from '@/server/lib/omp/config/roots-watch.server';
+import { emitRealtimeSignal } from '@/server/lib/realtime/signals.server';
+
+const MAX_BATCH = 200;
+
+export async function batchDeleteFolders({ request }: ActionFunctionArgs) {
+  if (request.method !== 'POST') {
+    return methodNotAllowed({ request, params: {} });
+  }
+
+  const parsed = await parseJsonBody<{ ids?: unknown }>(request);
+  if (!parsed.ok) return json({ error: 'Invalid JSON body' }, { status: 400 });
+
+  const raw = parsed.body.ids;
+  if (!Array.isArray(raw) || raw.some((id) => typeof id !== 'string' || id.length === 0)) {
+    return json({ error: 'ids must be an array of workspace ids' }, { status: 400 });
+  }
+  const ids = [...new Set(raw as string[])];
+  if (ids.length === 0) return json({ error: 'No workspaces selected' }, { status: 400 });
+  if (ids.length > MAX_BATCH) {
+    return json({ error: `At most ${MAX_BATCH} workspaces can be deleted at once.` }, { status: 400 });
+  }
+
+  const db = await getDb();
+  const removed: string[] = [];
+  const refused: { id: string; error: string; code?: string }[] = [];
+
+  for (const id of ids) {
+    // `deleteWorkspaceFolder` answers false for an id that is not a folder, and
+    // takes the id as a bound parameter — there is no path built from it here.
+    const deleted = await deleteWorkspaceFolder(db, id);
+    if (deleted) removed.push(id);
+    else refused.push({ id, error: 'Workspace not found', code: 'not_found' });
+  }
+
+  // One watcher reconcile and one republish for the whole batch: the removed
+  // folders' `.omp` roots leave scope together, and the sidebar re-reads once.
+  if (removed.length > 0) {
+    void syncDiscoveryRootsWatch();
+    emitRealtimeSignal('sidebar-structure');
+  }
+
+  return json({ success: refused.length === 0, removed, refused });
+}

package/src/server/routes/folders/index.ts

@@ -9,9 +9,13 @@ import {
   toggleFolder,
   updateFolderSettings,
 } from '@/server/routes/folders/folder';
+import { batchDeleteFolders } from '@/server/routes/folders/batch-delete';
 
 export const foldersBindings: HandlerBinding[] = [
   ...bindingsFor(foldersCreate, '/api/folders'),
+  // Static segment, registered before `:folderId/*` for the same reason the
+  // sessions batch route is: an id route must not swallow it.
+  { method: 'POST', path: '/api/folders/batch-delete', handler: batchDeleteFolders },
   ...actionBindings(foldersClone.action, '/api/folders/clone'),
   ...actionBindings(foldersMkdir.action, '/api/folders/mkdir'),
   ...actionBindings(pinFolder, '/api/folders/:folderId/pin'),