ompchamber 0.3.0

package/src/shared/types/browser.ts

@@ -0,0 +1,58 @@
+/**
+ * Live browser-viewer contract shared between the /api/browser route and the
+ * browser panel. Values are produced server-side from the omp shared-browser
+ * daemon (see app/lib/browser/) and consumed by the panel's screencast hook.
+ */
+
+/** Why the viewer is not showing frames, or that it is. */
+export type BrowserViewStatus = 'agent-offline' | 'browser-offline' | 'no-tab' | 'live';
+
+/** One page target living in the project-shared browser. */
+export interface BrowserTabInfo {
+  targetId: string;
+  url: string;
+  title: string;
+}
+
+/** Coarse viewer state pushed on every meaningful change. */
+export interface BrowserViewState {
+  status: BrowserViewStatus;
+  url?: string;
+  title?: string;
+  targetId?: string;
+  tabs: BrowserTabInfo[];
+}
+
+/** One screencast frame (base64 JPEG) for the currently viewed tab. */
+export interface BrowserViewFrame {
+  data: string;
+  mimeType: string;
+  targetId: string;
+}
+
+export type BrowserActionKind =
+  | 'open'
+  | 'navigate'
+  | 'loaded'
+  | 'click'
+  | 'type'
+  | 'press'
+  | 'submit'
+  | 'wait'
+  | 'screenshot'
+  | 'scroll'
+  | 'upload'
+  | 'close'
+  | 'error';
+
+export interface BrowserPanelAction {
+  id: string;
+  kind: BrowserActionKind;
+  label: string;
+}
+
+/** Page context handed from a browser panel to the chat composer draft. */
+export interface BrowserPageContext {
+  url: string;
+  title?: string;
+}

package/src/shared/types/chat.ts

@@ -0,0 +1,289 @@
+import type { ReactNode } from 'preact/compat';
+import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
+
+export interface Attachment {
+  id: string;
+  name?: string;
+  file: File;
+  preview: string;
+  type?: string;
+  size?: number;
+  /** Base64 payload for image attachments (sent to the omp model). */
+  dataBase64?: string;
+}
+
+export type ChatAttachment = Attachment;
+
+/** Nama tool omp asli (built-in + hidden + MCP). `string` menampung tool
+ *  custom/plugin dan MCP (`mcp__<server>_<tool>`). */
+export type ToolType =
+  | 'bash'
+  | 'terminal'
+  | 'read'
+  | 'edit'
+  | 'write'
+  | 'ast_grep'
+  | 'ast_edit'
+  | 'ask'
+  | 'debug'
+  | 'eval'
+  | 'github'
+  | 'glob'
+  | 'grep'
+  | 'lsp'
+  | 'checkpoint'
+  | 'rewind'
+  | 'context_notes'
+  | 'new_context'
+  | 'security_scan'
+  | 'task'
+  | 'hub'
+  | 'todo'
+  | 'web_search'
+  | 'memory_edit'
+  | 'retain'
+  | 'recall'
+  | 'reflect'
+  | 'learn'
+  | 'manage_skill'
+  | 'yield'
+  | 'goal'
+  | 'think'
+  | 'edit_file' // legacy alias (MOCK path)
+  | 'read_file' // legacy alias (MOCK path)
+  | 'view_file' // legacy alias (MOCK path)
+  | 'create_file' // legacy alias (MOCK path)
+  | 'search_fs' // legacy alias (MOCK path)
+  | 'custom'
+  | (string & {});
+
+export type ToolStatus = 'pending' | 'running' | 'success' | 'error' | 'aborted' | 'skipped';
+
+export interface ToolDiffChunk {
+  file: string;
+  added?: number;
+  removed?: number;
+  diffText?: string;
+}
+
+export interface ToolCallData {
+  /** toolCallId dari omp — kunci pairing dengan toolResult. */
+  id: string;
+  type: ToolType;
+  title: string;
+  name?: string;
+  /** Short human intent (omp arguments.i) — ditampilkan sebelum tools. */
+  intent?: string;
+  target?: string;
+  command?: string;
+  /** Raw arguments tool call (object dari omp, string dari MOCK path). */
+  input?: string | Record<string, any>;
+  output?: string;
+  error?: string;
+  status?: ToolStatus;
+  duration?: string;
+  /** Raw duration ms dari toolResult (untuk format ulang). */
+  durationMs?: number;
+  diff?: ToolDiffChunk;
+  /** RAW details toolResult — dipakai renderer diff/task/usage. */
+  details?: Record<string, any>;
+  isError?: boolean;
+  /** details.__synthetic === true → call emitted tapi tidak dieksekusi. */
+  synthetic?: boolean;
+  icon?: ReactNode;
+  detail?: string;
+  time?: string;
+}
+
+export interface ThinkingData {
+  duration?: string;
+  thought: string;
+  summary?: string;
+  steps?: string[];
+  isGenerating?: boolean;
+}
+
+export interface AgentActionData {
+  icon?: ReactNode;
+  title: string;
+  time?: string;
+  detail: string;
+  type?: ToolType;
+  command?: string;
+  output?: string;
+  status?: ToolStatus;
+}
+
+export interface ChatMessageData {
+  id: string;
+  role: 'user' | 'ai' | 'assistant';
+  date?: string;
+  timestamp?: string;
+  content: string;
+  attachments?: { id?: string; name: string; preview?: string; type?: string; size?: number }[];
+  thinking?: ThinkingData | string;
+  /** Short human intent for tool calls (omp arguments.i) shown before the tools. */
+  intent?: string;
+  /** System notice surfaced by omp (e.g. ultrathink-notice) — rendered as an
+   *  alert row, not as assistant content. */
+  notice?: string;
+  toolCalls?: ToolCallData[];
+  actions?: (AgentActionData | ToolCallData)[];
+  systemNote?: string;
+  actions2?: (AgentActionData | ToolCallData)[];
+  attribution?: 'user' | 'agent' | string;
+  model?: string;
+  /** Provider that served this turn (omp `message.provider`). */
+  provider?: string;
+  /** Thinking level in effect for this turn (omp `thinking_level_change`).
+   *  Null/unset records normalize to `off`; absent = no level recorded. */
+  thinkingLevel?: string;
+  /** Wall-clock start of the turn in epoch ms (omp `message.timestamp`). */
+  startedAt?: number;
+  /** Wall-clock end of the turn in epoch ms (omp `message.completedAt`), or
+   *  derived from `startedAt + durationMs` when the runtime omits it. */
+  completedAt?: number;
+  durationMs?: number;
+  usage?: {
+    input?: number;
+    output?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    totalTokens?: number;
+    reasoningTokens?: number;
+    cost?: { input?: number; output?: number; cacheRead?: number; cacheWrite?: number; total?: number };
+  };
+  summary?: string;
+  monologue?: string;
+  /** Provider/API error attached to an assistant turn (e.g. 401 auth failure). */
+  error?: {
+    status?: number;
+    id?: number;
+    message?: string;
+    stopReason?: string;
+  };
+}
+
+/** Model settings snapshotted with a queued message so auto-delivery replays
+ *  them (set_model / set_thinking_level RPC + spawn access mode) instead of
+ *  using whatever the session happens to run with at delivery time. */
+export interface QueuedMessageModel {
+  provider: string;
+  modelId: string;
+  /** 'auto' means "leave omp's current level untouched" at delivery. */
+  thinkingLevel: string;
+  accessMode: ApprovalMode;
+}
+
+/** One row of the follow-up/steering queue (SQLite `queued_messages`). */
+export interface QueuedMessage {
+  id: string;
+  text: string;
+  attachments: Attachment[];
+  /** Null when queued before any model was selected — delivery falls back to
+   *  the session's current model. */
+  model: QueuedMessageModel | null;
+}
+
+export interface AIModelOption {
+  id: string;
+  name: string;
+  provider: string;
+  providerIcon?: string;
+  contextWindow?: string | number;
+  isCmdAgent?: boolean;
+  isFavorite?: boolean;
+  isRecent?: boolean;
+  thinkingLevel?: string;
+  /** Baked thinking ladder for this model: `["off", ...efforts]`. */
+  thinkingLevels?: string[];
+  capabilities?: string[];
+  input?: string;
+  output?: string;
+  cost?: {
+    input: string | number;
+    output: string | number;
+    cacheRead?: string | number;
+    cacheWrite?: string | number;
+  };
+  description?: string;
+}
+
+// ── Real omp model registry (forked from omp-web) ──────────────────────────
+
+/** One pickable model from the omp catalog (`/api/models` modelList). */
+export interface ModelEntry {
+  id: string;
+  name: string;
+  provider: string;
+  supportsFastMode?: boolean;
+  contextWindow?: number;
+  maxTokens?: number;
+  /** Baked thinking ladder for this model: `["off", ...efforts]`. */
+  thinkingLevels?: string[];
+  /** Cost in $/1M tokens (omp catalog). */
+  cost?: { input?: number; output?: number; cacheRead?: number; cacheWrite?: number };
+}
+
+/** A model selected by provider + modelId (omp's set_model shape). */
+export interface SelectedModel {
+  provider: string;
+  modelId: string;
+}
+
+/** Model-level thinking metadata read off the live session state. */
+export interface ThinkingModelMeta {
+  provider: string;
+  modelId: string;
+  name?: string;
+  reasoning?: boolean;
+  thinking?: { efforts?: string[] };
+}
+
+/** Response shape of GET /api/models (mirrors omp-web ModelsData). */
+export interface ModelsData {
+  models: Record<string, string>;
+  modelList: ModelEntry[];
+  defaultModel: SelectedModel | null;
+  thinkingLevels: Record<string, string[]>;
+  connectedProviders?: { id: string; name: string; disabled: boolean }[];
+  modelError?: string;
+}
+
+// ── Composer autocomplete (@file/agent / /command+skill) ───────────────────
+
+/** Trigger group that opened the composer autocomplete: `@` → mention, `/` → command. */
+export type ComposerPickKind = 'mention' | 'command';
+/** Origin of a pickable item: an `@` mention is an agent or a workspace file. */
+export type ComposerPickSource = 'agent' | 'file' | 'command' | 'skill';
+
+/** A detected trigger: the `@`/`/` char plus the query typed after it. */
+export interface ComposerTrigger {
+  kind: ComposerPickKind;
+  query: string;
+  /** Index of the trigger char (`@` or `/`). */
+  start: number;
+  /** Caret index when detected. */
+  end: number;
+}
+
+/** One autocomplete item surfaced in the composer popover. */
+export interface ComposerPickItem {
+  id: string;
+  name: string;
+  description: string;
+  /** The item's own category (agent / file / command / skill). */
+  kind: ComposerPickSource;
+  source: ComposerPickSource;
+  /** Exact insertion text WITHOUT trailing space: `@architect` | `@file:path/to/file` | `/review` | `/skill:capacity`. */
+  token: string;
+  /** Workspace-relative path (file items only). */
+  path?: string;
+}
+
+/** A pick item after filtering, with the matched range within `name` (or null). */
+export interface ComposerMatchItem extends ComposerPickItem {
+  /** Matched range within `name`; null = matched via description or empty query. */
+  match: { start: number; end: number } | null;
+}
+

package/src/shared/types/context.ts

@@ -0,0 +1,87 @@
+export interface ContextTokenBreakdown {
+  total: number;
+  input: number;
+  output: number;
+  reasoning: number;
+  cache: {
+    write: number;
+    read: number;
+  };
+}
+
+export interface RawMessageInfo {
+  id: string;
+  parentID?: string;
+  role: 'user' | 'assistant' | 'system';
+  mode?: string;
+  agent?: string;
+  path?: {
+    cwd: string;
+    root: string;
+  };
+  cost: number;
+  tokens: ContextTokenBreakdown;
+  modelID: string;
+  contentSnippet?: string;
+  toolSummary?: string;
+  timestamp?: string;
+}
+
+export interface RawMessageItem {
+  id: string;
+  type: string;
+  badgeLabel: string;
+  tokenSummary: string;
+  timestamp: string;
+  info: RawMessageInfo;
+  rawPayload: Record<string, any>;
+}
+
+export interface ContextCostBreakdown {
+  /** Fresh (uncached) prompt cost — often labelled "cache miss". */
+  input: number;
+  output: number;
+  /** Served-from-cache cost — labelled "cache hit". */
+  cacheRead: number;
+  cacheWrite: number;
+  total: number;
+}
+
+export interface SessionContextTelemetry {
+  sessionId: string;
+  sessionTitle: string;
+  modelId: string;
+  modelName: string;
+  timestamp: string;
+  contextUsed: number;
+  contextLimit: number;
+  contextPercent: number;
+  messagesCount: number;
+  userCount: number;
+  assistantCount: number;
+  totalCost: number;
+  costFormatted: string;
+  /** Average cache-hit rate (%) across assistant turns. */
+  cacheHitAverage?: number;
+  /** Per-category cost breakdown for the cost detail popup. */
+  costBreakdown?: ContextCostBreakdown;
+  lastMessage: {
+    input: number;
+    output: number;
+    reasoning: number;
+    cacheRead: number;
+    cacheWrite: number;
+    cacheHitPercent: number;
+  };
+  distribution: {
+    userTokens: number;
+    userPercent: number;
+    assistantTokens: number;
+    assistantPercent: number;
+    toolTokens: number;
+    toolPercent: number;
+    otherTokens: number;
+    otherPercent: number;
+  };
+  rawMessages: RawMessageItem[];
+}

package/src/shared/types/fs.ts

@@ -0,0 +1,36 @@
+export interface FsNode {
+  name: string;
+  path: string;
+  type: 'file' | 'folder';
+  size?: number;
+  modified?: number;
+  children?: FsNode[];
+  forceExpanded?: boolean;
+}
+
+export interface OpenedFile {
+  id: number | string;
+  name: string;
+  path: string;
+  content?: string;
+  isDirty?: boolean;
+  root?: string;
+  repo?: string;
+  isDiff?: boolean;
+  diffStatus?: string;
+  diffStaged?: boolean;
+}
+
+export interface SearchResultItem {
+  file: string;
+  line: number;
+  content: string;
+  preview?: string;
+}
+
+/** A flat file entry from the recursive file-listing endpoint (composer `@` mentions). */
+export interface FsFileEntry {
+  name: string;
+  /** Workspace-relative path with forward slashes. */
+  path: string;
+}

package/src/shared/types/git.ts

@@ -0,0 +1,60 @@
+export interface GitChange {
+  file: string;
+  status: 'M' | 'A' | 'D' | '?' | 'R' | 'C' | 'U' | string;
+  staged: boolean;
+  additions?: number;
+  deletions?: number;
+}
+
+export interface GitCommitFile {
+  file: string;
+  status: string;
+  additions: number;
+  deletions: number;
+  diff?: string;
+}
+
+export interface GitCommit {
+  hash: string;
+  shortHash: string;
+  author: string;
+  date: string;
+  message: string;
+  parents: string[];
+  refs?: string[];
+  files?: GitCommitFile[];
+  lane?: number;
+}
+
+export type GitViewMode = 'flat' | 'tree';
+
+export interface GitTreeNode {
+  id: string;
+  name: string;
+  path: string;
+  type: 'folder' | 'file';
+  change?: GitChange;
+  children: GitTreeNode[];
+  changeCount: number;
+}
+
+export interface GitStatusData {
+  changes: GitChange[];
+  branch: string;
+  branches: string[];
+  repos: string[];
+  activeRepo: string;
+  syncCount?: { ahead: number; behind: number };
+}
+
+export interface FileDiffData {
+  file: string;
+  diff: string;
+  oldContent?: string;
+  newContent?: string;
+  staged: boolean;
+  status: string;
+  additions?: number;
+  deletions?: number;
+}
+

package/src/shared/types/index.ts

@@ -0,0 +1,22 @@
+export * from '@/shared/types/workspace';
+export * from '@/shared/types/fs';
+export * from '@/shared/types/git';
+export * from '@/shared/types/chat';
+export * from '@/shared/types/terminal';
+export * from '@/shared/types/settings/state';
+export * from '@/shared/types/tokenUsage';
+export * from '@/shared/types/settings/project';
+export * from '@/shared/types/settings/provider';
+export * from '@/shared/types/settings/agent';
+export * from '@/shared/types/settings/command';
+export * from '@/shared/types/settings/mcp';
+export * from '@/shared/types/settings/usage';
+export * from '@/shared/types/settings/skill';
+export * from '@/shared/types/context';
+export * from '@/shared/types/omp/session';
+export * from '@/shared/types/omp/agent';
+export * from '@/shared/types/omp/instructions';
+export * from '@/shared/types/omp/subagent';
+export * from '@/shared/types/browser';
+export * from '@/shared/types/updates';
+export type { RightPanelType } from '@/shared/lib/workspace/right-panels';

package/src/shared/types/omp/agent.ts

@@ -0,0 +1,109 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * omp agent event surface types shared by useOmpAgent, the chamber timeline
+ * and the AskDialog renderer. Kept separate so the hook file stays under the
+ * repo's per-file size ceiling.
+ */
+
+import type { ChatMessageData } from '@/shared/types/chat';
+import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
+
+/** One frame of the live agent event stream (WebSocket or SSE). */
+export interface OmpAgentEvent {
+  type: string;
+  [key: string]: unknown;
+}
+
+/** Callbacks the timeline hands to useOmpAgent; every frame the stream folds
+ *  into ChatMessageData lands on one of these. */
+export interface OmpAgentCallbacks {
+  onAgentStart?: () => void;
+  onMessageUpdate?: (msg: ChatMessageData) => void;
+  onMessageEnd?: (msg: ChatMessageData) => void;
+  onAgentEnd?: (info: { errorMessage?: string; message?: string }) => void;
+  onPromptError?: (errorMessage: string) => void;
+  onNotice?: (level: string, message: string) => void;
+  onConnected?: () => void;
+  /** Mount-time probe found the session mid-run → the stream was reattached
+   *  and the UI should resume its generating state. */
+  onResumeStream?: () => void;
+  /** Ask/approval dialog diminta omp — blocking sampai di-respond. */
+  onExtensionUiRequest?: (request: IncomingExtensionUiRequest) => void;
+  /** User-message turn delivered by omp (queued steer/follow-up picked up). */
+  onQueuedMessageDelivered?: (text: string) => void;
+  /** omp applied a model change (set_model). The frame carries no payload, so
+   *  consumers should re-read session metadata to refresh the displayed model. */
+  onModelChanged?: () => void;
+  /** Live activity phrase for the generating indicator ("Editing app/x.ts"),
+   *  derived from the tool call or assistant phase the stream is on. */
+  onActivity?: (verb: string) => void;
+}
+
+export interface OmpAgentState {
+  isGenerating: boolean;
+  connected: boolean;
+  error: string | null;
+}
+
+/** An attached image payload accepted by every prompt-bearing RPC command. */
+export interface AgentImage {
+  data: string;
+  mimeType: string;
+}
+
+/** Command surface returned by useOmpAgent — the live omp session handle the
+ *  chat timeline drives. */
+export interface OmpAgentHandle extends OmpAgentState {
+  /** Send a prompt to an already-spawned session (warms the process up first).
+   *  `accessMode` rides the warmup + prompt bodies: omp has no RPC to change its
+   *  tool-approval mode, so the CLI `--approval-mode` flag is applied at spawn
+   *  time and the server reconciles an idle session by respawning it. */
+  sendPrompt: (message: string, images?: AgentImage[], options?: { accessMode?: ApprovalMode }) => Promise<boolean>;
+  /** Spawn a brand-new omp session and send its first prompt; resolves with the
+   *  adopted session id (or null on failure). */
+  sendNewPrompt: (
+    message: string,
+    cwd: string,
+    images?: AgentImage[],
+    composerOptions?: { model?: { provider: string; modelId: string } | null; thinkingLevel?: string | null; accessMode?: ApprovalMode },
+  ) => Promise<{ sessionId: string; model: { provider: string; modelId: string } | null } | null>;
+  /** Abort the running turn and immediately send `message` as a fresh prompt. */
+  sendInterruptAndReply: (message: string, images?: AgentImage[]) => Promise<boolean>;
+  /** Enqueue `message` for the agent to process after the current turn. */
+  sendFollowUp: (message: string, images?: AgentImage[]) => Promise<boolean>;
+  abort: () => Promise<void>;
+  setModel: (provider: string, modelId: string) => Promise<void>;
+  setThinkingLevel: (level: string) => Promise<void>;
+  /** Answer an ask/approval dialog, releasing omp's blocking tool call. */
+  respondToExtensionUi: (
+    request: ExtensionUiDialogRequest,
+    response: { value: string } | { confirmed: boolean } | { cancelled: true },
+  ) => Promise<void>;
+  disconnect: () => void;
+}
+
+/** Frame `extension_ui_request` dari omp (ask dialog, approval, OAuth). */
+export type ExtensionUiDialogMethod = 'select' | 'confirm' | 'input' | 'editor';
+
+export interface ExtensionUiDialogRequest {
+  type: 'extension_ui_request';
+  id: string;
+  method: ExtensionUiDialogMethod;
+  title: string;
+  options?: string[];
+  optionDetails?: { description?: string }[];
+  message?: string;
+  placeholder?: string;
+  prefill?: string;
+  timeout?: number;
+}
+
+export type IncomingExtensionUiRequest =
+  | ExtensionUiDialogRequest
+  | { type: 'extension_ui_request'; id: string; method: 'cancel'; targetId: string }
+  | { type: 'extension_ui_request'; id: string; method: 'notify'; message: string; notifyType?: 'info' | 'warning' | 'error' }
+  | { type: 'extension_ui_request'; id: string; method: 'open_url'; url: string; launchUrl?: string; instructions?: string };

package/src/shared/types/omp/instructions.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The two native user-level instruction files in the omp agent directory that
+ * the Behavior panel can edit, plus the HTTP payload shapes shared by
+ * `GET/POST /api/settings/behavior` and its hook.
+ */
+
+/**
+ * `agents` → AGENTS.md, the user context file injected once when a session
+ * starts. `rules` → RULES.md, the sticky rule whose full body rides every
+ * request and is re-read at session start / `/clear` / `/new`.
+ */
+export type InstructionFileKind = 'agents' | 'rules';
+
+/** Response shape of GET and POST /api/settings/behavior. */
+export interface InstructionFilePayload {
+  kind?: InstructionFileKind;
+  /** File content; empty when the file does not exist (or holds only whitespace). */
+  rules?: string;
+  /** Absolute native path, or null in MOCK mode where nothing hits disk. */
+  path?: string | null;
+  exists?: boolean;
+  isMock?: boolean;
+  /** True when recognizable permission directives were mirrored into config.yml. */
+  nativeSynced?: boolean;
+  nativeError?: string;
+  error?: string;
+}
+
+/** Outcome of a persist attempt: an error to surface, or a note about what landed. */
+export interface InstructionSaveResult {
+  error?: string;
+  note?: string;
+}