ompchamber 3.0.0 → 3.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ompchamber",
-  "version": "3.0.0",
+  "version": "3.1.1",
   "description": "Developer web console and diagnostic chamber for AI Oh-My-Pi — Elysia + Preact on Bun.",
   "license": "UNLICENSED",
   "author": "Wijanarko Putra Rajeb <wijanarko.rajeb@gmail.com>",

package/src/cli/lib/args.js

@@ -188,7 +188,7 @@ USAGE:
 COMMANDS:
   serve          Start the OMPChamber web server (default when no command is given)
   update         Update OMPChamber to the latest GitHub release
-  stop           Stop running OMPChamber instances (every one, or --port <port>)
+  stop           Stop the instances the CLI started (--port/--all to stop any)
   restart        Stop and start again (every CLI-started instance, or --port <port>)
   status         Show running instances (every one, or --port <port>)
   logs           Print or follow server logs (every instance, or --port <port>)
@@ -201,7 +201,7 @@ OPTIONS:
   --prod                  Run the production build instead of the dev server
   --foreground            Run the server in the foreground (no daemon)
   --no-daemon             Alias for --foreground
-  --all                   Explicit form of the default for stop/restart (every instance)
+  --all                   Every instance, including ones started outside the CLI
   -c, --check             Report whether a newer release exists without installing it
   --force                 Reinstall even when already up to date
   --no-restart            Do not restart a running instance after updating
@@ -226,7 +226,8 @@ EXAMPLES:
   ompchamber serve --prod          # Serve the production build
   ompchamber update --check        # Is a newer release available?
   ompchamber update                # Update, then restart a running instance
-  ompchamber stop                  # Stop the running instance
+  ompchamber stop                  # Stop the instances the CLI started
+  ompchamber stop --port 3000      # Stop the instance on port 3000, whoever started it
   ompchamber restart               # Restart the server
   ompchamber status                # Show whether the server is running
   ompchamber logs -f -n 200        # Follow the last 200 log lines

package/src/cli/lib/commands/restart.js

@@ -1,19 +1,20 @@
 // `ompchamber restart` — stop live instances, then serve again.
 //
 // Scoping matches `status` and `stop`: without `--port` every live instance is
-// restarted on its own recorded port/host/mode, and `--port <port>` restricts
-// the restart to that one. With nothing running, the command is simply `serve`.
+// considered, and `--port <port>` restricts the restart to that one. With
+// nothing running, the command is simply `serve`.
 //
 // Instances the CLI did not start are left alone, exactly as `ompchamber update`
 // leaves them: `bun run dev` and `bun run start` own their own process, so
-// replacing it would break a loop OMPChamber does not manage. `ompchamber stop`
-// is still the deliberate way to end one.
+// replacing it would break a loop OMPChamber does not manage. `ompchamber stop
+// --port <port>` (or `--all`) is the deliberate way to end one.
 
 import { findLiveInstance, listLiveInstances, stopInstance } from '@/cli/lib/runtime.js';
 import { STOP_TIMEOUT_MS } from '@/cli/lib/process-lifecycle.js';
 import { log, isJson, isQuiet } from '@/cli/lib/output.js';
 import { run as runServe } from '@/cli/lib/commands/serve.js';
-import { isAutoRestartable, skipRestartNote } from '@/server/lib/lifecycle/restart';
+import { skipRestartNote } from '@/server/lib/lifecycle/restart';
+import { isCliManaged } from '@/server/lib/lifecycle/launch-mode';
 
 function explicitPort(options) {
   const raw = options?.port;
@@ -34,7 +35,7 @@ export async function run(options, ctx) {
   if (targets.length === 0) return runServe(options, ctx);
 
   for (const live of targets) {
-    if (!isAutoRestartable(live.launchMode)) {
+    if (!isCliManaged(live.launchMode)) {
       if (!json && !quiet) log(`Skipping OMPChamber on port ${live.port}: ${skipRestartNote(live.launchMode)}.`);
       continue;
     }

package/src/cli/lib/commands/stop.js

@@ -1,22 +1,19 @@
-// `ompchamber stop` — stop one or every live OMPChamber instance.
+// `ompchamber stop` — stop OMPChamber instances.
+//
+// Scope follows OWNERSHIP, the same rule `restart` and `update` apply. By
+// default only the instances the CLI started are stopped, because a server
+// running from source is supervised by a launcher the CLI does not own and
+// that launcher exits with the child it spawned: `bun run dev` is a process
+// whose whole job is to mirror the script under it, so signalling the server
+// takes the user's dev loop down with it. `--port <port>` and `--all` are the
+// explicit forms that do end one — naming an instance is a deliberate call,
+// not a default.
 
 import { listLiveInstances, findLiveInstance, stopInstance } from '@/cli/lib/runtime.js';
 import { STOP_TIMEOUT_MS } from '@/cli/lib/process-lifecycle.js';
-import { ok, warn, printJson, isJson } from '@/cli/lib/output.js';
-
-function resolvePort(options) {
-  const raw = options?.port;
-  if (raw !== null && raw !== undefined) {
-    const parsed = Number(raw);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  const env = Bun.env.OMPCHAMBER_PORT;
-  if (typeof env === 'string' && env.trim().length > 0) {
-    const parsed = Number(env.trim());
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return 3000;
-}
+import { ok, warn, log, printJson, isJson, isQuiet } from '@/cli/lib/output.js';
+import { unmanagedReason } from '@/server/lib/lifecycle/launch-mode';
+import { partitionStopTargets } from '@/cli/lib/stop-scope.js';
 
 function explicitPort(options) {
   const raw = options?.port;
@@ -25,30 +22,40 @@ function explicitPort(options) {
   return Number.isFinite(parsed) ? parsed : null;
 }
 
+/** How to end an instance the default scope leaves alone. */
+function stopHint(port) {
+  return `stop it with \`ompchamber stop --port ${port}\` or \`ompchamber stop --all\``;
+}
+
 export async function run(options) {
   const json = isJson();
+  const quiet = isQuiet();
   const requested = explicitPort(options);
+  // `--all` is the explicit spelling of "every instance, whoever started it".
+  const explicitScope = requested !== null || Boolean(options?.all);
+
+  const live = requested !== null
+    ? [await findLiveInstance(requested)].filter(Boolean)
+    : await listLiveInstances();
+  const { targets, skipped } = partitionStopTargets(live, explicitScope);
+  const skippedReport = skipped.map((entry) => ({ port: entry.port, pid: entry.pid, launchMode: entry.launchMode }));
 
-  // No `--port` means every live instance: a CLI server, a dev run and a
-  // production server are three processes, and `stop` without a port is the
-  // command that clears all of them. `--all` is the explicit spelling of the
-  // same default, kept because it reads well in scripts.
-  let targets;
-  if (requested !== null) {
-    const live = await findLiveInstance(requested);
-    targets = live ? [live] : [];
-  } else {
-    targets = await listLiveInstances();
+  if (!json && !quiet) {
+    for (const entry of skipped) {
+      log(`Skipping OMPChamber on port ${entry.port} (pid ${entry.pid}): it ${unmanagedReason(entry.launchMode)} — ${stopHint(entry.port)}.`);
+    }
   }
 
   if (targets.length === 0) {
     if (json) {
-      printJson({ stopped: [] });
+      printJson({ stopped: [], skipped: skippedReport });
       return;
     }
-    warn(requested === null
-      ? 'No running OMPChamber instances found.'
-      : `No running OMPChamber instance on port ${requested}.`);
+    if (skipped.length === 0) {
+      warn(requested === null
+        ? 'No running OMPChamber instances found.'
+        : `No running OMPChamber instance on port ${requested}.`);
+    }
     return;
   }
 
@@ -64,5 +71,5 @@ export async function run(options) {
     }
   }
 
-  if (json) printJson({ stopped });
+  if (json) printJson({ stopped, skipped: skippedReport });
 }

package/src/cli/lib/commands/update.js

@@ -10,7 +10,8 @@ import { color, configure, error, log, ok, warn, printJson, isJson, isQuiet } fr
 import { listLiveInstances, findLiveInstance, stopInstance } from '@/cli/lib/runtime.js';
 import { STOP_TIMEOUT_MS } from '@/cli/lib/process-lifecycle.js';
 import { run as runServe } from '@/cli/lib/commands/serve.js';
-import { isAutoRestartable, skipRestartNote } from '@/server/lib/lifecycle/restart';
+import { skipRestartNote } from '@/server/lib/lifecycle/restart';
+import { isCliManaged } from '@/server/lib/lifecycle/launch-mode';
 import { resolveInstallContext, resolveOmpChamberVersion, updateOmpChamber } from '@/server/lib/updates/install';
 
 /**
@@ -30,7 +31,7 @@ async function restartInstances(options, ctx) {
   const restarted = [];
   const skipped = [];
   for (const entry of await liveInstances(options)) {
-    if (!isAutoRestartable(entry.launchMode)) {
+    if (!isCliManaged(entry.launchMode)) {
       skipped.push({ port: entry.port, pid: entry.pid, launchMode: entry.launchMode });
       log(`Skipping OMPChamber on port ${entry.port}: ${skipRestartNote(entry.launchMode)}.`);
       continue;

package/src/cli/lib/stop-scope.js

@@ -0,0 +1,23 @@
+// Ownership scope for `ompchamber stop`.
+//
+// Kept separate from the command so the rule is testable without a live
+// server: the default scope is the instances the CLI started, and only an
+// explicit `--port <port>` / `--all` widens it to the ones it did not. That
+// distinction is the whole reason this module exists — a server running from
+// source sits under a launcher that exits with its child, so stopping it by
+// default takes a `bun run dev` loop down with it.
+
+import { isCliManaged } from '@/server/lib/lifecycle/launch-mode';
+
+/**
+ * Split the live instances into the ones `stop` acts on and the ones it leaves
+ * alone. `explicit` is true when the user named a port or passed `--all`:
+ * naming an instance is a deliberate call, so ownership no longer gates it.
+ */
+export function partitionStopTargets(instances, explicit) {
+  if (explicit) return { targets: instances, skipped: [] };
+  return {
+    targets: instances.filter((entry) => isCliManaged(entry.launchMode)),
+    skipped: instances.filter((entry) => !isCliManaged(entry.launchMode)),
+  };
+}

package/src/cli/lib/stop-scope.test.js

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { partitionStopTargets } from '@/cli/lib/stop-scope.js';
+
+const daemon = { port: 3000, pid: 11, launchMode: 'daemon' };
+const foreground = { port: 3001, pid: 12, launchMode: 'foreground' };
+const dev = { port: 3002, pid: 13, launchMode: 'direct' };
+const unknown = { port: 3003, pid: 14, launchMode: 'unknown' };
+
+describe('partitionStopTargets', () => {
+  // The default scope is ownership, not "everything that answers /api/health".
+  // `bun run dev` is a supervisor whose only job is to mirror the script under
+  // it, so stopping that server exits the user's dev loop too — the bug this
+  // rule exists to prevent.
+  test('stops only the instances the CLI started when the scope is implicit', () => {
+    const { targets, skipped } = partitionStopTargets([daemon, dev, foreground, unknown], false);
+    expect(targets).toEqual([daemon, foreground]);
+    expect(skipped).toEqual([dev, unknown]);
+  });
+
+  // Naming an instance — a port or `--all` — is a deliberate call, so the
+  // ownership rule no longer gates it.
+  test('widens to every instance when the scope is explicit', () => {
+    const { targets, skipped } = partitionStopTargets([daemon, dev, unknown], true);
+    expect(targets).toEqual([daemon, dev, unknown]);
+    expect(skipped).toEqual([]);
+  });
+
+  test('an unreadable launch mode is never stopped implicitly', () => {
+    // A record whose launchMode could not be read must not authorise a kill:
+    // the safe reading is "not ours".
+    const { targets, skipped } = partitionStopTargets([{ port: 4000, pid: 99, launchMode: undefined }], false);
+    expect(targets).toEqual([]);
+    expect(skipped.length).toBe(1);
+  });
+});

package/src/client/components/common/code-editor/handler.test.ts

@@ -0,0 +1,274 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The editor's keydown dispatcher, exercised with a fake textarea.
+ *
+ * These assertions are the routing contract: which layer owns a key, and what
+ * happens to the event when nobody does. The failures they guard against are
+ * all silent — a chord that reaches the browser's own find bar, an Escape that
+ * throws away a multi-selection instead of dropping it, a Tab that escapes the
+ * editor mid-line.
+ *
+ * The platform is PINNED rather than detected. The dispatcher resolves chords
+ * through `isMacPlatform()`, so a test written with ⌘ chords passes on a
+ * developer's Mac and fails on the Linux CI runner — which is exactly what
+ * happened. `usePlatform()` below makes each case state the platform it means.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { handleEditorKeydown, runEditorCommand, type EditorKeydownDeps } from '@/client/components/common/code-editor/handler';
+import { createHistory, pushRecord } from '@/shared/lib/code/editor/history';
+import type { EditorHistory } from '@/client/hooks/editor/use-editor-history';
+import type { OccurrencesApi } from '@/client/hooks/editor/use-occurrences';
+import type { EditorCommand } from '@/shared/lib/code/editor/keymap';
+import type { TextRange } from '@/shared/lib/code/editor/commands';
+
+/** A textarea stand-in: the dispatcher only reads value/selection and calls blur. */
+function fakeInput(value: string, start: number, end = start) {
+  return {
+    value,
+    selectionStart: start,
+    selectionEnd: end,
+    blurred: false,
+    blur() {
+      this.blurred = true;
+    },
+  };
+}
+
+interface Harness {
+  deps: EditorKeydownDeps;
+  committed: Array<{ value: string; selectionStart: number; selectionEnd: number }>;
+  steps: string[];
+  delegated: EditorCommand[];
+  cleared: number;
+  selected: Array<[number, number]>;
+  ranges: TextRange[];
+  captureToggles: number;
+}
+
+function harness(options: { value: string; start?: number; end?: number; ranges?: TextRange[]; language?: string; delegate?: (c: EditorCommand) => boolean } = { value: '' }): Harness {
+  const committed: Harness['committed'] = [];
+  const steps: string[] = [];
+  const delegated: EditorCommand[] = [];
+  const selected: Array<[number, number]> = [];
+  const state = { ranges: options.ranges ? [...options.ranges] : [] as TextRange[] };
+  let cleared = 0;
+  let captureToggles = 0;
+
+  const history: EditorHistory = {
+    history: createHistory(),
+    buffer: options.value,
+    commit: (edit) => committed.push(edit),
+    commitEdit: (edit) => committed.push(edit),
+    step: (direction) => steps.push(direction),
+    markApplied: () => {},
+  };
+
+  const multi: OccurrencesApi = {
+    get ranges() {
+      return state.ranges;
+    },
+    set: (ranges) => {
+      state.ranges = [...ranges];
+    },
+    clear: () => {
+      cleared++;
+      state.ranges = [];
+    },
+    selectNext: (input, select) => select(input.selectionStart, input.selectionEnd + 1),
+    selectAll: (input, select) => select(0, input.value.length),
+    insertCursorBelow: () => {},
+    replicate: () => null,
+  };
+
+  const input = fakeInput(options.value, options.start ?? 0, options.end ?? options.start ?? 0);
+  const deps: EditorKeydownDeps = {
+    input: input as unknown as HTMLTextAreaElement,
+    language: options.language ?? 'typescript',
+    captureTab: true,
+    toggleCaptureTab: () => captureToggles++,
+    history,
+    multi,
+    select: (start, end) => selected.push([start, end]),
+    delegate: (command) => {
+      delegated.push(command);
+      options.delegate?.(command);
+    },
+  };
+
+  return {
+    deps,
+    committed,
+    steps,
+    delegated,
+    selected,
+    get cleared() {
+      return cleared;
+    },
+    get captureToggles() {
+      return captureToggles;
+    },
+    get ranges() {
+      return state.ranges;
+    },
+  } as Harness;
+}
+
+/** Run `body` with `navigator.platform` reporting `platform`. */
+function usePlatform<T>(platform: string, body: () => T): T {
+  const globals = globalThis as Record<string, unknown>;
+  const previous = globals.navigator;
+  globals.navigator = { platform };
+  try {
+    return body();
+  } finally {
+    if (previous === undefined) delete globals.navigator;
+    else globals.navigator = previous;
+  }
+}
+
+/** A keydown event with only the fields the dispatcher reads. */
+function press(key: string, code: string, modifiers: Partial<{ metaKey: boolean; ctrlKey: boolean; altKey: boolean; shiftKey: boolean }> = {}) {
+  const prevented = { value: false };
+  const event = {
+    key,
+    code,
+    metaKey: false,
+    ctrlKey: false,
+    altKey: false,
+    shiftKey: false,
+    ...modifiers,
+    preventDefault: () => {
+      prevented.value = true;
+    },
+  };
+  return { event: event as never, prevented };
+}
+
+describe('handleEditorKeydown', () => {
+  test('Escape drops a live multi-selection before it leaves the editor', () => {
+    const first = harness({ value: 'abc', ranges: [{ start: 1, end: 2 }] });
+    const one = press('Escape', 'Escape');
+    handleEditorKeydown(one.event, first.deps);
+
+    expect(first.cleared).toBe(1);
+    expect(one.prevented.value).toBe(true);
+
+    // With no extra ranges left, Escape is a plain blur.
+    const input = first.deps.input as unknown as { blurred: boolean };
+    const two = press('Escape', 'Escape');
+    handleEditorKeydown(two.event, first.deps);
+
+    expect(input.blurred).toBe(true);
+    expect(two.prevented.value).toBe(false);
+  });
+
+  test('Tab indents through the history, not through a raw write', () => {
+    const h = harness({ value: 'one', start: 0 });
+    const { event, prevented } = press('Tab', 'Tab');
+    handleEditorKeydown(event, h.deps);
+
+    expect(prevented.value).toBe(true);
+    expect(h.committed[0].value).toBe('  one');
+  });
+
+  test('undo and redo step the history and drop the extra ranges', () => {
+    const h = harness({ value: 'abc', ranges: [{ start: 1, end: 2 }] });
+    usePlatform('MacIntel', () => handleEditorKeydown(press('z', 'KeyZ', { metaKey: true }).event, h.deps));
+
+    expect(h.steps).toEqual(['undo']);
+    expect(h.cleared).toBe(1);
+  });
+
+  test('a line command commits and clears the ranges it just invalidated', () => {
+    const h = harness({ value: 'one\ntwo', start: 0, end: 3, ranges: [{ start: 8, end: 9 }] });
+    handleEditorKeydown(press('ArrowDown', 'ArrowDown', { altKey: true }).event, h.deps);
+
+    expect(h.committed[0].value).toBe('two\none');
+    expect(h.cleared).toBe(1);
+  });
+
+  test('⌘D routes to the occurrence grower with the editor’s own select', () => {
+    const h = harness({ value: 'alpha', start: 0, end: 5 });
+    usePlatform('MacIntel', () => handleEditorKeydown(press('d', 'KeyD', { metaKey: true }).event, h.deps));
+
+    expect(h.selected).toEqual([[0, 6]]);
+  });
+
+  test('a find-bar chord is delegated and consumed', () => {
+    // The bar may not be open: nothing handles ⌘F, but the browser's own find
+    // bar must not open over the editor either — so the chord is consumed
+    // whatever the panel does with it.
+    const h = harness({ value: 'abc' });
+    const { event, prevented } = press('f', 'KeyF', { metaKey: true });
+    usePlatform('MacIntel', () => handleEditorKeydown(event, h.deps));
+
+    expect(h.delegated).toEqual(['find']);
+    expect(prevented.value).toBe(true);
+  });
+
+  test('a palette-style call runs a text command with no event at all', () => {
+    const h = harness({ value: 'one\ntwo', start: 0, end: 3 });
+    runEditorCommand('copyLineDown', h.deps);
+
+    expect(h.committed[0].value).toBe('one\none\ntwo');
+  });
+
+  test('an unbound chord is left to the browser', () => {
+    const h = harness({ value: 'abc' });
+    const { event, prevented } = press('a', 'KeyA', { metaKey: true });
+    handleEditorKeydown(event, h.deps);
+
+    expect(h.delegated).toEqual([]);
+    expect(prevented.value).toBe(false);
+  });
+
+  test('a chord built on Enter reaches the keymap instead of the plain-Enter branch', () => {
+    // ⌘⏎ is `insertLineBelow`; the plain-Enter auto-indent branch used to catch
+    // it first and do nothing on an unindented line, making the command dead.
+    const h = harness({ value: 'const a = 1;\nconst b = 2;', start: 20 });
+    usePlatform('MacIntel', () => handleEditorKeydown(press('Enter', 'Enter', { metaKey: true }).event, h.deps));
+
+    expect(h.committed[0].value).toBe('const a = 1;\nconst b = 2;\n');
+  });
+
+  test('plain Enter still auto-indents', () => {
+    const h = harness({ value: '  one', start: 5 });
+    handleEditorKeydown(press('Enter', 'Enter').event, h.deps);
+
+    expect(h.committed[0].value).toBe('  one\n  ');
+  });
+
+  test('⌘[ outdents the line the caret is on, with nothing selected', () => {
+    const h = harness({ value: '  one', start: 2 });
+    usePlatform('MacIntel', () => handleEditorKeydown(press('[', 'BracketLeft', { metaKey: true }).event, h.deps));
+
+    expect(h.committed[0].value).toBe('one');
+    expect(h.committed[0].selectionStart).toBe(0);
+  });
+
+  test('Ctrl+M still toggles Tab capture', () => {
+    const h = harness({ value: 'abc' });
+    // On macOS the chord needs Shift (Ctrl+M alone is Return in the terminal's
+    // own vocabulary), which is what the handler encodes. Both platforms are
+    // exercised explicitly rather than detected.
+    usePlatform('Win32', () => handleEditorKeydown(press('m', 'KeyM', { ctrlKey: true }).event, h.deps));
+    expect(h.captureToggles).toBe(1);
+
+    usePlatform('MacIntel', () => handleEditorKeydown(press('m', 'KeyM', { ctrlKey: true, shiftKey: true }).event, h.deps));
+    expect(h.captureToggles).toBe(2);
+  });
+});
+
+describe('editor keymap ownership', () => {
+  test('the editor’s own history is seeded, not the browser’s', () => {
+    const history = createHistory();
+    pushRecord(history, { value: 'a', selectionStart: 1, selectionEnd: 1, timestamp: 1 });
+    expect(history.stack.length).toBe(1);
+  });
+});