ompchamber 0.3.0

package/src/server/routes/telemetry/tokens.ts

@@ -0,0 +1,163 @@
+import { json } from '@/server/lib/remix-compat';
+import type { ActionFunctionArgs, LoaderFunctionArgs } from '@/server/lib/remix-compat';
+import { methodNotAllowed } from '@/server/lib/route-adapter';
+import { BREAKDOWN_DATA, MOCK_CHART_SERIES, MOCK_CUSTOM_RANGE_DATA, MOCK_RANGE_DATA, TIME_RANGES } from '@/client/data/mock/token-usage';
+import { isMockMode } from '@/server/mock.server';
+import { loadModelsDevCatalog } from '@/shared/lib/models/catalog';
+import { aggregateUsage, buildChartSeries, toBreakdownRows, toMetricSet, type UsageWindow } from '@/server/lib/omp/session/usage';
+import type { BreakdownRow, BreakdownTab, CadenceType, ChartSeriesPoint, TimeRangeType, TokenUsageMetricSet } from '@/shared/types';
+
+const REAL_ZERO_METRIC: TokenUsageMetricSet = {
+  rawCost: '$0.00',
+  processedTokens: '0',
+  activeRate: '0 per active day',
+  cachedInput: '0',
+  cachedPercent: '0.0% of observed input',
+  uncachedInput: '0',
+  outputTokens: '0',
+  reasoning: 'includes 0 reasoning',
+  cacheSavings: '$0.00',
+  scannedTranscripts: 0,
+  usageRecords: 0,
+};
+
+const PRESET_RANGES: Exclude<TimeRangeType, 'custom'>[] = ['today', '7d', '30d', '90d', 'all'];
+const CADENCES: CadenceType[] = ['daily', 'weekly', 'monthly'];
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+
+function parseWindow(url: URL): UsageWindow {
+  const timeRange = (url.searchParams.get('timeRange') as TimeRangeType) || '30d';
+  if (timeRange === 'custom') {
+    const from = url.searchParams.get('customFrom') || '';
+    const to = url.searchParams.get('customTo') || '';
+    if (ISO_DATE.test(from) && ISO_DATE.test(to) && from <= to) {
+      return { kind: 'custom', from, to };
+    }
+    return { kind: 'preset', range: '30d' };
+  }
+  if (timeRange === 'all') return { kind: 'all' };
+  if (PRESET_RANGES.includes(timeRange as Exclude<TimeRangeType, 'custom'>)) {
+    return { kind: 'preset', range: timeRange as Exclude<TimeRangeType, 'custom'> };
+  }
+  return { kind: 'preset', range: '30d' };
+}
+
+/** Optional per-model rates from the models.dev catalog (input/output per
+ *  1M tokens). Failures degrade to an empty map — pricing is supplementary. */
+async function loadModelRates(modelNames: string[]): Promise<Record<string, { input?: number; output?: number }>> {
+  try {
+    const catalog = await loadModelsDevCatalog();
+    const rates: Record<string, { input?: number; output?: number }> = {};
+    for (const name of modelNames) {
+      const bare = name.split('/').pop()?.toLowerCase() ?? name.toLowerCase();
+      for (const provider of Object.values(catalog)) {
+        const models = provider?.models;
+        if (!models || typeof models !== 'object') continue;
+        const match = Object.entries(models).find(([key, model]) => {
+          const candidates = [key.toLowerCase(), (model?.name ?? '').toLowerCase()];
+          return candidates.some((candidate) => candidate === bare || candidate === name.toLowerCase());
+        });
+        if (match) {
+          rates[name] = { input: match[1]?.cost?.input, output: match[1]?.cost?.output };
+          break;
+        }
+      }
+    }
+    return rates;
+  } catch {
+    return {};
+  }
+}
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  const url = new URL(request.url);
+  const timeRange = (url.searchParams.get('timeRange') as TimeRangeType) || '30d';
+  const breakdownTab = (url.searchParams.get('breakdownTab') as BreakdownTab) || 'model';
+  const cadenceParam = url.searchParams.get('cadence');
+  const cadence = CADENCES.includes(cadenceParam as CadenceType) ? (cadenceParam as CadenceType) : 'daily';
+  const window = parseWindow(url);
+  const mock = isMockMode();
+
+  if (mock) {
+    const activeMetrics = window.kind === 'custom'
+      ? MOCK_CUSTOM_RANGE_DATA
+      : (MOCK_RANGE_DATA[timeRange as Exclude<TimeRangeType, 'custom'>] || MOCK_RANGE_DATA['30d']);
+    const activeBreakdownRows = BREAKDOWN_DATA[breakdownTab] || BREAKDOWN_DATA.model;
+    const chartSeries = MOCK_CHART_SERIES[cadence] || MOCK_CHART_SERIES.daily;
+
+    return json({
+      timeRanges: TIME_RANGES,
+      rangeData: MOCK_RANGE_DATA,
+      breakdownData: BREAKDOWN_DATA,
+      activeMetrics,
+      activeBreakdownRows,
+      chartSeries,
+      metrics: activeMetrics,
+      breakdownRows: activeBreakdownRows,
+      timeRange,
+      breakdownTab,
+      cadence,
+      isMock: true,
+    });
+  }
+
+  // Real Mode: aggregate actual token/cost usage from omp session files.
+  try {
+    const realRangeData = {} as Record<Exclude<TimeRangeType, 'custom'>, TokenUsageMetricSet>;
+    for (const range of PRESET_RANGES) {
+      realRangeData[range] = toMetricSet(await aggregateUsage({ kind: 'preset', range }), cadence);
+    }
+
+    const activeAggregate = await aggregateUsage(window);
+    const realBreakdown: Record<BreakdownTab, BreakdownRow[]> = {
+      model: toBreakdownRows(activeAggregate, 'model'),
+      day: toBreakdownRows(activeAggregate, 'day', cadence),
+      project: toBreakdownRows(activeAggregate, 'project'),
+    };
+    const activeMetrics = toMetricSet(activeAggregate, cadence);
+    const activeBreakdownRows = realBreakdown[breakdownTab] || [];
+    const perModelRates = await loadModelRates(
+      realBreakdown.model.map((row) => row.name),
+    );
+
+    return json({
+      timeRanges: TIME_RANGES,
+      rangeData: realRangeData,
+      breakdownData: realBreakdown,
+      activeMetrics,
+      activeBreakdownRows,
+      chartSeries: buildChartSeries(activeAggregate, cadence),
+      metrics: activeMetrics,
+      breakdownRows: activeBreakdownRows,
+      pricing: perModelRates,
+      timeRange,
+      breakdownTab,
+      cadence,
+      isMock: false,
+    });
+  } catch (error: any) {
+    const zeroBreakdown: Record<BreakdownTab, BreakdownRow[]> = { model: [], day: [], project: [] };
+    return json({
+      timeRanges: TIME_RANGES,
+      rangeData: { today: REAL_ZERO_METRIC, '7d': REAL_ZERO_METRIC, '30d': REAL_ZERO_METRIC, '90d': REAL_ZERO_METRIC, all: REAL_ZERO_METRIC },
+      breakdownData: zeroBreakdown,
+      activeMetrics: REAL_ZERO_METRIC,
+      activeBreakdownRows: [],
+      chartSeries: [] as ChartSeriesPoint[],
+      metrics: REAL_ZERO_METRIC,
+      breakdownRows: [],
+      timeRange,
+      breakdownTab,
+      cadence,
+      isMock: false,
+      error: error.message,
+    });
+  }
+}
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  if (request.method === 'POST') {
+    return json({ success: true, timestamp: new Date().toISOString() });
+  }
+  return methodNotAllowed({ request, params });
+}

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

@@ -0,0 +1,8 @@
+import { bindingsFor, type HandlerBinding } from '@/server/lib/route-adapter';
+import * as terminalRun from '@/server/routes/terminal/run';
+import * as terminalStream from '@/server/routes/terminal/stream';
+
+export const terminalBindings: HandlerBinding[] = [
+  ...bindingsFor(terminalRun, '/api/terminal/run'),
+  ...bindingsFor(terminalStream, '/api/terminal/stream'),
+];

package/src/server/routes/terminal/run.ts

@@ -0,0 +1,135 @@
+import { json, type ActionFunctionArgs, type LoaderFunctionArgs } from '@/server/lib/remix-compat';
+import path from 'path';
+import { runShell } from '@/server/lib/fs/shell';
+import { resolveRoot } from '@/server/lib/fs/root';
+import { scopeToRepo } from '@/server/lib/fs/repo-scope';
+import { matchCdCommand, resolveCdTarget, resolveTerminalCwd } from '@/server/lib/fs/terminal-cwd';
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  const url = new URL(request.url);
+  const rootDir = await resolveRoot(url.searchParams.get('root'), process.cwd());
+  const targetDir = await scopeToRepo(rootDir, url.searchParams.get('repo'));
+  let bunVersion = '';
+  // `process.version` is the Node version Bun emulates, not a real Node binary.
+  const nodeVersion = process.version;
+  let gitBranch = 'main';
+
+  try {
+    const bunOut = await runShell('bun --version', { cwd: targetDir });
+    bunVersion = bunOut.stdout.trim();
+  } catch {
+    bunVersion = Bun.version;
+  }
+
+  try {
+    const branchOut = await runShell('git rev-parse --abbrev-ref HEAD', { cwd: targetDir });
+    gitBranch = branchOut.stdout.trim() || 'main';
+  } catch {
+    gitBranch = 'main';
+  }
+
+  return json({
+    bunVersion,
+    nodeVersion,
+    gitBranch,
+    cwd: targetDir,
+    relativePath: '.',
+  });
+}
+
+export async function action({ request }: ActionFunctionArgs) {
+  let command = '';
+  let requestedCwd = '';
+  let requestedRoot = '';
+  let requestedRepo = '';
+
+  const contentType = request.headers.get('content-type') || '';
+  if (contentType.includes('application/json')) {
+    const body = await request.json();
+    command = (body.command || '').trim();
+    requestedCwd = (body.cwd || '').trim();
+    requestedRoot = (body.root || '').trim();
+    requestedRepo = (body.repo || '').trim();
+  } else {
+    const formData = await request.formData();
+    command = ((formData.get('command') as string) || '').trim();
+    requestedCwd = ((formData.get('cwd') as string) || '').trim();
+    requestedRoot = ((formData.get('root') as string) || '').trim();
+    requestedRepo = ((formData.get('repo') as string) || '').trim();
+  }
+
+  const baseDir = await resolveRoot(requestedRoot, process.cwd());
+  const rootDir = await scopeToRepo(baseDir, requestedRepo);
+  const currentDir = await resolveTerminalCwd(rootDir, requestedCwd);
+
+  if (!command) {
+    return json({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+      durationMs: 0,
+      cwd: path.relative(rootDir, currentDir) || '.',
+    });
+  }
+
+  // Handle 'cd' commands directly to track directory state across calls
+  const cdTarget = matchCdCommand(command);
+  if (cdTarget !== null) {
+    if (!cdTarget || cdTarget === '~' || cdTarget === '/') {
+      return json({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+        durationMs: 1,
+        cwd: '.',
+      });
+    }
+
+    const cd = await resolveCdTarget(rootDir, currentDir, cdTarget);
+    if (!cd.ok) {
+      return json({
+        stdout: '',
+        stderr: cd.reason === 'above-root'
+          ? `cd: permission denied: cannot navigate above workspace root`
+          : `cd: no such file or directory: ${cdTarget}`,
+        exitCode: 1,
+        durationMs: 1,
+        cwd: path.relative(rootDir, currentDir) || '.',
+      });
+    }
+
+    return json({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+      durationMs: 1,
+      cwd: cd.cwd,
+    });
+  }
+
+  const startTime = Date.now();
+  const result = await runShell(command, {
+    cwd: currentDir,
+    timeout: 30000,
+    maxBuffer: 1024 * 1024 * 2,
+    env: {
+      PAGER: 'cat',
+      FORCE_COLOR: '0',
+    },
+  });
+  const durationMs = Date.now() - startTime;
+  // Timeout detection uses signalCode (SIGTERM from Bun), not `killed` —
+  // Bun 1.4 sets killed=true even for normal non-zero exits.
+  const timedOut = result.signalCode !== null;
+  const exitCode = timedOut ? 1 : (result.exitCode ?? 1);
+  const stderr = result.stderr || (timedOut ? 'Command timed out' : '') || (exitCode === 0 ? '' : result.error?.message || 'Command execution failed');
+
+  return json({
+    stdout: result.stdout,
+    stderr,
+    exitCode,
+    durationMs,
+    cwd: path.relative(rootDir, currentDir) || '.',
+    ...(exitCode === 0 ? {} : { error: result.error?.message || (timedOut ? 'Command timed out' : `Command exited with code ${exitCode}`) }),
+  });
+}

package/src/server/routes/terminal/stream.ts

@@ -0,0 +1,100 @@
+import { type LoaderFunctionArgs } from '@/server/lib/remix-compat';
+import path from 'path';
+import { resolveRoot } from '@/server/lib/fs/root';
+import { scopeToRepo } from '@/server/lib/fs/repo-scope';
+import { createSseStream } from '@/server/lib/sse';
+import { matchCdCommand, resolveCdTarget, resolveTerminalCwd } from '@/server/lib/fs/terminal-cwd';
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  const url = new URL(request.url);
+  const command = (url.searchParams.get('cmd') || '').trim();
+  const requestedCwd = (url.searchParams.get('cwd') || '').trim();
+  const baseDir = await resolveRoot(url.searchParams.get('root'), process.cwd());
+  const rootDir = await scopeToRepo(baseDir, url.searchParams.get('repo'));
+  const currentDir = await resolveTerminalCwd(rootDir, requestedCwd);
+
+  const stream = createSseStream({
+    headers: { 'Cache-Control': 'no-cache, no-transform' },
+    async onStart(handlers) {
+      if (!command) {
+        handlers.send('exit', { exitCode: 0, cwd: path.relative(rootDir, currentDir) || '.' });
+        handlers.close();
+        return;
+      }
+
+      // Special handling for cd navigation
+      const cdTarget = matchCdCommand(command);
+      if (cdTarget !== null) {
+        if (!cdTarget || cdTarget === '~' || cdTarget === '/') {
+          handlers.send('exit', { exitCode: 0, cwd: '.' });
+          handlers.close();
+          return;
+        }
+        const cd = await resolveCdTarget(rootDir, currentDir, cdTarget);
+        if (!cd.ok) {
+          handlers.send('data', {
+            text: cd.reason === 'above-root'
+              ? `\x1b[31mcd: permission denied: cannot navigate above workspace root\x1b[0m\r\n`
+              : `\x1b[31mcd: no such file or directory: ${cdTarget}\x1b[0m\r\n`,
+          });
+          handlers.send('exit', { exitCode: 1, cwd: path.relative(rootDir, currentDir) || '.' });
+          handlers.close();
+          return;
+        }
+        handlers.send('exit', { exitCode: 0, cwd: cd.cwd });
+        handlers.close();
+        return;
+      }
+
+      // Spawn via /bin/sh so shell syntax (pipes, &&) keeps working, with full
+      // ANSI color support for the xterm viewer.
+      const proc = Bun.spawn({
+        cmd: ['sh', '-c', command],
+        cwd: currentDir,
+        stdin: 'ignore',
+        stdout: 'pipe',
+        stderr: 'pipe',
+        env: {
+          ...Bun.env,
+          FORCE_COLOR: '1',
+          TERM: 'xterm-256color',
+        },
+      });
+
+      request.signal.addEventListener('abort', () => {
+        try {
+          proc.kill('SIGINT');
+        } catch {}
+      });
+
+      const decoder = new TextDecoder();
+      const pump = async (stream: ReadableStream<Uint8Array> | undefined) => {
+        if (!stream) return;
+        const reader = stream.getReader();
+        try {
+          for (;;) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            handlers.send('data', { text: decoder.decode(value, { stream: true }) });
+          }
+        } catch {
+          // Stream died with the process; exit handling below reports it.
+        } finally {
+          reader.releaseLock();
+        }
+      };
+      const stdoutDone = pump(proc.stdout);
+      const stderrDone = pump(proc.stderr);
+
+      void Promise.all([stdoutDone, stderrDone, proc.exited]).then(([_, __, code]) => {
+        handlers.send('exit', {
+          exitCode: code ?? 0,
+          cwd: path.relative(rootDir, currentDir) || '.',
+        });
+        handlers.close();
+      });
+    },
+  });
+
+  return stream.response;
+}

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

@@ -0,0 +1,25 @@
+import { json } from '@/server/lib/remix-compat';
+import type { ActionFunctionArgs } from '@/server/lib/remix-compat';
+import { methodNotAllowed } from '@/server/lib/route-adapter';
+import { applyUpdate } from '@/server/lib/updates/apply';
+
+/**
+ * POST /api/updates/apply — body `{ target: 'omp' | 'ompchamber' }`.
+ * Unknown targets are a 400; unexpected failures are a 500.
+ */
+export async function action({ request, params }: ActionFunctionArgs) {
+  if (request.method !== 'POST') {
+    return methodNotAllowed({ request, params });
+  }
+  try {
+    const body = (await request.json()) as { target?: unknown };
+    const target = body.target;
+    if (target === 'omp' || target === 'ompchamber') {
+      return json(await applyUpdate(target));
+    }
+    return json({ error: 'Unknown update target' }, { status: 400 });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Failed to apply update';
+    return json({ error: message }, { status: 500 });
+  }
+}

package/src/server/routes/updates/check.ts

@@ -0,0 +1,27 @@
+import { json, NO_STORE_HEADERS } from '@/server/lib/remix-compat';
+import { checkAllUpdates } from '@/server/lib/updates/check';
+import type { UpdateCheckResult, UpdateTargetInfo } from '@/shared/types/updates';
+
+function failureResult(message: string): UpdateCheckResult {
+  const target = (): UpdateTargetInfo => ({
+    current: null,
+    latest: null,
+    updateAvailable: false,
+    installed: false,
+    error: message,
+  });
+  return { ompchamber: target(), omp: target(), checkedAt: new Date().toISOString() };
+}
+
+/**
+ * GET /api/updates/check — latest OMPChamber release + oh-my-pi status.
+ * Always returns a valid UpdateCheckResult so the client never sees a 500.
+ */
+export async function loader() {
+  try {
+    return json(await checkAllUpdates(), { headers: NO_STORE_HEADERS });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Failed to check for updates';
+    return json(failureResult(message), { headers: NO_STORE_HEADERS });
+  }
+}

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

@@ -0,0 +1,8 @@
+import { bindingsFor, type HandlerBinding } from '@/server/lib/route-adapter';
+import * as updatesApply from '@/server/routes/updates/apply';
+import * as updatesCheck from '@/server/routes/updates/check';
+
+export const updatesBindings: HandlerBinding[] = [
+  ...bindingsFor(updatesApply, '/api/updates/apply'),
+  ...bindingsFor(updatesCheck, '/api/updates/check'),
+];

package/src/server/routes/well-known/devtools.ts

@@ -0,0 +1,9 @@
+import { json } from '@/server/lib/remix-compat';
+
+/**
+ * Chrome DevTools / browser debuggers probe this well-known endpoint to detect
+ * app-specific capabilities. A valid empty JSON body keeps the console clean.
+ */
+export async function loader() {
+  return json({});
+}

package/src/server/routes/well-known/index.ts

@@ -0,0 +1,6 @@
+import { bindingsFor, type HandlerBinding } from '@/server/lib/route-adapter';
+import * as wellKnownDevtools from '@/server/routes/well-known/devtools';
+
+export const wellKnownBindings: HandlerBinding[] = [
+  ...bindingsFor(wellKnownDevtools, '/.well-known/appspecific/com.chrome.devtools.json'),
+];

package/src/shared/lib/browser/activity.ts

@@ -0,0 +1,115 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Extracts human-readable activity from the eval script the agent runs against
+ * its built-in browser. The script itself is the intent: `browser.open({url})`,
+ * `.goto(url)`, `wait(ms)`, `.screenshot()`, … are parsed in source order so
+ * the panel can show what the agent is about to do. Interaction-level events
+ * (click/type/press) are deliberately NOT parsed here — the live CDP observer
+ * reports those as they actually happen (see observer.ts).
+ */
+
+import type { BrowserActionKind } from '@/shared/types';
+
+/** A toast-ready action before the transport adds id/source/timestamp. */
+export interface BrowserActionDraft {
+  kind: BrowserActionKind;
+  label: string;
+}
+
+const MAX_ACTIONS_PER_SCRIPT = 8;
+
+/** Host + trimmed path for toast copy, without the scheme. */
+export function shortUrl(raw: string): string {
+  const value = raw.trim();
+  if (!value) return '';
+  try {
+    const parsed = new URL(value);
+    const path = parsed.pathname === '/' ? '' : parsed.pathname;
+    return `${parsed.hostname}${path}`.slice(0, 64);
+  } catch {
+    return value.slice(0, 64);
+  }
+}
+
+function formatWait(ms: number): string {
+  const seconds = Math.round(ms / 1000);
+  return seconds >= 60 ? `Menunggu ${Math.round(seconds / 60)} menit` : `Menunggu ${seconds} detik`;
+}
+
+interface FoundAction {
+  index: number;
+  action: BrowserActionDraft;
+}
+
+/** Parse one eval script into an ordered, deduped, capped action list. */
+export function extractEvalActions(args: { code?: unknown; title?: unknown }): BrowserActionDraft[] {
+  const code = typeof args.code === 'string' ? args.code : '';
+  if (!code) return [];
+
+  const found: FoundAction[] = [];
+  const add = (index: number, kind: BrowserActionKind, label: string): void => {
+    found.push({ index, action: { kind, label } });
+  };
+
+  const openPattern = /browser\s*\.\s*open\s*\(\s*\{([^}]*)\}/g;
+  for (const match of code.matchAll(openPattern)) {
+    const body = match[1] ?? '';
+    const urlMatch = body.match(/url\s*:\s*(['"`])([^'"`]+)\1/);
+    if (urlMatch?.[2]) add(match.index ?? 0, 'open', `Membuka halaman ${shortUrl(urlMatch[2])}`);
+  }
+
+  const openCallPattern = /browser\s*\.\s*open\s*\(([^)]*)\)/g;
+  for (const match of code.matchAll(openCallPattern)) {
+    const body = match[1] ?? '';
+    if (body.includes('{')) continue;
+    const keywordMatch = body.match(/url\s*=\s*(['"])([^'"]+)\1/);
+    const positionalMatch = body.match(/^\s*(['"])([^'"]+)\1/);
+    const url = keywordMatch?.[2] ?? positionalMatch?.[2];
+    if (url) add(match.index ?? 0, 'open', `Membuka halaman ${shortUrl(url)}`);
+  }
+
+  const gotoPattern = /\.goto\s*\(\s*(['"`])([^'"`]+)\1\s*\)/g;
+  for (const match of code.matchAll(gotoPattern)) {
+    add(match.index ?? 0, 'navigate', `Navigasi ke ${shortUrl(match[2] ?? '')}`);
+  }
+
+  const waitPattern = /\bwait\s*\(\s*([\d_]+)\s*\)/g;
+  for (const match of code.matchAll(waitPattern)) {
+    const ms = Number.parseInt((match[1] ?? '').replace(/_/g, ''), 10);
+    if (Number.isFinite(ms) && ms >= 1000) add(match.index ?? 0, 'wait', formatWait(ms));
+  }
+
+  const screenshotPattern = /\.screenshot\s*\(/g;
+  for (const match of code.matchAll(screenshotPattern)) {
+    add(match.index ?? 0, 'screenshot', 'Mengambil screenshot');
+  }
+
+  const uploadPattern = /\.upload(?:File)?\s*\(/g;
+  for (const match of code.matchAll(uploadPattern)) {
+    add(match.index ?? 0, 'upload', 'Mengunggah file');
+  }
+
+  const scrollPattern = /\.scroll(?:IntoView)?\s*\(/g;
+  for (const match of code.matchAll(scrollPattern)) {
+    add(match.index ?? 0, 'scroll', 'Menggulir halaman');
+  }
+
+  const closePattern = /(?:browser|tab)\s*\.\s*close\s*\(/g;
+  for (const match of code.matchAll(closePattern)) {
+    add(match.index ?? 0, 'close', 'Menutup tab');
+  }
+
+  found.sort((a, b) => a.index - b.index);
+  const result: BrowserActionDraft[] = [];
+  for (const { action } of found) {
+    const previous = result[result.length - 1];
+    if (previous && previous.kind === action.kind && previous.label === action.label) continue;
+    result.push(action);
+    if (result.length >= MAX_ACTIONS_PER_SCRIPT) break;
+  }
+  return result;
+}