ompchamber 0.7.0 → 1.0.0

package/src/client/hooks/workspace/terminal.ts

@@ -1,283 +0,0 @@
-import type { TargetedKeyboardEvent } from 'preact';
-import { useCallback, useEffect, useRef, useState } from 'preact/hooks';
-import { useSessionState } from '@/client/hooks/workspace/session-state';
-import { useSessionStateContext } from '@/client/hooks/workspace/session-state/context';
-import type { TerminalLogItem } from '@/shared/types';
-
-const DEFAULT_COMMAND_HISTORY = ['bun --version', 'bun run build', 'git status -s'];
-
-const MAX_TERMINAL_LOGS = 50;
-
-function capLogs(items: TerminalLogItem[]): TerminalLogItem[] {
-  return items.length > MAX_TERMINAL_LOGS ? items.slice(-MAX_TERMINAL_LOGS) : items;
-}
-
-export interface UseTerminalOptions {
-  onStreamChunk?: (text: string) => void;
-  onCommandStart?: (cmd: string, options?: { fromXterm?: boolean }) => void;
-  onCommandEnd?: (exitCode: number, cwd: string) => void;
-  onClear?: () => void;
-  root?: string;
-  repo?: string;
-}
-
-export function useTerminal(options?: UseTerminalOptions) {
-  const [terminalLogs, setTerminalLogs] = useState<TerminalLogItem[]>([]);
-  const [terminalInput, setTerminalInput] = useSessionState<string>('terminal.input', '');
-  const [isRunning, setIsRunning] = useState(false);
-  const [cwd, setCwd] = useSessionState<string>('terminal.cwd', '.');
-  const [commandHistory, setCommandHistory] = useSessionState<string[]>('terminal.commandHistory', DEFAULT_COMMAND_HISTORY);
-  const [historyPointer, setHistoryPointer] = useState<number>(-1);
-  const [systemInfo, setSystemInfo] = useState<{
-    bunVersion: string;
-    nodeVersion: string;
-    gitBranch: string;
-  }>({
-    bunVersion: '',
-    nodeVersion: '',
-    gitBranch: 'main',
-  });
-
-  const abortControllerRef = useRef<AbortController | null>(null);
-  const streamCallbackRef = useRef(options?.onStreamChunk);
-  streamCallbackRef.current = options?.onStreamChunk;
-
-  const commandStartRef = useRef(options?.onCommandStart);
-  commandStartRef.current = options?.onCommandStart;
-
-  const commandEndRef = useRef(options?.onCommandEnd);
-  commandEndRef.current = options?.onCommandEnd;
-
-  const clearCallbackRef = useRef(options?.onClear);
-  clearCallbackRef.current = options?.onClear;
-
-  const rootRef = useRef(options?.root);
-  rootRef.current = options?.root;
-  const prevRootRef = useRef(options?.root);
-
-  const repoRef = useRef(options?.repo);
-  repoRef.current = options?.repo;
-  const prevRepoRef = useRef(options?.repo);
-
-  const { sessionId, ready } = useSessionStateContext();
-  const sessionIdRef = useRef(sessionId);
-  const absorbRestoreRef = useRef(true);
-
-  // Absorb the repo/cwd prop changes produced by a session restore (skip the
-  // reset for one tick after the blob loads), while genuine repo changes on a
-  // settled session still clear cwd/logs.
-  useEffect(() => {
-    if (sessionIdRef.current !== sessionId) {
-      sessionIdRef.current = sessionId;
-      absorbRestoreRef.current = true;
-    }
-    if (!ready || !absorbRestoreRef.current) return;
-    const timer = setTimeout(() => {
-      absorbRestoreRef.current = false;
-    }, 0);
-    return () => clearTimeout(timer);
-  }, [sessionId, ready]);
-
-  // Fetch real system environment on mount / when the scoped root or repo changes
-  useEffect(() => {
-    const root = options?.root;
-    const repo = options?.repo;
-    if (prevRootRef.current !== root || prevRepoRef.current !== repo) {
-      prevRootRef.current = root;
-      prevRepoRef.current = repo;
-      if (!absorbRestoreRef.current) {
-        setCwd('.');
-        setTerminalLogs([]);
-        clearCallbackRef.current?.();
-      }
-    }
-    const rootQuery = root ? `?root=${encodeURIComponent(root)}` : '';
-    const repoQuery = repo && repo !== '.' ? `&repo=${encodeURIComponent(repo)}` : '';
-    fetch(`/api/terminal/run${rootQuery}${repoQuery}`)
-      .then(res => res.json())
-      .then(data => {
-        if (data && data.bunVersion) {
-          setSystemInfo({
-            bunVersion: data.bunVersion ?? '',
-            nodeVersion: data.nodeVersion ?? '',
-            gitBranch: data.gitBranch || 'main',
-          });
-        }
-      })
-      .catch(() => {});
-  }, [options?.root, options?.repo]);
-
-  const clearLogs = useCallback(() => {
-    setTerminalLogs([]);
-  }, []);
-
-  const executeCommand = useCallback(
-    async (customCommand?: string, options?: { fromXterm?: boolean }) => {
-      const rawCmd = (customCommand !== undefined ? customCommand : terminalInput).trim();
-      if (!rawCmd || isRunning) return;
-
-      // Handle clear command locally
-      if (rawCmd === 'clear' || rawCmd === 'cls') {
-        setTerminalLogs([]);
-        setTerminalInput('');
-        setHistoryPointer(-1);
-        clearCallbackRef.current?.();
-        return;
-      }
-
-      const commandId = `cmd-${Date.now()}-${Math.random().toString(36).substring(2, 6)}`;
-      const timestamp = new Date().toLocaleTimeString();
-
-      // Add to history
-      setCommandHistory(prev => (prev[prev.length - 1] === rawCmd ? prev : [...prev, rawCmd]));
-      setHistoryPointer(-1);
-      setTerminalInput('');
-      setIsRunning(true);
-
-      // Notify start to xterm
-      commandStartRef.current?.(rawCmd, options);
-
-      const controller = new AbortController();
-      abortControllerRef.current = controller;
-
-      let accumulatedStdout = '';
-      let exitCode = 0;
-      let nextCwd = cwd;
-
-      try {
-        const rootQuery = rootRef.current ? `&root=${encodeURIComponent(rootRef.current)}` : '';
-        const repoQuery = repoRef.current && repoRef.current !== '.' ? `&repo=${encodeURIComponent(repoRef.current)}` : '';
-        const streamUrl = `/api/terminal/stream?cmd=${encodeURIComponent(rawCmd)}&cwd=${encodeURIComponent(cwd)}${rootQuery}${repoQuery}`;
-        const response = await fetch(streamUrl, {
-          signal: controller.signal,
-        });
-
-        if (!response.body) {
-          throw new Error('Streaming not supported by browser');
-        }
-
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = '';
-
-        while (true) {
-          const { value, done } = await reader.read();
-          if (done) break;
-
-          buffer += decoder.decode(value, { stream: true });
-          const lines = buffer.split('\n');
-          buffer = lines.pop() || '';
-
-          let currentEvent = 'message';
-          for (const line of lines) {
-            const trimmed = line.trim();
-            if (trimmed.startsWith('event:')) {
-              currentEvent = trimmed.slice(6).trim();
-            } else if (trimmed.startsWith('data:')) {
-              const dataStr = trimmed.slice(5).trim();
-              try {
-                const payload = JSON.parse(dataStr);
-                if (currentEvent === 'data' && payload.text) {
-                  const normalizedText = payload.text.replace(/\r?\n/g, '\r\n');
-                  accumulatedStdout += normalizedText;
-                  streamCallbackRef.current?.(normalizedText);
-                } else if (currentEvent === 'exit') {
-                  exitCode = typeof payload.exitCode === 'number' ? payload.exitCode : 0;
-                  if (payload.cwd && payload.cwd !== cwd) {
-                    nextCwd = payload.cwd;
-                    setCwd(payload.cwd);
-                  }
-                }
-              } catch {}
-            }
-          }
-        }
-      } catch (err: any) {
-        if (err.name === 'AbortError') {
-          exitCode = 130;
-          const abortMsg = '\r\n^C (Interrupted)\r\n';
-          accumulatedStdout += abortMsg;
-          streamCallbackRef.current?.(abortMsg);
-        } else {
-          exitCode = 1;
-          const errMsg = `\r\n\x1b[31mError: ${err.message || 'Execution failed'}\x1b[0m\r\n`;
-          accumulatedStdout += errMsg;
-          streamCallbackRef.current?.(errMsg);
-        }
-      } finally {
-        setIsRunning(false);
-        abortControllerRef.current = null;
-        commandEndRef.current?.(exitCode, nextCwd);
-
-        setTerminalLogs(prev =>
-          capLogs([
-            ...prev,
-            {
-              id: commandId,
-              command: rawCmd,
-              stdout: accumulatedStdout,
-              exitCode,
-              timestamp,
-              cwd: nextCwd,
-            },
-          ])
-        );
-      }
-    },
-    [terminalInput, isRunning, cwd, sessionId]
-  );
-
-  const cancelRunningCommand = useCallback(() => {
-    if (abortControllerRef.current) {
-      abortControllerRef.current.abort();
-    }
-  }, []);
-
-  const handleKeyDown = useCallback(
-    (e: TargetedKeyboardEvent<HTMLInputElement>) => {
-      if (e.key === 'ArrowUp') {
-        e.preventDefault();
-        if (commandHistory.length === 0) return;
-        setHistoryPointer(prev => {
-          const next = prev === -1 ? commandHistory.length - 1 : Math.max(0, prev - 1);
-          setTerminalInput(commandHistory[next] || '');
-          return next;
-        });
-      } else if (e.key === 'ArrowDown') {
-        e.preventDefault();
-        if (historyPointer === -1) return;
-        setHistoryPointer(prev => {
-          const next = prev + 1;
-          if (next >= commandHistory.length) {
-            setTerminalInput('');
-            return -1;
-          }
-          setTerminalInput(commandHistory[next] || '');
-          return next;
-        });
-      } else if (e.key === 'c' && e.ctrlKey) {
-        if (isRunning) {
-          cancelRunningCommand();
-        }
-      } else if (e.key === 'l' && e.ctrlKey) {
-        e.preventDefault();
-        clearLogs();
-        clearCallbackRef.current?.();
-      }
-    },
-    [commandHistory, historyPointer, isRunning, cancelRunningCommand, clearLogs, sessionId]
-  );
-
-  return {
-    terminalLogs,
-    terminalInput,
-    setTerminalInput,
-    isRunning,
-    cwd,
-    systemInfo,
-    executeCommand,
-    clearLogs,
-    cancelRunningCommand,
-    handleKeyDown,
-  };
-}

package/src/server/lib/fs/terminal-cwd.ts

@@ -1,49 +0,0 @@
-import path from 'path';
-import { isWithinRoot } from '@/server/lib/fs/root';
-
-/** True when `dir` resolves to an existing directory (async stat probe). */
-export async function isDirectory(dir: string): Promise<boolean> {
-  const stat = await Bun.file(dir).stat().catch(() => null);
-  return stat?.isDirectory() ?? false;
-}
-
-/**
- * Resolve the directory a terminal command should run in. `requestedCwd` is
- * honored only when it stays within `rootDir` and names a real directory;
- * otherwise the command runs at the root.
- */
-export async function resolveTerminalCwd(rootDir: string, requestedCwd: string): Promise<string> {
-  if (!requestedCwd) return rootDir;
-  const resolved = path.isAbsolute(requestedCwd)
-    ? path.resolve(requestedCwd)
-    : path.resolve(rootDir, requestedCwd);
-  if (isWithinRoot(rootDir, resolved) && (await isDirectory(resolved))) return resolved;
-  return rootDir;
-}
-
-export type CdResult =
-  | { ok: true; cwd: string }
-  | { ok: false; reason: 'above-root' | 'missing' };
-
-/**
- * Resolve a `cd <target>` against the current directory. The containment test
- * mirrors the original `startsWith(rootDir)` (no separator) exactly, so an
- * out-of-root sibling is still rejected the same way it always was.
- */
-export async function resolveCdTarget(
-  rootDir: string,
-  currentDir: string,
-  target: string,
-): Promise<CdResult> {
-  const nextDir = path.resolve(currentDir, target);
-  if (!nextDir.startsWith(rootDir)) return { ok: false, reason: 'above-root' };
-  if (!(await isDirectory(nextDir))) return { ok: false, reason: 'missing' };
-  return { ok: true, cwd: path.relative(rootDir, nextDir) || '.' };
-}
-
-/** Match a bare `cd` invocation; returns the trimmed target or null. */
-export function matchCdCommand(command: string): string | null {
-  const match = command.match(/^cd(?:\s+(.*))?$/);
-  if (!match) return null;
-  return (match[1] || '').trim();
-}

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

@@ -1,100 +0,0 @@
-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;
-}