ompchamber 0.5.0 → 0.7.0

package/package.json

@@ -1,7 +1,9 @@
 {
   "name": "ompchamber",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "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>",
   "type": "module",
   "engines": {
     "bun": ">=1.4.0"
@@ -32,12 +34,12 @@
     "tsconfig.json"
   ],
   "scripts": {
-    "dev:server": "bun run --hot src/server/index.ts",
+    "dev:server": "NODE_ENV=development bun run --hot src/server/index.ts --ompchamber-server",
     "dev:client": "rsbuild build --watch",
-    "dev": "NODE_ENV=development bun run dev:server & bun run dev:client; wait",
-    "dev:lan": "HOST=0.0.0.0 NODE_ENV=development bun run dev:server & bun run dev:client; wait",
+    "dev": "bun run dev:server & bun run dev:client; wait",
+    "dev:lan": "HOST=0.0.0.0 bun run dev:server & bun run dev:client; wait",
     "build": "rsbuild build",
-    "start": "NODE_ENV=production bun run src/server/index.ts",
+    "start": "NODE_ENV=production bun run src/server/index.ts --ompchamber-server",
     "typecheck": "tsc",
     "clean": "rm -rf dist",
     "lint": "tsc --noEmit",
@@ -65,10 +67,18 @@
   "devDependencies": {
     "@rsbuild/core": "^2.2.7",
     "@rsbuild/plugin-preact": "^2.1.0",
+    "@semantic-release/changelog": "^7.0.0",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/git": "^11.0.1",
+    "@semantic-release/github": "^12.0.10",
+    "@semantic-release/npm": "^13.2.0",
+    "@semantic-release/release-notes-generator": "^14.1.1",
     "@tailwindcss/postcss": "^4.1.14",
     "@types/bun": "^1.4.2",
     "@types/node": "^22.14.0",
+    "conventional-changelog-conventionalcommits": "^9.3.1",
     "happy-dom": "^20.14.5",
+    "semantic-release": "^25.0.9",
     "tailwindcss": "^4.1.14",
     "typescript": "~5.8.2"
   }

package/src/cli/lib/args.js

@@ -188,20 +188,20 @@ USAGE:
 COMMANDS:
   serve          Start the OMPChamber web server (default when no command is given)
   update         Update OMPChamber to the latest GitHub release
-  stop           Stop the running OMPChamber instance
-  restart        Stop and then start the server again
-  status         Show the status of the running instance
-  logs           Print or follow the server log output
+  stop           Stop running OMPChamber instances (every one, or --port <port>)
+  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>)
 
 OPTIONS:
-  -p, --port <port>       Web server port (default: 3000)
+  -p, --port <port>       Web server port (default: 3000); scopes status/stop/restart/logs
   --host <address>        Bind address (default: 127.0.0.1)
   --hostname <address>    Alias for --host
   --lan                   Bind to 0.0.0.0 for LAN access
   --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                   Apply the command to every running instance
+  --all                   Explicit form of the default for stop/restart (every instance)
   -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

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

@@ -1,8 +1,14 @@
-// `ompchamber logs` — print or follow the server log file.
-
-import { findLiveInstance } from '@/cli/lib/runtime.js';
+// `ompchamber logs` — print or follow the server logs.
+//
+// Scoping matches `status`/`stop`/`restart`: without `--port` the logs of every
+// live instance are shown, each behind a `==> path <==` header, and `--port
+// <port>` restricts the output to that instance. With nothing running, the log
+// of the requested (or default) port is shown so a stopped server's output is
+// still readable.
+
+import { findLiveInstance, listLiveInstances } from '@/cli/lib/runtime.js';
 import { getLogFilePath } from '@/cli/lib/paths.js';
-import { log, printJson, fail, isJson, isQuiet } from '@/cli/lib/output.js';
+import { log, warn, printJson, fail, isJson, isQuiet } from '@/cli/lib/output.js';
 const DEFAULT_LINES = 50;
 const FOLLOW_INTERVAL_MS = 300;
 
@@ -39,36 +45,47 @@ function writeLines(lines) {
   }
 }
 
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+async function readTail(target, lineCount) {
+  const content = await Bun.file(target.logFile).text();
+  return { port: target.port, logFile: target.logFile, lines: splitLines(content).slice(-lineCount) };
 }
 
-async function followFile(filePath, initialCount) {
-  const initial = await Bun.file(filePath).text();
-  writeLines(splitLines(initial).slice(-initialCount));
+/** Per-file read position, so following several logs keeps them independent. */
+async function followFiles(targets, multiple) {
+  const state = [];
+  for (const target of targets) {
+    let position = 0;
+    try {
+      position = (await Bun.file(target.logFile).stat()).size;
+    } catch {
+      position = 0;
+    }
+    state.push({ target, position });
+  }
 
-  let position = Buffer.byteLength(initial, 'utf8');
   let running = true;
   const stop = () => { running = false; };
-
   process.once('SIGINT', stop);
   process.once('SIGTERM', stop);
+
   try {
     while (running) {
-      await sleep(FOLLOW_INTERVAL_MS);
-
-      let size;
-      try {
-        size = (await Bun.file(filePath).stat()).size;
-      } catch {
-        continue;
+      await Bun.sleep(FOLLOW_INTERVAL_MS);
+      for (const entry of state) {
+        let size;
+        try {
+          size = (await Bun.file(entry.target.logFile).stat()).size;
+        } catch {
+          continue;
+        }
+        if (size < entry.position) entry.position = 0;
+        if (size === entry.position) continue;
+
+        if (multiple) process.stdout.write(`==> ${entry.target.logFile} <==\n`);
+        const chunk = await Bun.file(entry.target.logFile).slice(entry.position, size).text();
+        entry.position = size;
+        process.stdout.write(chunk);
       }
-      if (size < position) position = 0;
-      if (size === position) continue;
-
-      const chunk = await Bun.file(filePath).slice(position, size).text();
-      position = size;
-      process.stdout.write(chunk);
     }
   } finally {
     process.removeListener('SIGINT', stop);
@@ -80,11 +97,28 @@ export async function run(options) {
   const json = isJson();
   const quiet = isQuiet();
   const requested = explicitPort(options);
-  const live = await findLiveInstance(requested);
-  const logFile = live?.logFile ?? getLogFilePath(requested ?? resolvePort(options));
+  const fallbackPort = requested ?? resolvePort(options);
 
-  if (!(await Bun.file(logFile).exists())) {
-    fail(`No log file found at ${logFile}.\nStart the server first with \`ompchamber serve\`.`);
+  const instances = requested !== null
+    ? [await findLiveInstance(requested)].filter(Boolean)
+    : await listLiveInstances();
+
+  const candidates = instances.length > 0
+    ? instances.map((entry) => ({ port: entry.port, logFile: entry.logFile ?? getLogFilePath(entry.port) }))
+    : [{ port: fallbackPort, logFile: getLogFilePath(fallbackPort) }];
+
+  const targets = [];
+  const skipped = [];
+  for (const candidate of candidates) {
+    if (await Bun.file(candidate.logFile).exists()) targets.push(candidate);
+    else skipped.push(candidate);
+  }
+  if (targets.length === 0) {
+    // A server started outside the CLI (`bun run dev`) logs to its own terminal,
+    // so its recorded port has no file here even though it is very much alive.
+    fail(skipped.length > 0 && instances.length > 0
+      ? `No log file at ${skipped[0].logFile}.\nPort ${skipped[0].port} was not started by the CLI — its output goes to the terminal that started it.`
+      : `No log file found at ${candidates[0].logFile}.\nStart the server first with \`ompchamber serve\`.`);
   }
 
   const requestedLines = Number(options?.lines);
@@ -93,16 +127,24 @@ export async function run(options) {
     : DEFAULT_LINES;
 
   if (json) {
-    printJson({ logFile, lines: splitLines(await Bun.file(logFile).text()).slice(-lineCount) });
+    const tails = [];
+    for (const target of targets) tails.push(await readTail(target, lineCount));
+    printJson({ instances: tails, skipped: skipped.map((entry) => ({ port: entry.port, logFile: entry.logFile })) });
     return;
   }
 
-  if (!quiet) log(`Log file: ${logFile}`);
+  const multiple = targets.length > 1;
+  if (!quiet) {
+    log(multiple ? `Log files: ${targets.length} instances` : `Log file: ${targets[0].logFile}`);
+    if (skipped.length > 0) {
+      warn(`Skipped ${skipped.length} instance(s) without a CLI log file: port ${skipped.map((entry) => entry.port).join(', ')}`);
+    }
+  }
 
-  if (options?.follow) {
-    await followFile(logFile, lineCount);
-    return;
+  for (const target of targets) {
+    if (multiple) process.stdout.write(`==> ${target.logFile} <==\n`);
+    writeLines(splitLines(await Bun.file(target.logFile).text()).slice(-lineCount));
   }
 
-  writeLines(splitLines(await Bun.file(logFile).text()).slice(-lineCount));
+  if (options?.follow) await followFiles(targets, multiple);
 }

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

@@ -1,9 +1,19 @@
-// `ompchamber restart` — stop the live instance (if any), then serve again.
+// `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`.
+//
+// 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.
 
-import { findLiveInstance, stopInstance } from '@/cli/lib/runtime.js';
+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';
 
 function explicitPort(options) {
   const raw = options?.port;
@@ -15,14 +25,36 @@ function explicitPort(options) {
 export async function run(options, ctx) {
   const json = isJson();
   const quiet = isQuiet();
-  const live = await findLiveInstance(explicitPort(options));
+  const requested = explicitPort(options);
 
-  if (live) {
-    if (!json && !quiet) {
-      log(`Stopping OMPChamber on port ${live.port} (pid ${live.pid})...`);
+  const targets = requested !== null
+    ? [await findLiveInstance(requested)].filter(Boolean)
+    : await listLiveInstances();
+
+  if (targets.length === 0) return runServe(options, ctx);
+
+  for (const live of targets) {
+    if (!isAutoRestartable(live.launchMode)) {
+      if (!json && !quiet) log(`Skipping OMPChamber on port ${live.port}: ${skipRestartNote(live.launchMode)}.`);
+      continue;
     }
+
+    if (!json && !quiet) log(`Stopping OMPChamber on port ${live.port} (pid ${live.pid})...`);
     await stopInstance(live, { timeoutMs: STOP_TIMEOUT_MS });
-  }
 
-  return runServe(options, ctx);
+    // Reuse the recorded port/host/mode so an instance started on a non-default
+    // port, or bound to the LAN, comes back the way it was found.
+    await runServe(
+      {
+        ...options,
+        port: live.port,
+        host: live.host,
+        lan: live.host === '0.0.0.0',
+        prod: live.mode === 'prod',
+        foreground: false,
+        all: false,
+      },
+      ctx,
+    );
+  }
 }

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

@@ -6,8 +6,8 @@ import {
   buildServeInvocation,
   waitForHealth,
   findLiveInstance,
-  probeHost,
 } from '@/cli/lib/runtime.js';
+import { probeHost } from '@/server/lib/lifecycle/probe';
 import { log, ok, warn, fail, printJson, isJson, isQuiet } from '@/cli/lib/output.js';
 import { wireChildProcessLifecycle } from '@/cli/lib/process-lifecycle.js';
 import { ompStartupError } from '@/server/lib/omp/core/startup';
@@ -64,14 +64,22 @@ export async function run(options, ctx) {
 
   const existing = await findLiveInstance(port);
   if (existing) {
-    fail(`An OMPChamber instance is already running on port ${port} (pid ${existing.pid}).\nUse \`ompchamber restart\` or a different \`--port\`.`);
+    // Refused here as well as in the server (lib/lifecycle/port-guard) so the
+    // CLI reports it immediately instead of spawning a child that exits during
+    // the health wait. Nothing is stopped: freeing a port is `ompchamber stop`.
+    fail(
+      `Port ${port} is already served by OMPChamber (pid ${existing.pid}, ${existing.mode}).`
+      + '\n  Nothing was stopped — a starting instance never stops another one.'
+      + `\n  Stop it first:  ompchamber stop --port ${port}`
+      + `\n  Or start on another port:  ompchamber serve --port <port>`,
+    );
   }
 
   if (options?.foreground) {
     return runForeground({ pkgRoot, mode, port, host, quiet });
   }
 
-  const { entry } = spawnDetachedServer({ pkgRoot, mode, port, host });
+  const { entry } = spawnDetachedServer({ pkgRoot, mode, port, host, launchMode: 'daemon' });
 
   if (!quiet && !json) {
     log(`Starting OMPChamber (${mode}) on ${entry.url} (pid ${entry.pid})...`);
@@ -96,7 +104,7 @@ export async function run(options, ctx) {
 }
 
 function runForeground({ pkgRoot, mode, port, host, quiet }) {
-  const { file, args, env } = buildServeInvocation({ pkgRoot, mode, port, host });
+  const { file, args, env } = buildServeInvocation({ pkgRoot, mode, port, host, launchMode: 'foreground' });
   const url = `http://${probeHost(host)}:${port}`;
   if (!quiet) {
     log(`Running OMPChamber (${mode}) in the foreground on ${url} (Ctrl+C to stop)...`);

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

@@ -1,6 +1,13 @@
-// `ompchamber status` — report the live instance, its health and log path.
+// `ompchamber status` — report the live instances, their health and log paths.
+//
+// Without `--port` every live instance is reported: a CLI server on one port, a
+// `bun run dev` server on another and a production server on a third are three
+// separate processes, and a status command that showed only the first would
+// hide the two you forgot about. `--port <port>` narrows the report to that
+// instance.
 
-import { findLiveInstance, waitForHealth, probeHost } from '@/cli/lib/runtime.js';
+import { findLiveInstance, listLiveInstances, waitForHealth } from '@/cli/lib/runtime.js';
+import { probeHost } from '@/server/lib/lifecycle/probe';
 import { log, ok, printJson, isJson } from '@/cli/lib/output.js';
 
 function explicitPort(options) {
@@ -30,34 +37,49 @@ function formatHealth(health) {
   return `ok (version ${version}${mock})`;
 }
 
+/** One block per instance; the field names match the single-instance output. */
+function printInstance(entry) {
+  log(`  instance: ${entry.port}`);
+  log(`  pid:      ${entry.pid}`);
+  log(`  port:     ${entry.port}`);
+  log(`  url:      ${entry.url ?? `http://${probeHost(entry.host)}:${entry.port}`}`);
+  log(`  mode:     ${entry.mode ?? 'unknown'}`);
+  log(`  launch:   ${entry.launchMode ?? 'unknown'}${entry.source ? ` (${entry.source})` : ''}`);
+  log(`  uptime:   ${formatUptime(entry.startedAt)}`);
+  log(`  health:   ${formatHealth(entry.health)}`);
+  log(`  log:      ${entry.logFile}`);
+}
+
 export async function run(options) {
   const json = isJson();
-  const live = await findLiveInstance(explicitPort(options));
+  const requested = explicitPort(options);
+
+  const instances = requested !== null
+    ? [await findLiveInstance(requested)].filter(Boolean)
+    : await listLiveInstances();
 
-  if (!live) {
+  if (instances.length === 0) {
     if (json) {
-      printJson({ running: false });
+      printJson(requested !== null ? { running: false, port: requested } : { running: false, instances: [] });
       return;
     }
-    log('OMPChamber is not running.');
+    log(requested !== null ? `No OMPChamber instance on port ${requested}.` : 'OMPChamber is not running.');
     return;
   }
 
-  const health = await waitForHealth(live.port, live.host, 4000);
-  const merged = { ...live, running: true, health };
+  const reported = [];
+  for (const entry of instances) {
+    reported.push({ ...entry, health: await waitForHealth(entry.port, entry.host, 4000) });
+  }
 
   if (json) {
-    printJson(merged);
+    printJson(requested !== null ? { ...reported[0], running: true } : { running: true, instances: reported });
     return;
   }
 
-  ok('OMPChamber is running');
-  log(`  instance: ${live.port}`);
-  log(`  pid:      ${live.pid}`);
-  log(`  port:     ${live.port}`);
-  log(`  url:      ${live.url ?? `http://${probeHost(live.host)}:${live.port}`}`);
-  log(`  mode:     ${live.mode ?? 'unknown'}`);
-  log(`  uptime:   ${formatUptime(live.startedAt)}`);
-  log(`  health:   ${formatHealth(health)}`);
-  log(`  log:      ${live.logFile}`);
+  ok(reported.length === 1 ? 'OMPChamber is running' : `OMPChamber is running — ${reported.length} instances`);
+  for (const [index, entry] of reported.entries()) {
+    if (index > 0) log('');
+    printInstance(entry);
+  }
 }

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

@@ -1,6 +1,6 @@
 // `ompchamber stop` — stop one or every live OMPChamber instance.
 
-import { listRegistries, findLiveInstance, isProcessAlive, stopInstance } from '@/cli/lib/runtime.js';
+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';
 
@@ -27,13 +27,18 @@ function explicitPort(options) {
 
 export async function run(options) {
   const json = isJson();
+  const requested = explicitPort(options);
 
+  // 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 (options?.all) {
-    targets = (await listRegistries()).filter((entry) => entry && isProcessAlive(Number(entry.pid)));
-  } else {
-    const live = await findLiveInstance(explicitPort(options));
+  if (requested !== null) {
+    const live = await findLiveInstance(requested);
     targets = live ? [live] : [];
+  } else {
+    targets = await listLiveInstances();
   }
 
   if (targets.length === 0) {
@@ -41,9 +46,9 @@ export async function run(options) {
       printJson({ stopped: [] });
       return;
     }
-    warn(options?.all
+    warn(requested === null
       ? 'No running OMPChamber instances found.'
-      : `No running OMPChamber instance on port ${explicitPort(options) ?? resolvePort(options)}.`);
+      : `No running OMPChamber instance on port ${requested}.`);
     return;
   }
 

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

@@ -2,32 +2,40 @@
 //
 // The installation mechanics live in the shared update engine so the CLI and
 // the console's "Update" button do the same thing; this command owns the
-// terminal presentation and restarts any instance still serving the previous
-// build.
+// terminal presentation and restarts the instances still serving the previous
+// build (the ones the CLI started — a server running from source is left to its
+// own launcher).
 
 import { color, configure, error, log, ok, warn, printJson, isJson, isQuiet } from '@/cli/lib/output.js';
-import { listRegistries, findLiveInstance, isProcessAlive, stopInstance } from '@/cli/lib/runtime.js';
+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 { resolveInstallContext, resolveOmpChamberVersion, updateOmpChamber } from '@/server/lib/updates/install';
 
 /**
  * Live instances to restart after an update: every one with `--all`, otherwise
  * the first. Their recorded port/host/mode is reused, so a server started on a
- * non-default port comes back on that same port.
+ * non-default port comes back on that same port. Instances started outside the
+ * CLI (`bun run dev`, `bun run start`, a supervisor) are reported and left
+ * running — their own launcher is what applies the new files.
  */
 async function liveInstances(options) {
-  if (options?.all) {
-    const entries = await listRegistries();
-    return entries.filter((entry) => entry && isProcessAlive(Number(entry.pid)));
-  }
+  if (options?.all) return await listLiveInstances();
   const live = await findLiveInstance(null);
   return live ? [live] : [];
 }
 
 async function restartInstances(options, ctx) {
   const restarted = [];
+  const skipped = [];
   for (const entry of await liveInstances(options)) {
+    if (!isAutoRestartable(entry.launchMode)) {
+      skipped.push({ port: entry.port, pid: entry.pid, launchMode: entry.launchMode });
+      log(`Skipping OMPChamber on port ${entry.port}: ${skipRestartNote(entry.launchMode)}.`);
+      continue;
+    }
+
     log(`Restarting OMPChamber on port ${entry.port} (pid ${entry.pid})...`);
     await stopInstance(entry, { timeoutMs: STOP_TIMEOUT_MS });
     await runServe(
@@ -44,7 +52,7 @@ async function restartInstances(options, ctx) {
     );
     restarted.push(entry.port);
   }
-  return restarted;
+  return { restarted, skipped };
 }
 
 async function runCheck(pkgRoot, json) {
@@ -94,8 +102,10 @@ export async function run(options, ctx) {
     // Restarting prints through the serve command; silence it so stdout stays
     // one JSON document.
     if (result.success && result.updated && shouldRestart) configure({ json: false, quiet: true });
-    const restarted = result.success && result.updated && shouldRestart ? await restartInstances(options, ctx) : [];
-    printJson({ ...result, restarted });
+    const { restarted, skipped } = result.success && result.updated && shouldRestart
+      ? await restartInstances(options, ctx)
+      : { restarted: [], skipped: [] };
+    printJson({ ...result, restarted, skipped });
     if (!result.success) process.exitCode = 1;
     return;
   }
@@ -114,7 +124,8 @@ export async function run(options, ctx) {
     return;
   }
 
-  if ((await restartInstances(options, ctx)).length === 0) {
+  const { restarted, skipped } = await restartInstances(options, ctx);
+  if (restarted.length === 0 && skipped.length === 0) {
     log('No running instance to restart.');
   }
 }

package/src/cli/lib/paths.js

@@ -1,29 +1,16 @@
 import fs from 'node:fs';
-import { joinPath, resolvePath, homeDir } from '@/cli/lib/path-utils.js';
+import { getDataDir, getRunDir } from '@/server/lib/lifecycle/paths';
+import { joinPath } from '@/cli/lib/path-utils.js';
 
 /**
- * Resolve the OMPChamber data directory.
+ * CLI-side paths.
  *
- * Matches the convention used by app/db.server.ts so the CLI and the web
- * console always agree on where state lives.
+ * The data directory and the per-port run directory are owned by
+ * `src/server/lib/lifecycle/paths` — the server writes its instance record
+ * there, and the CLI must read the same file. Only the log location is
+ * CLI-specific: the CLI redirects the daemon's stdout into it, so the server
+ * never needs to know where the logs live.
  */
-export function getDataDir() {
-  const override = Bun.env.OMPCHAMBER_DATA_DIR;
-  if (typeof override === 'string' && override.trim().length > 0) {
-    return resolvePath(override.trim());
-  }
-  return joinPath(homeDir(), '.ompchamber');
-}
-
-/**
- * Directory holding per-instance registry files (`<port>.json`).
- * Created on demand with owner-only permissions.
- */
-export function getRunDir() {
-  const dir = joinPath(getDataDir(), 'run');
-  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-  return dir;
-}
 
 /**
  * Directory holding per-instance log files.
@@ -34,13 +21,6 @@ export function getLogsDir() {
   return dir;
 }
 
-/**
- * Registry file describing the running instance bound to `port`.
- */
-export function getRegistryPath(port) {
-  return joinPath(getRunDir(), `${port}.json`);
-}
-
 /**
  * Log file for the running instance bound to `port`.
  */