ompchamber 0.3.0

package/src/server/lib/omp/core/worktree.ts

@@ -0,0 +1,106 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Read-only port of omp-web/lib/worktree.ts — resolves a session's cwd to the
+ * main repository root so sessions from git worktrees group under one project.
+ *
+ * A linked worktree's `git rev-parse --git-common-dir` points at the *main*
+ * repo's .git directory, so its parent is the project root shared by all
+ * worktrees. Non-git directories resolve to themselves. Results are cached on
+ * globalThis with a short TTL (this layer never mutates repos, so no eager
+ * invalidation is needed).
+ */
+
+import { promises as fsp } from 'fs';
+import { dirname, join } from 'path';
+import { pathExists } from '@/server/lib/omp/core/paths';
+
+declare global {
+  var __ompChamberProjectCache: Map<string, { root: string; expiresAt: number }> | undefined;
+}
+
+const PROJECT_CACHE_TTL_MS = 60_000;
+
+async function realPathOrSelf(filePath: string): Promise<string> {
+  try {
+    return await fsp.realpath(filePath);
+  } catch {
+    return filePath;
+  }
+}
+
+function getProjectCache(): Map<string, { root: string; expiresAt: number }> {
+  if (!globalThis.__ompChamberProjectCache) globalThis.__ompChamberProjectCache = new Map();
+  return globalThis.__ompChamberProjectCache;
+}
+
+async function git(cwd: string, args: string[]): Promise<string> {
+  const proc = Bun.spawn({
+    cmd: ['git', '-C', cwd, ...args],
+    stdout: 'pipe',
+    stderr: 'pipe',
+    timeout: 10_000,
+    maxBuffer: 1024 * 1024,
+    env: { ...Bun.env, LC_ALL: 'C' },
+  });
+  const stdout = await new Response(proc.stdout).text();
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) throw new Error(`git ${args[0]} failed with exit code ${exitCode}`);
+  return stdout.trim();
+}
+
+function samePath(a: string, b: string): boolean {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  return normalizeForComparison(a) === normalizeForComparison(b);
+}
+
+/** Case-insensitive comparison on win32, case-sensitive elsewhere. */
+function normalizeForComparison(value: string): string {
+  if (!value) return value;
+  const normalized = value.replace(/\\/g, '/').replace(/\/{2,}/g, '/').replace(/\/+$/, '');
+  return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+
+/**
+ * Resolve a cwd to its repository root. Returns the cwd itself when it is not
+ * inside a git repository (or the directory does not exist). Cached per-cwd
+ * with a short TTL.
+ */
+export async function resolveProjectRoot(cwd: string): Promise<string> {
+  const cache = getProjectCache();
+  const cached = cache.get(cwd);
+  if (cached && cached.expiresAt > Date.now()) return cached.root;
+
+  let root: string;
+  try {
+    const dotGit = join(cwd, '.git');
+    if (!(await pathExists(cwd)) || !(await pathExists(dotGit))) {
+      root = await realPathOrSelf(cwd);
+    } else {
+      const out = await git(cwd, [
+        'rev-parse',
+        '--path-format=absolute',
+        '--git-common-dir',
+        '--show-toplevel',
+      ]);
+      const [commonDirRaw, toplevelRaw] = out.split('\n').map((l) => l.trim());
+      const commonDir = await realPathOrSelf(commonDirRaw || '');
+      const toplevel = await realPathOrSelf(toplevelRaw || '');
+      const realCwd = await realPathOrSelf(cwd);
+      const isTopLevel = samePath(toplevel, realCwd);
+      // For a linked worktree, --git-common-dir differs from the toplevel's
+      // .git: its parent is the MAIN repo root shared by all worktrees.
+      const isWorktreeTopLevel = isTopLevel && !samePath(dirname(commonDir), dirname(toplevel));
+      root = isWorktreeTopLevel ? await realPathOrSelf(dirname(commonDir)) : toplevel || realCwd;
+    }
+  } catch {
+    root = await realPathOrSelf(cwd);
+  }
+
+  cache.set(cwd, { root, expiresAt: Date.now() + PROJECT_CACHE_TTL_MS });
+  return root;
+}

package/src/server/lib/omp/rpc/constants.ts

@@ -0,0 +1,185 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Shared types, constants and pure helpers for the omp session RPC manager.
+ * Kept separate from the session wrapper/registry so each file stays under the
+ * repo's per-file size ceiling.
+ */
+
+import { homedir } from 'os';
+import { pathExists } from '@/server/lib/omp/core/paths';
+import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
+
+export interface AgentEvent {
+  type: string;
+  [key: string]: unknown;
+}
+
+export type EventListener = (event: AgentEvent) => void;
+
+export interface RpcSessionState {
+  sessionId: string;
+  sessionFile?: string;
+  sessionName?: string;
+  isStreaming: boolean;
+  isCompacting: boolean;
+  autoCompactionEnabled: boolean;
+  autoRetryEnabled?: boolean;
+  interruptMode: 'immediate' | 'wait';
+  steeringMode: 'all' | 'one-at-a-time';
+  followUpMode: 'all' | 'one-at-a-time';
+  model?: { id: string; provider: string; name?: string; reasoning?: boolean; thinking?: { efforts?: string[] } };
+  messageCount: number;
+  queuedMessageCount: number;
+  contextUsage?: { tokens: number; contextWindow: number; percent: number } | null;
+  systemPrompt?: string[];
+  thinkingLevel?: string;
+  fastMode?: boolean;
+  fastModeEnabled?: boolean;
+  fastModeActive?: boolean;
+  tokensPerSecond?: number | null;
+  todoPhases?: unknown[];
+}
+
+export interface WebSessionState {
+  sessionId: string;
+  sessionFile: string;
+  sessionName?: string;
+  isStreaming: boolean;
+  isPromptRunning: boolean;
+  isBashRunning: boolean;
+  isCompacting: boolean;
+  autoCompactionEnabled: boolean;
+  autoRetryEnabled?: boolean;
+  interruptMode: 'immediate' | 'wait';
+  steeringMode: 'all' | 'one-at-a-time';
+  followUpMode: 'all' | 'one-at-a-time';
+  model?: { id: string; provider: string; name?: string; reasoning?: boolean; thinking?: { efforts?: string[] } };
+  messageCount: number;
+  queuedMessageCount: number;
+  contextUsage: { tokens: number; contextWindow: number; percent: number } | null;
+  systemPrompt: string;
+  thinkingLevel: string;
+  fastModeEnabled: boolean;
+  fastModeActive?: boolean;
+  tokensPerSecond: number | null;
+  todoPhases: unknown[];
+}
+
+export const IDLE_DESTROY_MS = 10 * 60 * 1000;
+export const READY_TIMEOUT_MS = 120_000;
+export const GET_STATE_TIMEOUT_MS = 5_000;
+export const PROMPT_ACK_TIMEOUT_MS = 30_000;
+export const NON_TERMINAL_CONTINUATION_GRACE_MS = 2_000;
+export const AWAITING_AGENT_START_TIMEOUT_MS = 10_000;
+export const RESTARTING_MESSAGE = 'This session is restarting — retry in a moment.';
+
+export class WebRpcError extends Error {
+  readonly code: string;
+
+  constructor(message: string, code: string) {
+    super(message);
+    this.name = 'WebRpcError';
+    this.code = code;
+  }
+}
+
+// Commands forwarded to omp verbatim (request shape already matches rpc-types).
+export const PASSTHROUGH_COMMANDS = new Set([
+  'abort',
+  'abort_and_prompt',
+  // steer: interrupt/redirect the running agent; follow_up: enqueue a message the agent handles after the current turn.
+  'steer',
+  'follow_up',
+  'set_thinking_level',
+  'cycle_thinking_level',
+  'cycle_model',
+  'get_available_models',
+  'set_auto_compaction',
+  'set_auto_retry',
+  'abort_retry',
+  'abort_bash',
+  'set_todos',
+  'set_steering_mode',
+  'set_follow_up_mode',
+  'set_interrupt_mode',
+  'get_messages',
+  'get_messages_page',
+  'get_subagents',
+  'get_subagent_messages',
+  'set_subagent_subscription',
+  'get_login_providers',
+  'login',
+]);
+
+// Commands that can carry user-attached images to the model. All of them must
+// pass the same server-side per-image/count/aggregate validation before the
+// payload reaches omp — a client is free to POST any of them directly.
+export const IMAGE_BEARING_COMMANDS = new Set(['prompt', 'steer', 'follow_up', 'abort_and_prompt']);
+
+// `extension_ui_request` methods that BLOCK the agent until the matching
+// `extension_ui_response` arrives. omp emits no re-delivery, so the server is
+// the only place a still-pending request can be remembered across a client
+// reload. `cancel`, `notify`, `open_url`, `setWidget`, ... are fire-and-forget.
+export const ANSWERABLE_UI_METHODS = new Set(['select', 'confirm', 'input', 'editor']);
+
+export const MAX_ATTACHED_IMAGES = 20;
+export const MAX_ATTACHED_IMAGE_BYTES = 20 * 1024 * 1024;
+export const MAX_AGGREGATE_IMAGE_BYTES = 40 * 1024 * 1024;
+
+export function validateAgentImages(images: unknown): string | null {
+  if (images === undefined) return null;
+  if (!Array.isArray(images)) return 'images must be an array';
+  if (images.length > MAX_ATTACHED_IMAGES) return `Maximum of ${MAX_ATTACHED_IMAGES} attached images reached.`;
+  let aggregate = 0;
+  for (const image of images) {
+    if (!image || typeof image !== 'object') return 'invalid image entry';
+    const data = (image as { data?: unknown }).data;
+    const mimeType = (image as { mimeType?: unknown }).mimeType;
+    if (typeof data !== 'string' || typeof mimeType !== 'string') return 'invalid image entry';
+    const bytes = Buffer.byteLength(data, 'base64');
+    if (bytes > MAX_ATTACHED_IMAGE_BYTES) return `Images up to ${Math.round(MAX_ATTACHED_IMAGE_BYTES / 1024 / 1024)} MB are supported.`;
+    aggregate += bytes;
+  }
+  if (aggregate > MAX_AGGREGATE_IMAGE_BYTES) return 'Total image size exceeds the supported limit.';
+  return null;
+}
+
+export function toImageContents(value: unknown): Array<{ type: 'image'; data: string; mimeType: string }> | undefined {
+  const images = value as Array<{ type: 'image'; data: string; mimeType: string }> | undefined;
+  return images?.length ? images : undefined;
+}
+
+/** Pick a spawn cwd that actually exists. A session records the directory it
+ * was created in, but that directory may have been deleted since: spawn()
+ * would fail with ENOENT and `omp --cwd <missing>` throws in setProjectDir. */
+export async function resolveSpawnCwd(recordedCwd?: string | null): Promise<string> {
+  if (recordedCwd && (await pathExists(recordedCwd))) return recordedCwd;
+  try {
+    const serverCwd = process.cwd();
+    if (serverCwd && (await pathExists(serverCwd))) return serverCwd;
+  } catch {
+    // process.cwd() itself throws when the server's own cwd was removed.
+  }
+  return homedir();
+}
+
+/** Extra CLI args for spawning `omp --mode rpc-ui` for a session. */
+export function buildSessionSpawnArgs(sessionFile: string, approvalMode?: ApprovalMode): string[] {
+  const args: string[] = [];
+  if (sessionFile) {
+    // An absolute path resolves deterministically: omp's createSessionManager
+    // opens it directly via SessionManager.open without any interactive
+    // resume/fork prompts.
+    args.push('--resume', sessionFile);
+  }
+  if (approvalMode) {
+    // Spawn-time only: omp exposes no RPC command to change the tool-approval
+    // mode, so the flag is the sole lever. It works with or without --resume.
+    args.push('--approval-mode', approvalMode);
+  }
+  return args;
+}

package/src/server/lib/omp/rpc/errors.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Shared HTTP mapping for errors thrown by the omp RPC layer. Every agent
+ * route that awaits an RPC command answers the same way: a 400 carrying a
+ * `{ error, code }` envelope, with the code falling back per error class.
+ */
+
+import { json } from '@/server/lib/remix-compat';
+import { WebRpcError } from '@/server/lib/omp/rpc/constants';
+import { RpcCommandError, RpcCommandTimeoutError } from '@/server/lib/omp/rpc/process';
+
+export function rpcErrorResponse(error: unknown): Response {
+  if (error instanceof WebRpcError) {
+    return json({ error: error.message, code: error.code }, { status: 400 });
+  }
+  if (error instanceof RpcCommandTimeoutError) {
+    return json({ error: error.message, code: 'rpc_command_timeout' }, { status: 400 });
+  }
+  if (error instanceof RpcCommandError) {
+    return json({ error: error.message, code: error.code ?? 'rpc_command_failed' }, { status: 400 });
+  }
+  return json({ error: error instanceof Error ? error.message : String(error) }, { status: 400 });
+}

package/src/server/lib/omp/rpc/kill-tree.ts

@@ -0,0 +1,49 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Process-tree termination for a spawned `omp` child.
+ *
+ * POSIX: the child runs detached in its own process group, so signaling the
+ * negative pid reaches its LSP servers and extension subprocesses too.
+ * Windows: no portable negative-pid equivalent, so use taskkill's tree
+ * operation instead. Both paths fall back to signaling the direct child when
+ * the group/tree kill is unavailable.
+ */
+
+export function killProcessTree(pid: number | undefined, force: boolean, signal: NodeJS.Signals): void {
+  if (!pid) return;
+  if (process.platform === 'win32') {
+    const args = ['/pid', String(pid), '/t', ...(force ? ['/f'] : [])];
+    try {
+      const reaper = Bun.spawn({
+        cmd: ['taskkill', ...args],
+        stdout: 'ignore',
+        stderr: 'ignore',
+        windowsHide: true,
+      });
+      void reaper.exited.then(() => undefined, () => undefined);
+      reaper.exited.then(() => {
+        // taskkill missing from PATH: fall back to the direct child.
+        if (!reaper.exitCode) return;
+        try {
+          process.kill(pid, signal);
+        } catch {}
+      });
+    } catch {
+      try {
+        process.kill(pid, signal);
+      } catch {}
+    }
+    return;
+  }
+  try {
+    process.kill(-pid, signal);
+  } catch {
+    try {
+      process.kill(pid, signal);
+    } catch {}
+  }
+}

package/src/server/lib/omp/rpc/lines.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * NDJSON line reader over a Web `ReadableStream` — Bun-native replacement for
+ * `readline.createInterface({ input })` when consuming `Bun.spawn` stdout.
+ * Incomplete trailing data stays buffered until the next chunk or stream end,
+ * matching readline's line semantics. Per-line errors never surface: the
+ * callback receiving them is the caller's boundary.
+ */
+
+export function readLines(stream: ReadableStream<Uint8Array>, onLine: (line: string) => void): Promise<void> {
+  const decoder = new TextDecoder();
+  let buffer = '';
+  return stream.pipeTo(
+    new WritableStream({
+      write(chunk) {
+        buffer += decoder.decode(chunk, { stream: true });
+        let newlineIndex = buffer.indexOf('\n');
+        while (newlineIndex !== -1) {
+          const line = buffer.slice(0, newlineIndex);
+          buffer = buffer.slice(newlineIndex + 1);
+          onLine(line);
+          newlineIndex = buffer.indexOf('\n');
+        }
+      },
+      close() {
+        const rest = buffer + decoder.decode();
+        if (rest) onLine(rest);
+      },
+    }),
+  ).then(
+    () => undefined,
+    () => undefined,
+  );
+}