ompchamber 0.6.0 → 0.7.0

package/src/server/lib/lifecycle/restart.ts

@@ -0,0 +1,111 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Replacing the instance that is serving an update request.
+ *
+ * A server cannot restart itself: the process holding the port has to exit
+ * before a replacement can bind it, and the update response has to leave first.
+ * So once the files on disk are replaced, the work goes to a detached
+ * `ompchamber restart --port <port>` — the same stop-then-serve the CLI runs
+ * after `ompchamber update`.
+ *
+ * Instances the CLI did not start are left alone. `bun run dev` and
+ * `bun run start` execute this package's source in the user's own shell, and an
+ * external supervisor (systemd, pm2, a container) owns the process it started;
+ * all of them record `direct`, and replacing any of them would break a loop
+ * OMPChamber does not own — or fight a second daemon for the port. Their own
+ * launcher is what brings the new files up.
+ */
+
+import { existsSync } from 'node:fs';
+import { join as joinPath, resolve as resolvePath } from 'node:path';
+
+import { resolveBunBin } from '@/server/lib/lifecycle/bun';
+import { listInstanceRecords } from '@/server/lib/lifecycle/instance';
+import { resolveLaunchMode } from '@/server/lib/lifecycle/launch-mode';
+
+/** Package root of the running copy: src/server/lib/lifecycle -> four levels up. */
+const PKG_ROOT = resolvePath(import.meta.dir, '..', '..', '..', '..');
+
+/**
+ * Time between answering the update request and stopping the server. The
+ * response is a small JSON body on a local listener; this is the margin that
+ * keeps the console's toast from dying with the process that sent it.
+ */
+export const RESTART_GRACE_MS = 1_200;
+
+export interface SelfRestartPlan {
+  /** A detached restart is armed; `message` says so. */
+  restarting: boolean;
+  /** What to tell the user, either way. */
+  message: string;
+}
+
+/**
+ * True when the CLI owns this instance's lifecycle and may replace it. `direct`
+ * is every server OMPChamber did not start: `bun run dev`, `bun run start`, a
+ * manual `bun src/server/index.ts`, or an external supervisor.
+ */
+export function isAutoRestartable(launchMode: string | null | undefined): boolean {
+  return launchMode === 'daemon' || launchMode === 'foreground';
+}
+
+/** One-line reason an instance is left running, shared by the CLI and console. */
+export function skipRestartNote(launchMode: string | null | undefined): string {
+  if (launchMode === 'direct') {
+    return 'this instance runs from source (`bun run dev` / `bun run start`) — start it again to apply the update';
+  }
+  return 'this instance is not managed by the ompchamber CLI — restart it yourself to apply the update';
+}
+
+/** The record this process wrote for itself; falls back to the env it was launched with. */
+function ownInstance(): { port: number; launchMode: string } | null {
+  const record = listInstanceRecords().find((entry) => entry.pid === process.pid);
+  if (record) return { port: record.port, launchMode: record.launchMode };
+
+  const port = Number(Bun.env.PORT);
+  if (!Number.isFinite(port) || port <= 0) return null;
+  return { port, launchMode: resolveLaunchMode() };
+}
+
+/** `ompchamber restart --port <port>` for the install this server runs from. */
+function restartCommand(port: number): string[] | null {
+  const cli = joinPath(PKG_ROOT, 'src', 'cli', 'ompchamber.js');
+  if (!existsSync(cli)) return null;
+  return [resolveBunBin(), cli, 'restart', '--port', String(port)];
+}
+
+/**
+ * Stop and start this port again, once the response has been delivered. The
+ * helper is detached so this process exiting does not take it down, and it
+ * removes this port's record itself (`stopInstance`) before serving.
+ */
+export function scheduleSelfRestart(): SelfRestartPlan {
+  const self = ownInstance();
+  if (!self) {
+    return { restarting: false, message: 'This instance could not be identified — restart it yourself to apply the update.' };
+  }
+
+  if (!isAutoRestartable(self.launchMode)) {
+    return { restarting: false, message: skipRestartNote(self.launchMode) };
+  }
+
+  const cmd = restartCommand(self.port);
+  if (!cmd) {
+    return { restarting: false, message: `The ompchamber CLI is missing from ${PKG_ROOT} — restart it yourself to apply the update.` };
+  }
+
+  setTimeout(() => {
+    console.log(`[ompchamber] restarting on port ${self.port}: ${cmd.join(' ')}`);
+    try {
+      Bun.spawn({ cmd, cwd: PKG_ROOT, stdin: 'ignore', stdout: 'inherit', stderr: 'inherit', detached: true }).unref();
+    } catch (err) {
+      console.error(`[ompchamber] restart helper could not be started: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }, RESTART_GRACE_MS);
+
+  return { restarting: true, message: `Restarting OMPChamber on port ${self.port} to apply it — the console reconnects on its own.` };
+}

package/src/server/lib/omp/rpc/session-commands.ts

@@ -13,7 +13,7 @@ import { RpcCommandTimeoutError, type RpcProcess } from '@/server/lib/omp/rpc/pr
 import { AWAITING_AGENT_START_TIMEOUT_MS, GET_STATE_TIMEOUT_MS, IMAGE_BEARING_COMMANDS, PASSTHROUGH_COMMANDS, PROMPT_ACK_TIMEOUT_MS, RESTARTING_MESSAGE, SESSION_BUSY_MESSAGE, WebRpcError, toImageContents, type AgentEvent, type RpcSessionState, validateAgentImages } from '@/server/lib/omp/rpc/constants';
 import { clearSessionFileCaches } from '@/server/lib/omp/session/files';
 import { notifyRunningChange } from '@/server/lib/omp/rpc/session-registry';
-import { markStreamStatus } from '@/shared/lib/omp/session/stream-state.server';
+import { clearStreamStatus, markStreamStatus } from '@/shared/lib/omp/session/stream-state.server';
 import { buildWebState, type WebStateHost } from '@/server/lib/omp/rpc/web-state';
 
 /** Runtime surface AgentSessionWrapper exposes to the command dispatcher. */
@@ -66,12 +66,24 @@ export async function dispatchSessionCommand(host: SessionCommandHost, command:
         throw new Error('Cannot send a prompt while a shell command is running');
       }
       const streamingBehavior = command.streamingBehavior as 'steer' | 'followUp' | undefined;
+      // The live `stream` row starts with the DISPATCH, not with agent_start:
+      // the spawn/ack round trip that precedes agent_start must not read as
+      // "nothing happened" in the sidebar after the user hit send. Skipped
+      // while a turn already streams — that row belongs to the running turn,
+      // and this dispatch's failure must never roll it back.
+      const ownsStreamRow = !streamingBehavior && !host.streaming && Boolean(host.sessionId);
+      // A prompt that never started a turn leaves no run behind, so the row we
+      // wrote must go — unless a turn began meanwhile, which owns it now.
+      const releaseStreamRow = (): void => {
+        if (ownsStreamRow && !host.streaming) void clearStreamStatus(host.sessionId);
+      };
       if (!streamingBehavior) {
         host.promptRunning = true;
         host.promptDispatchPendingCount += 1;
         host.awaitingAgentStart = false;
         host.awaitingAgentStartDeadline = 0;
         host.continuationGraceUntil = 0;
+        if (ownsStreamRow) void markStreamStatus(host.sessionId, 'stream');
         notifyRunningChange();
       }
       try {
@@ -85,6 +97,7 @@ export async function dispatchSessionCommand(host: SessionCommandHost, command:
           host.promptRunning = false;
           host.awaitingAgentStart = false;
           host.awaitingAgentStartDeadline = 0;
+          releaseStreamRow();
           host.emit({ type: 'prompt_result', agentInvoked: false });
           notifyRunningChange();
         } else if (!streamingBehavior && ack?.agentInvoked !== false) {
@@ -95,6 +108,7 @@ export async function dispatchSessionCommand(host: SessionCommandHost, command:
         host.promptRunning = false;
         host.awaitingAgentStart = false;
         host.awaitingAgentStartDeadline = 0;
+        releaseStreamRow();
         notifyRunningChange();
         // The ack may simply be queued behind a running turn: omp accepts the
         // prompt before the turn it starts. No reset, and the client must not

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

@@ -1,16 +1,16 @@
 /**
  * Applies a requested update. oh-my-pi is updated through the omp binary;
  * OMPChamber through the shared self-update engine, which replaces the running
- * install in place (bun global install, or git fast-forward + rebuild).
+ * install in place (bun global install, or git fast-forward + rebuild) and then
+ * restarts this instance through a detached `ompchamber restart` — unless the
+ * instance was started from source, which its own launcher has to restart.
  */
 
+import { scheduleSelfRestart } from '@/server/lib/lifecycle/restart';
 import { updateOmpChamber } from '@/server/lib/updates/install';
 import { applyOmpUpdate } from '@/server/lib/updates/omp';
 import type { UpdateApplyResult, UpdateTarget } from '@/shared/types/updates';
 
-/** A server cannot replace its own process, so the user restarts it. */
-const RESTART_NOTE = ' Restart the server (`ompchamber restart`) to apply it.';
-
 export async function applyUpdate(target: UpdateTarget): Promise<UpdateApplyResult> {
   if (target === 'omp') {
     try {
@@ -28,11 +28,14 @@ export async function applyUpdate(target: UpdateTarget): Promise<UpdateApplyResu
 
   if (target === 'ompchamber') {
     const result = await updateOmpChamber();
+    // Only a call that actually replaced files has something to restart for:
+    // an "already up to date" answer must not bounce a healthy server.
+    const restart = result.success && result.updated ? scheduleSelfRestart() : null;
     return {
       success: result.success,
       target: 'ompchamber',
       manual: result.manual,
-      message: `${result.message}${result.updated ? RESTART_NOTE : ''}`,
+      message: restart ? `${result.message} ${restart.message}` : result.message,
       output: result.output || undefined,
     };
   }

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

@@ -14,6 +14,7 @@
 
 import { join as joinPath, resolve as resolvePath } from 'node:path';
 
+import { resolveBunBin } from '@/server/lib/lifecycle/bun';
 import { fetchLatestRelease, type GitHubRelease } from '@/server/lib/updates/github';
 import {
   detectInstallMethod,
@@ -137,10 +138,12 @@ export function resolveInstallContext(pkgRoot = DEFAULT_PKG_ROOT): InstallContex
   const remote = gitWorkTree ? runSync(['git', '-C', root, 'remote', 'get-url', 'origin']) : null;
   const gitRemote = remote?.ok && remote.out.length > 0 ? remote.out : null;
 
-  const execPath = process.execPath;
-  const bunBin = /(^|[\\/])bun$/.test(execPath) ? execPath : (Bun.which('bun') ?? 'bun');
-
-  return { ...detectInstallMethod({ pkgRoot: root, gitWorkTree, gitRemote }), pkgRoot: root, gitRemote, bunBin };
+  return {
+    ...detectInstallMethod({ pkgRoot: root, gitWorkTree, gitRemote }),
+    pkgRoot: root,
+    gitRemote,
+    bunBin: resolveBunBin(),
+  };
 }
 
 /** The commands that install `version` for a given install method. */

package/src/server/routes/health/probe.ts

@@ -1,5 +1,6 @@
 import { json, NO_STORE_HEADERS } from '@/server/lib/remix-compat';
 import pkg from '@/../package.json';
+import { resolveLaunchMode } from '@/server/lib/lifecycle/launch-mode';
 import { isMockMode } from '@/server/mock.server';
 
 const STARTED_AT = Date.now();
@@ -26,7 +27,7 @@ export async function loader() {
       // `launchMode` are what `status` prints, and the pair with `pid` is what
       // separates a dev server from a stale published build.
       mode: Bun.env.NODE_ENV === 'production' ? 'prod' : 'dev',
-      launchMode: Bun.env.OMPCHAMBER_LAUNCH_MODE ?? 'direct',
+      launchMode: resolveLaunchMode(),
       port: Number(Bun.env.PORT) || 3000,
       host: Bun.env.HOST || 'localhost',
     },

package/src/shared/lib/omp/session/stream-state.server.ts

@@ -8,7 +8,7 @@
  * sidebar can render spinner/check from the SAME loader that already refresh
  * on stream events (`omp:session-updated` → revalidator). Statuses:
  *
- *   stream  — a run is in flight (agent_start)
+ *   stream  — a run is in flight (prompt dispatch → agent_start)
  *   finish  — the run ended normally (agent_end), not yet seen
  *   abort   — the user stopped it, not yet seen
  *   error   — the run failed (prompt_error / process exit), not yet seen
@@ -41,6 +41,21 @@ export async function markStreamStatus(sessionId: string, status: SessionStreamS
   }
 }
 
+/**
+ * Drop an optimistic `stream` row whose prompt never started a turn: the ack
+ * reported `agentInvoked: false`, or the dispatch failed before omp accepted
+ * it. Live-only — a `stream` row a concurrent `agent_start` wrote is still the
+ * truth, and terminal badges are cleared by `markStreamSeen`.
+ */
+export async function clearStreamStatus(sessionId: string): Promise<void> {
+  try {
+    const db = await getDb();
+    await db.run("DELETE FROM session_stream_state WHERE session_id = ? AND status = 'stream'", [sessionId]);
+  } catch {
+    // Best-effort.
+  }
+}
+
 /**
  * Opening the session clears its terminal badge (one-shot contract).
  *