@oar-sh/oar 0.9.8 → 0.9.9

package/server/services/oar-cli-menu.mjs

@@ -0,0 +1,240 @@
+/**
+ * The terminal side of `oar`: line prompts and the menu. Everything reads
+ * from and writes to the stream pair it is given, so tests drive it with
+ * fake streams.
+ */
+
+import readline from 'node:readline';
+
+/** Ctrl+C (or a closed input) in a prompt or in the menu; `oar` exits 130 on it, without a message. */
+export class PromptAborted extends Error {
+  constructor() {
+    super('Aborted');
+    this.code = 'OAR_PROMPT_ABORTED';
+  }
+}
+
+export function askLine(question, { input = process.stdin, output = process.stdout } = {}) {
+  return new Promise((resolve, reject) => {
+    let rl;
+    try {
+      rl = readline.createInterface({ input, output, terminal: Boolean(input.isTTY) });
+    } catch {
+      // A terminal that refuses raw mode still reads whole lines.
+      rl = readline.createInterface({ input, output, terminal: false });
+    }
+    let settled = false;
+    const abort = () => {
+      if (settled) return;
+      settled = true;
+      rl.close();
+      output.write('\n');
+      reject(new PromptAborted());
+    };
+    rl.once('SIGINT', abort);
+    rl.once('close', abort);
+    rl.question(question, (answer) => {
+      settled = true;
+      rl.close();
+      resolve(String(answer).trim());
+    });
+  });
+}
+
+export async function askYesNo(question, { defaultYes = false, input, output } = {}) {
+  const answer = (await askLine(`${question} ${defaultYes ? '[Y/n]' : '[y/N]'} `, { input, output })).toLowerCase();
+  return answer ? answer === 'y' || answer === 'yes' : defaultYes;
+}
+
+export function createPrompter({ input = process.stdin, output = process.stdout } = {}) {
+  return {
+    line: (question) => askLine(question, { input, output }),
+    yesNo: (question, options = {}) => askYesNo(question, { ...options, input, output }),
+  };
+}
+
+export const MENU_ENTRIES = Object.freeze([
+  { id: 'start', label: 'Start' },
+  { id: 'stop', label: 'Stop' },
+  { id: 'restart', label: 'Restart' },
+  { id: 'url', label: 'Show URL and QR code' },
+  { id: 'setup', label: 'Settings' },
+  { id: 'service', label: 'Install or remove the service' },
+  { id: 'update', label: 'Update' },
+  { id: 'doctor', label: 'Doctor' },
+  { id: 'copilot', label: 'Copilot session' },
+  { id: 'quit', label: 'Quit' },
+]);
+
+const RELAY_TEXT = {
+  running: 'relay running',
+  stopped: 'relay stopped',
+  taken: 'relay not reachable (its port is held by another program, or by a relay with other settings)',
+  unconfigured: 'not set up yet (choose Settings)',
+};
+const SERVICE_TEXT = {
+  active: 'installed, running',
+  installed: 'installed',
+  none: 'not installed',
+  unavailable: 'not available here',
+};
+
+export function menuUsesColor({ env = process.env, output = process.stdout } = {}) {
+  return Boolean(output?.isTTY) && !String(env?.NO_COLOR || '');
+}
+
+/** The menu as lines of text: the status header, then the entries, the selected one marked. */
+export function renderMenu({ status = {}, selected = 0, color = false } = {}) {
+  const paint = (code, text) => (color ? `\x1b[${code}m${text}\x1b[0m` : text);
+  const relay = RELAY_TEXT[status.relay] || RELAY_TEXT.stopped;
+  const lines = [
+    `${paint(1, `OAR ${status.version || ''}`.trim())} · ${paint(status.relay === 'running' ? 32 : 31, relay)}`,
+  ];
+  if (status.url) lines.push(`  URL      ${status.url}`);
+  if (status.port) lines.push(`  Port     ${status.port}`);
+  if (status.access) lines.push(`  Access   ${status.access === 'lan' ? 'LAN' : 'this machine only'}`);
+  if (SERVICE_TEXT[status.service]) lines.push(`  Service  ${SERVICE_TEXT[status.service]}`);
+  for (const warning of status.warnings || []) lines.push(paint(33, `  ! ${warning}`));
+  lines.push('');
+  MENU_ENTRIES.forEach((entry, index) => {
+    const key = entry.id === 'quit' ? 'q' : String(index + 1);
+    const text = `${index === selected ? '>' : ' '} ${key}  ${entry.label}`;
+    lines.push(index === selected ? paint(7, text) : text);
+  });
+  lines.push('', 'Arrow keys and Enter, or a digit, to choose; q to quit.');
+  return lines;
+}
+
+/** One chunk of raw input as a menu key: 'up', 'down', 'enter', 'quit', 'interrupt', an entry index, or null. */
+export function readMenuKey(chunk) {
+  const key = String(chunk);
+  if (key === '\x03' || key === '\x04') return 'interrupt';
+  if (key === '\x1b[A' || key === '\x1bOA' || key === 'k') return 'up';
+  if (key === '\x1b[B' || key === '\x1bOB' || key === 'j') return 'down';
+  if (key === '\r' || key === '\n') return 'enter';
+  if (key === 'q' || key === 'Q') return 'quit';
+  if (/^[1-9]$/.test(key)) return Number(key) - 1;
+  return null;
+}
+
+/** Reads raw key presses until `onKey` returns a value; the terminal is back in line mode on every way out. */
+function readKeys({ input, onKey }) {
+  return new Promise((resolve, reject) => {
+    const finish = (settle, value) => {
+      input.removeListener('data', onData);
+      input.removeListener('end', onEnd);
+      try { input.setRawMode(false); } catch {}
+      input.pause();
+      settle(value);
+    };
+    const onEnd = () => finish(reject, new PromptAborted());
+    const onData = (chunk) => {
+      let result;
+      try { result = onKey(readMenuKey(chunk)); } catch (error) { finish(reject, error); return; }
+      if (result !== undefined) finish(resolve, result);
+    };
+    input.on('data', onData);
+    input.once('end', onEnd);
+    try {
+      input.setRawMode(true);
+      input.resume();
+    } catch (error) {
+      finish(reject, error);
+    }
+  });
+}
+
+/**
+ * Runs the menu until Quit or Ctrl+C. `loadStatus()` returns the header's
+ * status before each drawing; `actions[id](status)` runs an entry and may
+ * return `{ exit: true }` to leave the menu. An input without raw mode gets
+ * the same list with a numbered prompt.
+ */
+export async function runMenu({
+  input = process.stdin,
+  output = process.stdout,
+  env = process.env,
+  loadStatus = async () => ({}),
+  actions = {},
+} = {}) {
+  const color = menuUsesColor({ env, output });
+  let rawMode = typeof input.setRawMode === 'function';
+  let selected = 0;
+  const draw = (status) => {
+    output.write(`${output.isTTY ? '\x1b[2J\x1b[H' : ''}${renderMenu({ status, selected, color }).join('\n')}\n`);
+  };
+  const pickByKey = (status) => readKeys({
+    input,
+    onKey: (key) => {
+      if (key === 'interrupt') throw new PromptAborted();
+      if (key === 'quit') return MENU_ENTRIES.length - 1;
+      if (key === 'enter') return selected;
+      if (typeof key === 'number') {
+        selected = key;
+        return selected;
+      }
+      if (key === 'up' || key === 'down') {
+        selected = (selected + (key === 'up' ? MENU_ENTRIES.length - 1 : 1)) % MENU_ENTRIES.length;
+        draw(status);
+      }
+      return undefined;
+    },
+  });
+  const pickByNumber = async () => {
+    for (;;) {
+      const answer = (await askLine('Choose (1-9, q): ', { input, output })).toLowerCase();
+      if (answer === 'q') return MENU_ENTRIES.length - 1;
+      if (/^[1-9]$/.test(answer)) return Number(answer) - 1;
+    }
+  };
+
+  try {
+    for (;;) {
+      const status = await loadStatus();
+      draw(status);
+      let choice;
+      try {
+        choice = rawMode ? await pickByKey(status) : await pickByNumber();
+      } catch (error) {
+        if (error instanceof PromptAborted || !rawMode) throw error;
+        // The terminal refused raw mode.
+        rawMode = false;
+        choice = await pickByNumber();
+      }
+      selected = choice;
+      const entry = MENU_ENTRIES[choice];
+      if (entry.id === 'quit') return { code: 0, reason: 'menu-quit' };
+      output.write('\n');
+      let result = null;
+      try {
+        result = await actions[entry.id]?.(status);
+      } catch (error) {
+        // Ctrl+C inside an entry (a setup question) leaves that entry, not
+        // the menu.
+        if (error instanceof PromptAborted) {
+          output.write('\n');
+          continue;
+        }
+        output.write(`[oar] ${error?.message || error}\n`);
+      }
+      if (result?.exit) return { code: result.code ?? 0, reason: 'menu-exit' };
+      output.write('\n');
+      if (rawMode) {
+        output.write('Press a key to go back to the menu. ');
+        await readKeys({
+          input,
+          onKey: (key) => {
+            if (key === 'interrupt') throw new PromptAborted();
+            return true;
+          },
+        });
+      } else {
+        await askLine('Press Enter to go back to the menu. ', { input, output });
+      }
+    }
+  } catch (error) {
+    if (!(error instanceof PromptAborted)) throw error;
+    output.write('\n');
+    return { code: 130, reason: 'interrupted' };
+  }
+}

package/server/services/oar-cli-wsl.mjs

@@ -0,0 +1,129 @@
+/**
+ * What `oar` needs to know about WSL. A distro in WSL's default (NAT)
+ * networking has its own network namespace: a port a Windows program listens
+ * on looks free inside the distro, and a Windows browser's `localhost:<port>`
+ * then reaches the Windows program, not the relay in the distro. Windows is
+ * asked through interop; every failure means "unknown" and is treated like a
+ * plain Linux host.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+const INTEROP_TIMEOUT_MS = 4000;
+// WSL's own localhost forwarders listen on Windows for every port a distro
+// listens on, so they stand for the distro's program, not for a Windows one.
+const WSL_FORWARDER_RE = /^wsl(relay|host)\.exe$/i;
+
+export function isWsl({ env = process.env, platform = process.platform, readFileImpl = fs.readFileSync } = {}) {
+  if (platform !== 'linux') return false;
+  if (String(env?.WSL_DISTRO_NAME || env?.WSL_INTEROP || '').trim()) return true;
+  try {
+    return /microsoft|wsl/i.test(String(readFileImpl('/proc/sys/kernel/osrelease', 'utf8')));
+  } catch {
+    return false;
+  }
+}
+
+/** The Windows system folder as the distro sees it: `[automount] root` of /etc/wsl.conf, else /mnt/. */
+export function windowsSystemDir({ readFileImpl = fs.readFileSync } = {}) {
+  let root = '/mnt/';
+  try {
+    let section = '';
+    for (const raw of String(readFileImpl('/etc/wsl.conf', 'utf8')).split(/\r?\n/)) {
+      const line = raw.trim();
+      const header = line.match(/^\[(.+)\]$/);
+      if (header) section = header[1].trim().toLowerCase();
+      const pair = section === 'automount' && line.match(/^root\s*=\s*(.+)$/i);
+      if (pair) root = pair[1].trim().replace(/^["']|["']$/g, '') || root;
+    }
+  } catch {
+    // No wsl.conf: the default mount root.
+  }
+  return path.posix.join(root, 'c', 'Windows', 'System32');
+}
+
+function runWindowsTool(name, args, { spawnSyncImpl = spawnSync, readFileImpl = fs.readFileSync } = {}) {
+  try {
+    const result = spawnSyncImpl(path.posix.join(windowsSystemDir({ readFileImpl }), name), args, {
+      encoding: 'utf8',
+      timeout: INTEROP_TIMEOUT_MS,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    return result && !result.error && result.status === 0 ? String(result.stdout || '') : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Listening TCP ports in `netstat -ano` output, each with the process ids
+ * that hold it. Windows prints the state word in the system language, so a
+ * listener is recognised by its shape instead: a TCP row whose remote address
+ * is the all-zero one (`0.0.0.0:0` or `[::]:0`). Only listeners a browser's
+ * `localhost` reaches count: the loopback and the any-address ones.
+ */
+export function parseNetstatListeners(text) {
+  const listeners = new Map();
+  for (const line of String(text || '').split(/\r?\n/)) {
+    const row = line.match(/^\s*TCP\s+(\S+):(\d+)\s+(?:0\.0\.0\.0|\[::\]):0\s+.*?(\d+)\s*$/);
+    if (!row || !['0.0.0.0', '127.0.0.1', '[::]', '[::1]'].includes(row[1])) continue;
+    const port = Number(row[2]);
+    const pids = listeners.get(port) || [];
+    if (!pids.includes(Number(row[3]))) pids.push(Number(row[3]));
+    listeners.set(port, pids);
+  }
+  return listeners;
+}
+
+/** Port → process ids of the Windows listeners, or null when Windows cannot be asked. */
+export function windowsListeningPorts(options = {}) {
+  const output = runWindowsTool('netstat.exe', ['-ano'], options);
+  return output === null ? null : parseNetstatListeners(output);
+}
+
+function windowsProcessName(pid, options) {
+  const output = runWindowsTool('tasklist.exe', ['/FI', `PID eq ${pid}`, '/FO', 'CSV', '/NH'], options);
+  return output?.match(/^"([^"]+)"/m)?.[1] || '';
+}
+
+/**
+ * A function `(port) => name | null`: the Windows program that holds the port,
+ * or null when none does, when this is not WSL, or when Windows cannot be
+ * asked. The listener list is read once, on the first call.
+ */
+export function createWindowsPortCheck(options = {}) {
+  if (!isWsl(options)) return () => null;
+  let listeners;
+  return (port) => {
+    if (listeners === undefined) listeners = windowsListeningPorts(options);
+    for (const pid of listeners?.get(Number(port)) || []) {
+      const name = windowsProcessName(pid, options);
+      if (!WSL_FORWARDER_RE.test(name)) return name || 'a Windows program';
+    }
+    return null;
+  };
+}
+
+/**
+ * True in a WSL distro whose network is its own (NAT): its LAN address is
+ * internal to WSL. Mirrored networking shares the addresses of Windows.
+ */
+export function isWslNat(options = {}) {
+  if (!isWsl(options)) return false;
+  try {
+    const result = (options.spawnSyncImpl || spawnSync)('wslinfo', ['--networking-mode'], {
+      encoding: 'utf8',
+      timeout: INTEROP_TIMEOUT_MS,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    return String(result?.stdout || '').trim().toLowerCase() !== 'mirrored';
+  } catch {
+    return true;
+  }
+}
+
+export function windowsPortWarning(port, holder) {
+  return `Windows holds port ${port} (${holder}): a browser on Windows reaches that program, not this relay. Pick another port: oar setup --port N`;
+}

package/server/services/safe-served-content.mjs

@@ -3,15 +3,20 @@
 //
 // The threat: a semi-trusted producer (an AI worker writing a workspace file, or
 // an uploaded attachment) can supply content whose MIME type the browser will
-// execute as markup/script on THIS origin — `text/html`, `image/svg+xml`, XML
-// with embedded script. Served inline, that is stored XSS against the app (and,
-// via the unauthenticated /api/shared/* routes, against share viewers). We
-// neutralize such types to `text/plain` and always send `nosniff`, and we attach
-// a locked-down CSP + `sandbox` so anything that still reaches the browser as a
+// execute as markup/script on THIS origin — `text/html`, XML with embedded
+// script. Served inline, that is stored XSS against the app (and, via the
+// unauthenticated /api/shared/* routes, against share viewers). We neutralize
+// such types to `text/plain` and always send `nosniff`, and we attach a
+// locked-down CSP + `sandbox` so anything that still reaches the browser as a
 // document can neither run script nor navigate.
+//
+// SVG keeps its type: as an `<img>` it never runs script, and opened as a
+// document the `sandbox` CSP denies it script and an origin, so the viewer
+// and the file browser's thumbnails can show it.
 
 // Types the browser renders as active documents on this origin.
-const ACTIVE_MARKUP_PATTERN = /^text\/html\b|svg|xhtml|(^|\/)xml\b|\+xml\b/i;
+const ACTIVE_MARKUP_PATTERN = /^text\/html\b|xhtml|(^|\/)xml\b|\+xml\b/i;
+const SVG_TYPE = 'image/svg+xml';
 
 // Types safe to preview inline with their real Content-Type.
 const INLINE_SAFE_PREFIXES = ['image/', 'video/', 'audio/'];
@@ -25,7 +30,7 @@ const INLINE_SAFE_EXACT = new Set(['application/pdf']);
 export function safeServedContentType(mimeType) {
   const type = String(mimeType || '').trim().toLowerCase().split(';')[0].slice(0, 127)
     || 'application/octet-stream';
-  if (ACTIVE_MARKUP_PATTERN.test(type)) {
+  if (type !== SVG_TYPE && ACTIVE_MARKUP_PATTERN.test(type)) {
     // Render markup/script content as its own source text instead of executing it.
     return { contentType: 'text/plain; charset=utf-8', inlineSafe: false, neutralized: true };
   }
@@ -34,6 +39,45 @@ export function safeServedContentType(mimeType) {
   return { contentType: type, inlineSafe, neutralized: false };
 }
 
+// Printable ASCII, the only characters a quoted `filename="…"` may hold once
+// quotes and backslashes are gone. Anything else goes into `filename*`.
+const NON_ASCII_PATTERN = /[^\x20-\x7e]/g;
+// A surrogate without its partner: not a character, and encodeURIComponent
+// throws on it.
+const LONE_SURROGATE_PATTERN = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+
+/** RFC 5987 `ext-value` encoding: UTF-8 percent-encoded, attr-char kept. */
+function encodeRfc5987(value) {
+  return encodeURIComponent(value)
+    // encodeURIComponent leaves these alone, but RFC 5987 does not allow them bare.
+    .replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+
+/**
+ * The `Content-Disposition` value for `fileName`, RFC 6266 style: a quoted
+ * `filename` every client can read, built from the name's ASCII characters
+ * (never empty: `file` plus the extension when nothing is left), and, when the
+ * name has characters outside ASCII, `filename*=UTF-8''…` carrying the whole
+ * name percent-encoded. The result holds nothing a header may not: no
+ * control characters, no quotes inside the quoted string, and no character
+ * outside Latin-1, which Node's `setHeader` rejects (and which used to make a
+ * file with a Japanese or emoji name unservable).
+ */
+export function contentDispositionValue(disposition, fileName) {
+  const name = String(fileName || '')
+    .replace(LONE_SURROGATE_PATTERN, '')
+    .replace(/[\u0000-\u001f\u007f"\\]/g, '')
+    .slice(0, 255);
+  if (!name) return disposition;
+  const ascii = name.replace(NON_ASCII_PATTERN, '').trim();
+  if (ascii === name) return `${disposition}; filename="${name}"`;
+  const dot = name.lastIndexOf('.');
+  const stem = (dot > 0 ? name.slice(0, dot) : name).replace(NON_ASCII_PATTERN, '').replace(/^[\s.]+|[\s.]+$/g, '') || 'file';
+  const ext = (dot > 0 ? name.slice(dot) : '').replace(NON_ASCII_PATTERN, '').trim();
+  const fallback = `${stem}${ext.length > 1 ? ext : ''}`;
+  return `${disposition}; filename="${fallback}"; filename*=UTF-8''${encodeRfc5987(name)}`;
+}
+
 /**
  * Apply the safe Content-Type plus the hardening headers to a response that is
  * about to stream stored bytes. Returns the resolved descriptor so callers can
@@ -46,12 +90,18 @@ export function applySafeServedContentHeaders(res, mimeType, { fileName = '' } =
   // Belt-and-braces: a served file is never part of the app UI, so forbid it
   // from loading anything or being framed, and sandbox it so it cannot run
   // script or navigate even if a browser would otherwise treat it as active.
-  res.setHeader('Content-Security-Policy', "default-src 'none'; sandbox; frame-ancestors 'none'");
-  const safeName = String(fileName || '').replace(/[\r\n"\\]/g, '').slice(0, 255);
-  const disposition = resolved.inlineSafe ? 'inline' : 'attachment';
+  // A PDF is the exception: browsers refuse to show a sandboxed PDF in their
+  // built-in viewer, so it gets no `sandbox` and may be framed by this origin.
+  // PDF viewers do not run document script, so the sandbox bought nothing there.
+  res.setHeader(
+    'Content-Security-Policy',
+    resolved.contentType === 'application/pdf'
+      ? "default-src 'none'; frame-ancestors 'self'"
+      : "default-src 'none'; sandbox; frame-ancestors 'none'",
+  );
   res.setHeader(
     'Content-Disposition',
-    safeName ? `${disposition}; filename="${safeName}"` : disposition,
+    contentDispositionValue(resolved.inlineSafe ? 'inline' : 'attachment', fileName),
   );
   return resolved;
 }

package/server/services/session-history-refresh-service.mjs

@@ -144,6 +144,22 @@ export function createSessionHistoryRefreshService({
         WHERE conversation_id = ? AND hidden_from_shares = 1
       `)
     : null;
+  // Pins are carried across the replace the same way as hidden marks.
+  const messagesSupportPins = messageColumns.has('pinned_at');
+  const listPinnedMessageMarks = messagesSupportPins
+    ? db.prepare(`
+        SELECT id, role, text, timestamp, pinned_at
+        FROM messages
+        WHERE conversation_id = ? AND pinned_at IS NOT NULL
+      `)
+    : null;
+  const restoreMessagePin = messagesSupportPins
+    ? db.prepare(`
+        UPDATE messages
+        SET pinned_at = ?
+        WHERE conversation_id = ? AND id = ?
+      `)
+    : null;
   const restoreHiddenMessageVisibility = messagesSupportShareVisibility
     ? db.prepare(`
         UPDATE messages
@@ -418,6 +434,7 @@ export function createSessionHistoryRefreshService({
 
   const replaceRetrievableHistoryTx = db.transaction((conversationId, messages = []) => {
     const hiddenMessages = listHiddenMessageVisibility?.all(conversationId) || [];
+    const pinnedMessages = listPinnedMessageMarks?.all(conversationId) || [];
     const attachmentCandidates = collectAttachmentCandidates(conversationId);
     deleteConversationMessages.run(conversationId);
     deleteConversationActivity.run(conversationId);
@@ -437,6 +454,13 @@ export function createSessionHistoryRefreshService({
         resolvedId,
       );
     }
+    // Its own consumed set: a message can be both hidden and pinned.
+    const consumedPinnedIds = new Set();
+    for (const pinnedMessage of pinnedMessages) {
+      const resolvedId = resolveHiddenMessageId(pinnedMessage, rebuiltMessages, consumedPinnedIds);
+      if (!resolvedId) continue;
+      restoreMessagePin.run(pinnedMessage.pinned_at, conversationId, resolvedId);
+    }
   });
 
   function evaluateRefreshIdleState(conversationId) {