@kabmo-labs/kabmo 0.3.1 → 0.5.0

package/src/shared/lib/workspace/panel-ids.ts

@@ -1,15 +1,26 @@
 /**
- * Panel ids: the built-in right-panel views plus the panels plugin code
- * contributes.
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Panel ids: the built-in views plus the panels plugin code contributes.
  *
- * A plugin panel's id is `plugin:<pluginId>` — one string the layout stores,
- * keys widths by, and resolves a component from. Keeping it a plain string
- * rather than a second union member is what lets the activity bar, the mobile
- * tab bar and the width map handle a plugin without each learning about it.
+ * A plugin panel's id is `plugin:<pluginId>:<slot>` — one string the layout
+ * stores, keys widths by, and resolves a component from. One plugin contributes
+ * at most one panel PER SLOT (`rightPanel`, `panel`), and a plugin may register
+ * both: `marketplace/plugins/session-info` ships a `rightPanel` and a `panel`.
+ * The slot segment is what keeps those two apart.
  *
- * There is no panel-id segment because a plugin contributes AT MOST ONE panel
- * per slot: the layout gives it one activity-bar button and one editor tab, so
- * a second id could never be reached.
+ * It was not always. The id used to carry a panel segment, then dropped it on the
+ * claim that a plugin contributes at most one panel — true per slot, false per
+ * plugin. With the editor column's slot reachable again, one id for both would
+ * make them one entry in the enablement set, one width and one placement, so
+ * moving a plugin's right panel would move its editor panel with it.
+ *
+ * The BARE form is the one that shipped and is still accepted, resolving to the
+ * `rightPanel` slot — see {@link migrateLegacyPanelId}. Writers emit the
+ * segmented form; readers accept both.
  */
 
 import { RIGHT_PANEL_TYPES, type RightPanelType } from '@/shared/lib/workspace/right-panels';
@@ -17,43 +28,120 @@ import { RIGHT_PANEL_TYPES, type RightPanelType } from '@/shared/lib/workspace/r
 /** Prefix every plugin-contributed panel id carries. */
 export const PLUGIN_PANEL_PREFIX = 'plugin:';
 
-/** `plugin:<pluginId>` for a plugin's contributed panel. */
-export function pluginPanelKey(pluginId: string): string {
+/**
+ * The slots a plugin can contribute a panel to.
+ *
+ * NOT `headerPanel`/`settingsSection`: those are not panels — one is a navbar
+ * entry, the other a settings block — and neither keys a width or a placement.
+ */
+export const PLUGIN_PANEL_SLOTS = ['rightPanel', 'panel'] as const;
+
+export type PluginPanelSlot = (typeof PLUGIN_PANEL_SLOTS)[number];
+
+/** The slot a bare `plugin:<id>` names: the form that shipped. */
+/** The slot a bare `plugin:<id>` names, where an INSTANCE key is expected. */
+export const LEGACY_PLUGIN_SLOT: PluginPanelSlot = 'rightPanel';
+
+/**
+ * `plugin:<pluginId>:<slot>` — ONE PANEL of a plugin.
+ *
+ * The key every panel-shaped store uses: the width map, the dock placement, the
+ * stored order and the active selection. Two panels of one plugin are two panels
+ * here, which is the whole point.
+ */
+export function pluginPanelKey(pluginId: string, slot: PluginPanelSlot): string {
+  return `${PLUGIN_PANEL_PREFIX}${pluginId}:${slot}`;
+}
+
+/**
+ * `plugin:<pluginId>` — the PLUGIN, not a panel.
+ *
+ * Separate from {@link pluginPanelKey} on purpose. Enablement is per PLUGIN: the
+ * Settings switch says "Disable <plugin>" and the server gates that plugin's
+ * BUNDLE on this key, so one switch has to be one id no matter how many panels
+ * the plugin contributes. Making enablement per panel would leave a plugin whose
+ * bundle is still served while half its panels are "off".
+ *
+ * This is also the form that shipped, so every stored disabled row still names a
+ * plugin and needs no migration.
+ */
+export function pluginEnablementKey(pluginId: string): string {
   return `${PLUGIN_PANEL_PREFIX}${pluginId}`;
 }
 
+function isSlot(value: string): value is PluginPanelSlot {
+  return (PLUGIN_PANEL_SLOTS as readonly string[]).includes(value);
+}
+
 /**
- * The plugin id a panel id names, or null when `value` is not one.
+ * The parts of a plugin panel id, or null.
+ *
+ * Two shapes are accepted, and the second is DELIBERATELY the one that shipped:
  *
- * The segment must be non-empty: `plugin:` is the shape a truncated write or a
- * half-typed value produces, and accepting it would key a width map and a
- * component lookup on an id no registry can ever report.
+ * - `plugin:<id>:<slot>` — the current form;
+ * - `plugin:<id>` — a stored blob, an enablement row or an order entry written
+ *   before the slot segment existed. It resolves to `rightPanel`, because that
+ *   was the only reachable slot when it was written.
+ *
+ * The plugin id is validated as ONE segment: an empty id, a slash or a third
+ * colon is a truncated write or a hand-edited blob, and accepting it would key a
+ * width map and a component lookup on an id no registry can report.
  */
-export function pluginKeyOf(value: unknown): string | null {
+export function pluginPanelParts(value: unknown): { pluginId: string; slot: PluginPanelSlot } | null {
   if (typeof value !== 'string' || !value.startsWith(PLUGIN_PANEL_PREFIX)) return null;
   const rest = value.slice(PLUGIN_PANEL_PREFIX.length);
-  if (!rest || rest.includes('/')) return null;
-  return value;
+  const pieces = rest.split(':');
+  if (pieces.length > 2) return null;
+  const [pluginId, slot] = pieces;
+  if (!pluginId || pluginId.includes('/')) return null;
+  if (slot === undefined) return { pluginId, slot: LEGACY_PLUGIN_SLOT };
+  if (!isSlot(slot)) return null;
+  return { pluginId, slot };
+}
+
+/**
+ * The PANEL INSTANCE key a stored value names, or null.
+ *
+ * A bare `plugin:<id>` normalizes to the `rightPanel` instance, because that was
+ * the only reachable slot when such a row was written — the width map, the dock
+ * placement and the stored order all read through here, so a row from an older
+ * build keeps pointing at the panel it pointed at before.
+ */
+export function pluginKeyOf(value: unknown): string | null {
+  const parts = pluginPanelParts(value);
+  return parts ? pluginPanelKey(parts.pluginId, parts.slot) : null;
+}
+
+/** Whether a stored value is the retired bare form, and what it resolves to. */
+export function migrateLegacyPanelId(value: unknown): { from: string; to: string } | null {
+  const parts = pluginPanelParts(value);
+  if (!parts || typeof value !== 'string') return null;
+  const to = pluginPanelKey(parts.pluginId, parts.slot);
+  return value === to ? null : { from: value, to };
 }
 
 /** The plugin id inside a panel id, or null. */
 export function pluginIdOf(value: unknown): string | null {
-  const key = pluginKeyOf(value);
-  return key ? key.slice(PLUGIN_PANEL_PREFIX.length) : null;
+  return pluginPanelParts(value)?.pluginId ?? null;
+}
+
+/** The slot a panel id names, or null when `value` is not a plugin panel id. */
+export function pluginSlotOf(value: unknown): PluginPanelSlot | null {
+  return pluginPanelParts(value)?.slot ?? null;
 }
 
 /**
- * Whether a stored `layout.activeRightPanel` may be adopted on load.
+ * Whether a stored `layout.activeRightPanel` / width key may be adopted on load.
  *
  * A plugin panel is accepted on the shape of its id alone: the registry is a
  * network read and the slots exist only after a bundle has been imported, so
- * requiring the panel to be present would drop a perfectly valid selection
- * every time the server is slower than the first paint. A panel whose plugin
- * has since been uninstalled renders its own "not installed" notice rather than
- * falling back silently to Files.
+ * requiring the panel to be present would drop a perfectly valid selection every
+ * time the server is slower than the first paint. A panel whose plugin has since
+ * been uninstalled renders its own "not installed" notice rather than falling
+ * back silently to Files.
  */
 export function isPanelId(value: unknown): value is string {
-  return (RIGHT_PANEL_TYPES as readonly string[]).includes(value as string) || pluginKeyOf(value) !== null;
+  return (RIGHT_PANEL_TYPES as readonly string[]).includes(value as string) || pluginPanelParts(value) !== null;
 }
 
 export type { RightPanelType };

package/src/shared/lib/workspace/sidebar-width.ts

@@ -43,6 +43,10 @@ export const DEFAULT_LEFT_PANEL_WIDTH = 280;
  * `MIN_CHAT_PANEL_WIDTH` in `panel-widths.ts`: the sidebar cannot open past 500
  * and still leave the editor (320) and a browser view (320) room on a 1440px
  * display.
+ *
+ * It was raised to 720 for a second left pane and put back when that pane was
+ * removed: the dock holds ONE panel beside the list, and a wider ceiling would
+ * only invite a column nothing else in the layout budgets for.
  */
 export const MIN_LEFT_PANEL_WIDTH = 264;
 export const MAX_LEFT_PANEL_WIDTH = 500;

package/src/shared/types/index.ts

@@ -4,6 +4,7 @@ export * from '@/shared/types/fs';
 export * from '@/shared/types/git';
 export * from '@/shared/types/chat';
 export * from '@/shared/types/schedule';
+export * from '@/shared/types/waiting';
 export * from '@/shared/types/btw';
 export * from '@/shared/types/models';
 export * from '@/shared/types/terminal';

package/src/shared/types/waiting.ts

@@ -0,0 +1,54 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * A prompt held until another session finishes.
+ *
+ * The row is Kabmo's own (SQLite `waiting_prompts`): omp has no notion of a
+ * prompt that has not been sent yet, so the wait has to live somewhere that
+ * outlives the tab. Its `dependsOn` session is a SESSION ID, never a snapshot of
+ * its state — the state is re-read at each sweep, because a session that looks
+ * finished can pick up a queued follow-up a moment later.
+ */
+
+import type { Attachment, QueuedMessageModel } from '@/shared/types/chat';
+
+export type WaitingPromptStatus = 'waiting' | 'dispatched' | 'cancelled' | 'error';
+
+/** Plan/goal flags the spawn must carry (a new session has no JSONL to read). */
+export interface WaitingPromptModes {
+  plan: boolean;
+  goal: boolean;
+}
+
+export interface WaitingPrompt {
+  id: string;
+  /**
+   * The client's pending id (`new-…`) this prompt belongs to. The dispatch
+   * answers with omp's real session id, and the client moves the sidebar row
+   * across by this pairing — the same adoption the local send path performs.
+   */
+  pendingId: string | null;
+  /** The session whose completion releases this prompt. */
+  dependsOn: string;
+  /** Title of `dependsOn` at creation time, for the waiting row's own label. */
+  dependsOnTitle: string | null;
+  /** Composer text as the user typed it. */
+  prompt: string;
+  attachments: Attachment[];
+  /** Model/thinking/access snapshot, replayed at dispatch. */
+  model: QueuedMessageModel | null;
+  modes: WaitingPromptModes | null;
+  /** Absolute directory the new session spawns in, resolved at creation. */
+  cwd: string;
+  folderId: number | null;
+  status: WaitingPromptStatus;
+  /** omp's real session id, once the prompt was dispatched. */
+  sessionId: string | null;
+  /** Why the dispatch failed (status `error`). */
+  error: string | null;
+  createdAt: number;
+  updatedAt: number;
+}

package/src/shared/types/workspace.ts

@@ -30,6 +30,14 @@ export interface SessionItemData {
    *  provider/model in every tab and Kabmo instances. Absent for a session
    *  with no run row; callers fall back to the transcript's model entry. */
   runModel?: { provider: string; modelId: string };
+  /**
+   * Set on a PENDING row whose prompt is held until another session finishes.
+   *
+   * The row has no transcript and no omp id yet — it exists because the user
+   * sent a prompt that is deferred, and the cue is the only thing on screen
+   * saying so. Absent means the row is not waiting (the normal case).
+   */
+  waitingFor?: { waitId: string; sessionId: string; title: string | null };
 }
 
 /**

package/src/test-support/isolated-db.ts

@@ -23,14 +23,14 @@ import { mkdtempSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
+import { closeDb } from '@/server/db.server';
 import { removeDir } from '@/test-support/remove-dir';
 
 let dir: string | null = null;
 
 /** Point the process at a fresh database. Call from `beforeEach`. */
 export function isolateDb(): string {
-  globalThis.__kabmoDb?.resolved?.raw.close();
-  globalThis.__kabmoDb = undefined;
+  closeDb();
 
   dir = mkdtempSync(join(tmpdir(), 'omc-db-'));
   const path = join(dir, 'db.sqlite');
@@ -40,8 +40,7 @@ export function isolateDb(): string {
 
 /** Close the handle and drop the temp directory. Call from `afterEach`. */
 export function releaseDb(): void {
-  globalThis.__kabmoDb?.resolved?.raw.close();
-  globalThis.__kabmoDb = undefined;
+  closeDb();
   delete Bun.env.KABMO_DB_PATH;
   // `removeDir`, not a bare `rmSync`: a closed SQLite handle is released by the
   // OS asynchronously on Windows, so the delete races it and fails with EBUSY —

package/src/test-support/silent-socket.ts

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * A `WebSocket` that never dials, and the teardown pair that goes with it.
+ *
+ * A suite that mounts a component reading a realtime topic subscribes to the
+ * unified channel on mount, and `dial()` then constructs a real socket from
+ * `window.location`. Two failure shapes follow, and both are reported against
+ * whichever file runs NEXT rather than the one that caused them:
+ *
+ * - a happy-dom window created with no URL reports `about:blank`, whose origin
+ *   is `null`, so `realtimeSocketUrl()` produces `ws:///api/realtime/ws`. Bun
+ *   constructs that object without complaint and fails it ASYNCHRONOUSLY, after
+ *   the suite has already restored the DOM globals — measured as
+ *   `Unhandled error. (ErrorEvent { isTrusted: [Getter] })` between tests, and
+ *   then as `Cannot call beforeAll() after the test run has completed` in the
+ *   next file, because the error tears the run down mid-file.
+ * - a window WITH an origin dials a port nothing listens on, which fails the
+ *   same way (a refused connection is also asynchronous).
+ *
+ * `resetRealtimeClient()` in `afterEach` is not enough on its own: it closes a
+ * socket that already exists, and the dial's own failure has not been delivered
+ * yet. Silencing the CONSTRUCTOR is what removes the failure at its source.
+ *
+ * The subject of such a suite is its own markup, never the channel, so this
+ * stub sends nothing and reports nothing. A suite that really drives the
+ * channel uses `startRealtimeTestServer` instead, which injects the runner's
+ * own `WebSocket` (see `pristineWebSocket`).
+ */
+
+import { realtimeClient, resetRealtimeClient } from '@/shared/lib/realtime/client';
+
+/** `WebSocket.CLOSING` / `CLOSED`, spelled out: the client reads them off the
+ *  instance, and this object need not carry the statics. */
+class SilentSocket {
+  static readonly CONNECTING = 0;
+  static readonly OPEN = 1;
+  static readonly CLOSING = 2;
+  static readonly CLOSED = 3;
+  readyState = SilentSocket.CLOSED;
+  onopen: (() => void) | null = null;
+  onclose: (() => void) | null = null;
+  onmessage: ((event: { data: string }) => void) | null = null;
+  onerror: (() => void) | null = null;
+  send(): void {}
+  close(): void {}
+}
+
+/**
+ * Point the channel at `SilentSocket`. Call it BEFORE mounting anything that
+ * subscribes — a dial that already happened is not retracted by this.
+ */
+export function silenceRealtime(): void {
+  realtimeClient.setSocketConstructor(SilentSocket as unknown as typeof WebSocket);
+}
+
+/**
+ * Undo `silenceRealtime` and drop the channel's state. This is the `afterEach`
+ * half: the constructor goes back to `null` (the real global) so the next file
+ * is not left silenced, and the reset clears the topic cache the stubbed
+ * channel accumulated.
+ */
+export function restoreRealtime(): void {
+  resetRealtimeClient();
+  realtimeClient.setSocketConstructor(null);
+}