ompchamber 3.0.0 → 3.1.0

package/src/client/hooks/workspace/file-tree-actions.ts

@@ -0,0 +1,250 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Everything a file-tree row does that is not rendering: the context menu's
+ * action dispatch, the create/rename/delete dialogs and their server calls.
+ *
+ * Extracted from the row component because it is a stateful cluster with one
+ * shared dependency (`/api/fs/action` and the fetcher that submits to it), and
+ * because the row is at the repository's line ceiling. The component keeps the
+ * markup and the handlers that need its own DOM node; this keeps the behavior.
+ */
+
+import { useEffect, useRef, useState } from 'preact/hooks';
+import type { FormEvent, RefObject } from 'preact/compat';
+import { useFetcher } from '@/client/lib/router/fetcher';
+import { toAbsolutePath } from '@/shared/lib/fs/paths';
+import { copyToClipboard } from '@/client/hooks/ui/clipboard';
+
+/** The shape `/api/fs/action` answers with, as far as a row reads it. */
+interface FsActionResponse {
+  success?: boolean;
+  /** Present on the git-history payload, which the history modal reads. */
+  type?: string;
+  /** Relative path of a freshly created file. */
+  path?: string;
+  error?: string;
+}
+
+export interface FileActionTarget {
+  path: string;
+  name: string;
+  /** Absolute base dir of the listing, anchoring Copy Path. */
+  basePath?: string;
+  rootPath?: string;
+  repo?: string;
+}
+
+export interface FileActionDeps {
+  file: FileActionTarget;
+  /** Which diff to open, when the row is a changed file. */
+  diff?: { staged?: boolean; status?: string };
+  onOpenFile?: (file: { path: string; name: string; root?: string; repo?: string }) => void;
+  onActionComplete: () => void;
+}
+
+export interface FileActions {
+  contextMenu: { x: number; y: number } | null;
+  contextMenuRef: RefObject<HTMLDivElement>;
+  openContextMenu: (x: number, y: number) => void;
+  closeContextMenu: () => void;
+  showRenameModal: boolean;
+  showDeleteModal: boolean;
+  showHistoryModal: boolean;
+  showCreateModal: boolean;
+  /** The server's refusal for the create request, rendered inside its dialog. */
+  createError: string | null;
+  createName: string;
+  setCreateName: (value: string) => void;
+  renameValue: string;
+  setRenameValue: (value: string) => void;
+  /** True while a request is in flight; every dialog's buttons read it. */
+  busy: boolean;
+  /** The fetcher's own state/data, for the history modal. */
+  fetcherState: string;
+  fetcherData: FsActionResponse | undefined;
+  handleAction: (actionType: string) => void;
+  submitCreate: (e: FormEvent) => void;
+  submitRename: (e: FormEvent) => void;
+  submitDelete: () => void;
+  closeCreate: () => void;
+  closeDelete: () => void;
+  closeRename: () => void;
+  closeHistory: () => void;
+}
+
+export function useFileActions({ file, diff, onOpenFile, onActionComplete }: FileActionDeps): FileActions {
+  const actionFetcher = useFetcher<FsActionResponse>();
+  const [contextMenu, setContextMenu] = useState<{ x: number; y: number } | null>(null);
+  const contextMenuRef = useRef<HTMLDivElement>(null);
+  const [showRenameModal, setShowRenameModal] = useState(false);
+  const [showDeleteModal, setShowDeleteModal] = useState(false);
+  const [showHistoryModal, setShowHistoryModal] = useState(false);
+  const [showCreateModal, setShowCreateModal] = useState(false);
+  const [createName, setCreateName] = useState('');
+  const [createError, setCreateError] = useState<string | null>(null);
+  const [renameValue, setRenameValue] = useState(file.path);
+  /** Which dialog the in-flight request belongs to, so its result is routed. */
+  const pendingActionRef = useRef<'create' | null>(null);
+
+  const repo = file.repo;
+  const rootPath = file.rootPath;
+
+  /**
+   * The payload already acted on.
+   *
+   * The fetcher keeps `data` until the next request, and the callbacks below
+   * (`onActionComplete` → the panel's refresh → a re-render with a fresh
+   * callback identity) would otherwise re-run this effect for the SAME
+   * response forever: an unguarded effect here is an infinite refresh loop that
+   * pins the tab the moment a file is created.
+   */
+  const handledRef = useRef<FsActionResponse | null>(null);
+
+  useEffect(() => {
+    if (actionFetcher.state !== 'idle' || !actionFetcher.data) return;
+    const data = actionFetcher.data;
+    if (handledRef.current === data) return;
+    handledRef.current = data;
+    // The fetcher parses the body whatever the status, so a refusal arrives as
+    // `data.error` rather than as a throw — which is what lets the create
+    // dialog stay open and put the reason beside the field.
+    if (pendingActionRef.current === 'create') {
+      pendingActionRef.current = null;
+      if (data.success && data.path) {
+        // The user asked for a file to work on, so it opens: closing the dialog
+        // and refreshing the tree alone would leave them hunting for the empty
+        // row they just created.
+        setShowCreateModal(false);
+        setCreateName('');
+        setCreateError(null);
+        onActionComplete();
+        onOpenFile?.({
+          path: data.path,
+          name: data.path.split('/').pop() || data.path,
+          root: rootPath,
+          repo: repo || '.',
+        });
+      } else {
+        setCreateError(data.error || 'Could not create the file');
+      }
+      return;
+    }
+    if (data.success && !data.type) {
+      setShowRenameModal(false);
+      setShowDeleteModal(false);
+      onActionComplete();
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [actionFetcher.state, actionFetcher.data]);
+
+  const submitAction = (formData: FormData) => {
+    if (repo && repo !== '.') formData.append('repo', repo);
+    if (rootPath) formData.append('root', rootPath);
+    void actionFetcher.submit(formData, { method: 'post', action: '/api/fs/action' });
+  };
+
+  const openFile = () => {
+    onOpenFile?.({ path: file.path, name: file.name, root: rootPath, repo: repo || '.' });
+  };
+
+  const handleAction = (actionType: string) => {
+    setContextMenu(null);
+    if (actionType === 'view') {
+      openFile();
+    } else if (actionType === 'diff') {
+      window.dispatchEvent(new CustomEvent('omp:open-diff', {
+        detail: {
+          file: file.path,
+          staged: diff?.staged,
+          status: diff?.status || 'M',
+          repo: repo || '.',
+          root: rootPath,
+        },
+      }));
+    } else if (actionType === 'explorer') {
+      const fd = new FormData();
+      fd.append('actionType', 'open_explorer');
+      fd.append('path', file.path);
+      submitAction(fd);
+    } else if (actionType === 'copy_path') {
+      void copyToClipboard(toAbsolutePath(file.basePath, file.path));
+    } else if (actionType === 'copy_relative') {
+      void copyToClipboard(file.path);
+    } else if (actionType === 'history') {
+      setShowHistoryModal(true);
+      const fd = new FormData();
+      fd.append('actionType', 'git_history');
+      fd.append('path', file.path);
+      submitAction(fd);
+    } else if (actionType === 'rename') {
+      setRenameValue(file.path);
+      setShowRenameModal(true);
+    } else if (actionType === 'new_file') {
+      setCreateName('');
+      setCreateError(null);
+      setShowCreateModal(true);
+    } else if (actionType === 'delete') {
+      setShowDeleteModal(true);
+    }
+  };
+
+  const submitCreate = (e: FormEvent) => {
+    e.preventDefault();
+    const name = createName.trim();
+    if (!name) return;
+    setCreateError(null);
+    pendingActionRef.current = 'create';
+    const fd = new FormData();
+    fd.append('actionType', 'create');
+    fd.append('path', file.path);
+    fd.append('name', name);
+    submitAction(fd);
+  };
+
+  const submitRename = (e: FormEvent) => {
+    e.preventDefault();
+    const fd = new FormData();
+    fd.append('actionType', 'rename');
+    fd.append('path', file.path);
+    fd.append('newPath', renameValue);
+    submitAction(fd);
+  };
+
+  const submitDelete = () => {
+    const fd = new FormData();
+    fd.append('actionType', 'delete');
+    fd.append('path', file.path);
+    submitAction(fd);
+  };
+
+  return {
+    contextMenu,
+    contextMenuRef,
+    openContextMenu: (x, y) => setContextMenu({ x, y }),
+    closeContextMenu: () => setContextMenu(null),
+    showRenameModal,
+    showDeleteModal,
+    showHistoryModal,
+    showCreateModal,
+    createError,
+    createName,
+    setCreateName,
+    renameValue,
+    setRenameValue,
+    busy: actionFetcher.state !== 'idle',
+    fetcherState: actionFetcher.state,
+    fetcherData: actionFetcher.data,
+    handleAction,
+    submitCreate,
+    submitRename,
+    submitDelete,
+    closeCreate: () => setShowCreateModal(false),
+    closeDelete: () => setShowDeleteModal(false),
+    closeRename: () => setShowRenameModal(false),
+    closeHistory: () => setShowHistoryModal(false),
+  };
+}

package/src/client/hooks/workspace/session-todos.ts

@@ -0,0 +1,102 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Reads a session's live todo list for the right-panel view.
+ *
+ * The list belongs to omp and its only durable home is the session transcript,
+ * so this hook is a reader: it fetches `GET /api/omp/session-todos` and re-reads
+ * on two triggers —
+ *
+ *   - a poll (`usePanelRefresh`, paused while hidden), which covers a list the
+ *     agent changed while this client was not the one driving it;
+ *   - `omp:session-updated`, which the chat dispatches at every turn boundary
+ *     and therefore right after each `todo` tool call, so the panel follows a
+ *     running agent without waiting out the poll.
+ *
+ * The event path is throttled: one run emits the signal several times around a
+ * single tool call, and the read is a disk parse. A read already in flight is
+ * not cancelled by a newer trigger — the server answers an unchanged session
+ * from a stat, so the extra request is cheap, and dropping the newer one would
+ * leave the panel showing the list from before the call that just finished.
+ */
+
+import { useCallback, useEffect, useRef, useState } from 'preact/hooks';
+import { useChamberEvent } from '@/client/hooks/ui/window-event';
+import { usePanelRefresh } from '@/client/hooks/workspace/panel-refresh';
+import { TODO_REFRESH_EVENT_THROTTLE_MS } from '@/shared/lib/workspace/refresh-cadence';
+import type { SessionTodosPayload } from '@/shared/types/todo';
+
+export interface SessionTodosState {
+  data: SessionTodosPayload | null;
+  isLoading: boolean;
+  /** Set when the last read failed; the previous payload is kept meanwhile. */
+  error: string | null;
+  reload: () => void;
+}
+
+export function useSessionTodos(sessionId: string | null, enabled: boolean): SessionTodosState {
+  const [data, setData] = useState<SessionTodosPayload | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  // Latest session id for the fetcher, so switching sessions does not have to
+  // rebuild the callback (and with it the poll interval) on every render.
+  const sessionIdRef = useRef(sessionId);
+  sessionIdRef.current = sessionId;
+  // Guards against a response for a session the user has already left being
+  // written into the panel that now shows a different one.
+  const requestRef = useRef(0);
+
+  const load = useCallback(() => {
+    const id = sessionIdRef.current;
+    if (!id) {
+      setData(null);
+      return;
+    }
+    const request = ++requestRef.current;
+    setIsLoading(true);
+    fetch(`/api/omp/session-todos?sessionId=${encodeURIComponent(id)}`)
+      .then((response) => {
+        if (!response.ok) throw new Error(`Todo request failed (${response.status})`);
+        return response.json() as Promise<SessionTodosPayload>;
+      })
+      .then((payload) => {
+        if (requestRef.current !== request) return;
+        setData(payload);
+        setError(null);
+      })
+      .catch((err: unknown) => {
+        if (requestRef.current !== request) return;
+        setError(err instanceof Error ? err.message : 'Failed to load todos');
+      })
+      .finally(() => {
+        if (requestRef.current === request) setIsLoading(false);
+      });
+  }, []);
+
+  // A session switch must not render the previous session's list under the new
+  // title: drop the payload and re-read immediately.
+  useEffect(() => {
+    setData(null);
+    setError(null);
+    if (sessionId) load();
+  }, [sessionId, load]);
+
+  usePanelRefresh(load, enabled);
+
+  const throttleRef = useRef<ReturnType<typeof setTimeout> | undefined>(undefined);
+  useChamberEvent('omp:session-updated', () => {
+    if (!enabled || throttleRef.current !== undefined) return;
+    throttleRef.current = setTimeout(() => {
+      throttleRef.current = undefined;
+      load();
+    }, TODO_REFRESH_EVENT_THROTTLE_MS);
+  });
+
+  useEffect(() => () => clearTimeout(throttleRef.current), []);
+
+  return { data, isLoading, error, reload: load };
+}

package/src/client/tailwind.css

@@ -246,6 +246,36 @@
  * The selector keys off the variant attribute, not a list of theme ids. */
 .shiki span { color: var(--shiki-light); }
 html[data-theme-variant="dark"] .shiki span { color: var(--shiki-dark); }
+
+/* Find matches, painted inside the token spans the highlighter emits. An
+ * inline <mark> colours a background without moving a glyph, which is what
+ * keeps the transparent <textarea> above aligned with this layer — a block or
+ * a padding would shift the text under the caret. `color: inherit` is required:
+ * a <mark> would otherwise take the UA's own black-on-yellow, ignoring the
+ * dual-theme token colour it sits inside.
+ *
+ * No `border-radius`, and the current match is marked with TOP/BOTTOM borders
+ * rather than an outline: a match spanning several tokens (`const alpha` is
+ * three) is emitted as one <mark> per token, so any per-fragment decoration
+ * that draws vertical edges — radius, outline, left/right border — paints a
+ * seam in the middle of the match. Horizontal edges join seamlessly. */
+.shiki .find-match {
+  color: inherit;
+  background: color-mix(in srgb, var(--theme-warning) 32%, transparent);
+}
+/* An extra ⌘D selection: same geometry as a find match, different ink. The
+ * caret can only live in the primary range, so the two must not look alike —
+ * the user has to see where their keystrokes will land. */
+.shiki .find-match[data-occurrence] {
+  background: color-mix(in srgb, var(--theme-info) 30%, transparent);
+  border-top: 1px solid color-mix(in srgb, var(--theme-info) 55%, transparent);
+  border-bottom: 1px solid color-mix(in srgb, var(--theme-info) 55%, transparent);
+}
+.shiki .find-match[data-find-current] {
+  background: color-mix(in srgb, var(--theme-warning) 55%, transparent);
+  border-top: 1px solid color-mix(in srgb, var(--theme-warning) 75%, transparent);
+  border-bottom: 1px solid color-mix(in srgb, var(--theme-warning) 75%, transparent);
+}
 .prose-content .katex-display { overflow-x: auto; overflow-y: hidden; }
 
 /* Math placeholder: `marked.ts` emits a `.math-pending` span and KaTeX is

package/src/server/lib/omp/session/todos.ts

@@ -0,0 +1,100 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Read one session's todo state from its transcript.
+ *
+ * The list is omp's, and its only durable home is the session JSONL — there is
+ * no separate todo file and no chamber-side copy to fall out of date. So the
+ * read is: locate the session file, parse it, and take the deepest committed
+ * snapshot on the active branch (`latestTodoSnapshot`).
+ *
+ * Two properties of this read are deliberate:
+ *
+ *   - **It is a full-file parse, cached by size+mtime.** Measured on real
+ *     sessions (7.2 MB / 1905 entries) a full parse is ~15 ms, and the todos
+ *     may sit megabytes from EOF — a `todo` call near the start of a long
+ *     session stays the live list for the rest of it, so a bounded tail window
+ *     would report "no todos" for exactly the sessions that have the most. omp
+ *     flushes each entry as it appends, so a poll sees a new list within the
+ *     second it was written.
+ *   - **It never creates an omp process.** The session is read-only here; a
+ *     panel that spawned a child per poll would fight the chat's own session
+ *     wrapper for the same session file.
+ */
+
+import { findSessionFileById } from '@/server/lib/omp/session/locator';
+import { parseJsonlLenient } from '@/shared/lib/omp/session/jsonl';
+import { latestTodoSnapshot, todoProgress } from '@/shared/lib/chat/todo/snapshot';
+import type { SessionTodoState } from '@/shared/types/todo';
+
+/** Sessions larger than this are refused rather than parsed; a transcript past
+ *  it is pathological, and the read runs behind an HTTP request. */
+const MAX_TODO_SESSION_BYTES = 512 * 1024 * 1024;
+
+interface TodoCacheEntry {
+  size: number;
+  mtimeMs: number;
+  state: SessionTodoState;
+}
+
+/**
+ * Cache keyed by session id. Hangs off `globalThis` for the same reason the
+ * session-file caches do: a `bun --hot` reload re-evaluates modules but keeps
+ * `globalThis`, and a cache that vanished on every edit would re-parse a
+ * multi-megabyte file per poll during development.
+ */
+interface TodoCacheHost {
+  entries: Map<string, TodoCacheEntry>;
+}
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __ompChamberTodoCache: TodoCacheHost | undefined;
+}
+
+function cache(): TodoCacheHost {
+  globalThis.__ompChamberTodoCache ??= { entries: new Map() };
+  return globalThis.__ompChamberTodoCache;
+}
+
+const EMPTY_TODO_STATE: SessionTodoState = { snapshot: null, progress: todoProgress([]) };
+
+/**
+ * The todo state of one session. Returns an empty state (never a throw) when
+ * the transcript cannot be read: a session whose file is gone is a normal
+ * condition for a sidebar entry the user has not opened yet, and the panel
+ * reports "no todos" rather than an error for it.
+ */
+export async function readSessionTodos(sessionId: string): Promise<SessionTodoState> {
+  const filePath = await findSessionFileById(sessionId);
+  if (!filePath) return EMPTY_TODO_STATE;
+
+  let size: number;
+  let mtimeMs: number;
+  try {
+    const stats = await Bun.file(filePath).stat();
+    if (stats.size > MAX_TODO_SESSION_BYTES) return EMPTY_TODO_STATE;
+    size = stats.size;
+    mtimeMs = stats.mtimeMs;
+  } catch {
+    return EMPTY_TODO_STATE;
+  }
+
+  const slot = cache().entries.get(sessionId);
+  if (slot && slot.size === size && slot.mtimeMs === mtimeMs) return slot.state;
+
+  let body: string;
+  try {
+    body = await Bun.file(filePath).text();
+  } catch {
+    return EMPTY_TODO_STATE;
+  }
+
+  const snapshot = latestTodoSnapshot(parseJsonlLenient<Record<string, unknown>>(body));
+  const state: SessionTodoState = { snapshot, progress: todoProgress(snapshot?.phases ?? []) };
+  cache().entries.set(sessionId, { size, mtimeMs, state });
+  return state;
+}

package/src/server/routes/fs/action-create.test.ts

@@ -0,0 +1,90 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The Files panel's "New file" branch.
+ *
+ * Two rules are load-bearing and neither is visible from the happy path: the
+ * name may not carry a path separator (the folder is named by `path`, and a
+ * separator would turn a name into an arbitrary write under the root), and an
+ * existing file is REFUSED rather than truncated. The second one is the one a
+ * naive `Bun.write` gets wrong: `Bun.write` creates or truncates, so a name
+ * that collides with a real file would silently blank it.
+ */
+
+import { afterEach, describe, expect, test } from 'bun:test';
+import fs from 'fs';
+import path from 'path';
+import { action } from '@/server/routes/fs/action';
+
+/** Probes live in the repo root — the one directory the root allow-list always accepts. */
+const DIR = path.join(process.cwd(), 'tmp-create-probe');
+const NESTED = path.join(DIR, 'sub');
+
+afterEach(() => {
+  fs.rmSync(DIR, { recursive: true, force: true });
+});
+
+async function create(folderPath: string, name: string) {
+  const form = new FormData();
+  form.append('actionType', 'create');
+  form.append('root', process.cwd());
+  form.append('path', folderPath);
+  form.append('name', name);
+  const res = await action({ request: new Request('http://localhost/api/fs/action', { method: 'POST', body: form }) } as never);
+  return { status: res.status, body: (await res.json()) as { success?: boolean; path?: string; error?: string } };
+}
+
+describe('fs create', () => {
+  test('creates an empty file in the named folder and reports its relative path', async () => {
+    fs.mkdirSync(DIR, { recursive: true });
+    const { status, body } = await create('tmp-create-probe', 'notes.md');
+
+    expect(status).toBe(200);
+    expect(body).toEqual({ success: true, path: 'tmp-create-probe/notes.md' });
+    expect(fs.readFileSync(path.join(DIR, 'notes.md'), 'utf8')).toBe('');
+  });
+
+  test('creates inside a nested folder path, which is how a subfolder is targeted', async () => {
+    fs.mkdirSync(NESTED, { recursive: true });
+    const { status, body } = await create('tmp-create-probe/sub', 'index.ts');
+
+    expect(status).toBe(200);
+    expect(body.path).toBe('tmp-create-probe/sub/index.ts');
+    expect(fs.existsSync(path.join(NESTED, 'index.ts'))).toBe(true);
+  });
+
+  test('refuses an existing name instead of truncating it', async () => {
+    fs.mkdirSync(DIR, { recursive: true });
+    fs.writeFileSync(path.join(DIR, 'keep.txt'), 'important');
+
+    const { status, body } = await create('tmp-create-probe', 'keep.txt');
+
+    expect(status).toBe(409);
+    expect(body.error).toContain('already exists');
+    expect(fs.readFileSync(path.join(DIR, 'keep.txt'), 'utf8')).toBe('important');
+  });
+
+  test('refuses a name carrying a path separator', async () => {
+    fs.mkdirSync(DIR, { recursive: true });
+    for (const name of ['../escape.txt', 'sub/escape.txt', 'sub\\escape.txt']) {
+      const { status } = await create('tmp-create-probe', name);
+      expect(status).toBe(400);
+    }
+    expect(fs.existsSync(path.join(process.cwd(), 'escape.txt'))).toBe(false);
+  });
+
+  test('refuses an empty or whitespace-only name', async () => {
+    fs.mkdirSync(DIR, { recursive: true });
+    expect((await create('tmp-create-probe', '   ')).status).toBe(400);
+    expect((await create('tmp-create-probe', '.')).status).toBe(400);
+    expect((await create('tmp-create-probe', '..')).status).toBe(400);
+  });
+
+  test('refuses a folder that resolves outside the root', async () => {
+    const { status } = await create('../outside', 'x.txt');
+    expect(status).toBe(403);
+  });
+});

package/src/server/routes/fs/action.ts

@@ -37,6 +37,29 @@ export async function action({ request }: ActionFunctionArgs) {
       await fs.promises.mkdir(path.dirname(fullPath), { recursive: true });
       await Bun.write(fullPath, content);
       return json({ success: true });
+    } else if (actionType === 'create') {
+      // The Files panel's "New file": an empty file beside the folder that was
+      // right-clicked. Only a NAME is accepted, never a path — a separator
+      // would let the panel write anywhere under the root, and the folder is
+      // already named by `path`.
+      const name = ((formData.get('name') as string) ?? '').trim();
+      if (!name || name === '.' || name === '..' || /[/\\\0]/.test(name)) {
+        return json({ error: 'Enter a file name without slashes' }, { status: 400 });
+      }
+      const target = resolveWithinRoot(scopedRoot, path.join(filePath || '.', name));
+      if (!target) {
+        return json({ error: 'Invalid path' }, { status: 403 });
+      }
+      // Creating must never overwrite: a name that already exists is reported,
+      // not truncated — the panel offers Rename for that, and an empty write
+      // here would destroy the file the user meant to keep.
+      if ((await Bun.file(target).stat().catch(() => null)) !== null) {
+        return json({ error: `${name} already exists` }, { status: 409 });
+      }
+      await fs.promises.mkdir(path.dirname(target), { recursive: true });
+      await Bun.write(target, '');
+      // Relative to the LISTED root, which is the identity the tree renders by.
+      return json({ success: true, path: path.relative(scopedRoot, target).split(path.sep).join('/') });
     } else if (actionType === 'delete') {
       await fs.promises.rm(fullPath, { recursive: true, force: true });
       return json({ success: true });

package/src/server/routes/omp/index.ts

@@ -2,6 +2,7 @@ import { bindingsFor, type HandlerBinding } from '@/server/lib/route-adapter';
 import * as ompState from '@/server/routes/omp/state';
 import * as ompSidebar from '@/server/routes/omp/sidebar';
 import * as ompSessionStats from '@/server/routes/omp/session-stats';
+import * as ompSessionTodos from '@/server/routes/omp/session-todos';
 import * as ompCommands from '@/server/routes/omp/commands';
 import * as ompExtensions from '@/server/routes/omp/extensions';
 import * as ompLogin from '@/server/routes/omp/login';
@@ -12,6 +13,7 @@ export const ompBindings: HandlerBinding[] = [
   ...bindingsFor(ompState, '/api/omp/state'),
   ...bindingsFor(ompSidebar, '/api/omp/sidebar'),
   ...bindingsFor(ompSessionStats, '/api/omp/session-stats'),
+  ...bindingsFor(ompSessionTodos, '/api/omp/session-todos'),
   ...bindingsFor(ompCommands, '/api/omp/commands'),
   ...bindingsFor(ompExtensions, '/api/omp/extensions'),
   ...bindingsFor(ompLogin, '/api/omp/login'),