march-cli 0.1.28 → 0.1.30

package/src/browser/extension/errors.js

@@ -0,0 +1,19 @@
+export function serializeError(err) {
+  if (!err) return { message: "Unknown error" };
+  if (typeof err === "string") return { message: err };
+  const name = typeof err.name === "string" && err.name ? err.name : "Error";
+  const stack = typeof err.stack === "string" ? err.stack : "";
+  const message = readableErrorMessage(err);
+  return { name, message, stack };
+}
+
+function readableErrorMessage(err) {
+  if (typeof err?.message === "string" && err.message && err.message !== "[object Object]") return err.message;
+  if (typeof err?.message === "object") return safeStringify(err.message);
+  const json = safeStringify(err);
+  return json === "{}" ? String(err) : json;
+}
+
+function safeStringify(value) {
+  try { return JSON.stringify(value); } catch { return String(value); }
+}

package/src/browser/extension/execute-code.js

@@ -0,0 +1,53 @@
+export function buildExecCode(code) {
+  return `(async () => {
+    function smartResult(value) {
+      if (value == null || typeof value !== "object") return value;
+      try { if (value.window === value && value.document) return "[Window: " + (value.location?.href || "about:blank") + "]"; } catch {}
+      if (typeof Node !== "undefined" && value.nodeType === Node.ELEMENT_NODE) return value.outerHTML;
+      if (typeof NodeList !== "undefined" && (value instanceof NodeList || value instanceof HTMLCollection)) {
+        return Array.from(value).slice(0, 300).map((item) => item?.nodeType === Node.ELEMENT_NODE ? item.outerHTML : String(item));
+      }
+      try {
+        return JSON.parse(JSON.stringify(value, (_key, item) => {
+          if (item && typeof item === "object") {
+            if (typeof Node !== "undefined" && item.nodeType === Node.ELEMENT_NODE) return item.outerHTML;
+            try { if (item.window === item && item.document) return "[Window]"; } catch {}
+          }
+          return item;
+        }));
+      } catch (err) {
+        return "[Unserializable: " + (err?.message || String(err)) + "]";
+      }
+    }
+    function executable(source) {
+      const lines = source.split(/\\r?\\n/);
+      let index = lines.length - 1;
+      while (index >= 0 && !lines[index].trim()) index--;
+      if (index < 0) return source;
+      const last = lines[index].trim();
+      if (/^(return\\b|let\\b|const\\b|var\\b|if\\b|for\\b|while\\b|switch\\b|try\\b|throw\\b|class\\b|function\\b|async\\b|import\\b|export\\b|\\/\\/|})/.test(last)) return source;
+      lines[index] = lines[index].match(/^(\\s*)/)[1] + "return " + last;
+      return lines.join("\\n");
+    }
+    try {
+      const source = ${JSON.stringify(code)}.trim();
+      const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
+      let value;
+      if (/^return\\b/.test(source) || /\\n\\s*return\\b/.test(source)) {
+        value = await (new AsyncFunction(source))();
+      } else {
+        try {
+          value = eval(source);
+          if (value && typeof value.then === "function") value = await value;
+        } catch (err) {
+          if (err instanceof SyntaxError) value = await (new AsyncFunction(executable(source)))();
+          else throw err;
+        }
+      }
+      return { ok: true, data: smartResult(value) };
+    } catch (err) {
+      const message = err?.message || String(err);
+      return { ok: false, csp: /unsafe-eval|Content Security Policy|Refused to evaluate/i.test(message), error: { name: err?.name || "Error", message, stack: err?.stack || "" } };
+    }
+  })()`;
+}

package/src/browser/extension/manifest.json

@@ -0,0 +1,15 @@
+{
+  "manifest_version": 3,
+  "name": "March Browser Bridge",
+  "version": "0.1.0",
+  "description": "Connects the user's browser tabs to March CLI.",
+  "permissions": ["tabs", "scripting", "webNavigation", "storage", "alarms", "debugger"],
+  "host_permissions": ["<all_urls>"],
+  "background": {
+    "service_worker": "background.js",
+    "type": "module"
+  },
+  "action": {
+    "default_title": "March Browser Bridge"
+  }
+}

package/src/browser/extension-install.mjs

@@ -0,0 +1,21 @@
+import { cpSync, existsSync, rmSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export function sourceBrowserExtensionPath() {
+  const path = resolve(dirname(fileURLToPath(import.meta.url)), "extension");
+  if (!existsSync(path)) throw new Error(`Browser extension not found: ${path}`);
+  return path;
+}
+
+export function installedBrowserExtensionPath(stateRoot) {
+  return resolve(stateRoot, "browser-extension");
+}
+
+export function syncBrowserExtensionInstall(stateRoot) {
+  const source = sourceBrowserExtensionPath();
+  const target = installedBrowserExtensionPath(stateRoot);
+  rmSync(target, { recursive: true, force: true });
+  cpSync(source, target, { recursive: true });
+  return target;
+}

package/src/browser/tools/index.mjs

@@ -0,0 +1,89 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { toolText } from "../../agent/tool-result.mjs";
+import { callBrowserDaemon } from "../client/rpc.mjs";
+
+export function createBrowserTools({ stateRoot = join(homedir(), ".march") } = {}) {
+  return [
+    browserTabsTool(stateRoot),
+    browserOpenTool(stateRoot),
+    browserReadTool(stateRoot),
+    browserScriptTool(stateRoot),
+  ];
+}
+
+function browserTabsTool(stateRoot) {
+  return defineTool({
+    name: "browser_tabs",
+    label: "Browser Tabs",
+    description: "List all tabs visible to the March browser extension. Use this first to choose a tabId.",
+    parameters: Type.Object({}),
+    execute: async () => safeToolJson(() => callBrowserDaemon({ stateRoot, method: "tabs" })),
+  });
+}
+
+function browserOpenTool(stateRoot) {
+  return defineTool({
+    name: "browser_open",
+    label: "Browser Open",
+    description: "Create, navigate, focus, close, reload, back, or forward browser tabs. Returns the affected tab when available.",
+    parameters: Type.Object({
+      action: Type.String({ enum: ["new", "navigate", "focus", "close", "reload", "back", "forward"] }),
+      url: Type.Optional(Type.String({ description: "URL for new or navigate actions." })),
+      tabId: Type.Optional(Type.String({ description: "Target tab id for existing-tab actions." })),
+      active: Type.Optional(Type.Boolean({ description: "Whether a new tab should become active. Default true." })),
+    }),
+    execute: async (_id, params) => safeToolJson(() => callBrowserDaemon({ stateRoot, method: "open", params })),
+  });
+}
+
+function browserReadTool(stateRoot) {
+  return defineTool({
+    name: "browser_read",
+    label: "Browser Read",
+    description: "Read content from a specific browser tab. Defaults to visible text and interactive elements; can include HTML.",
+    parameters: Type.Object({
+      tabId: Type.String({ description: "Target tab id from browser_tabs or browser_open." }),
+      include: Type.Optional(Type.Object({
+        text: Type.Optional(Type.Boolean()),
+        html: Type.Optional(Type.Boolean()),
+        elements: Type.Optional(Type.Boolean()),
+      })),
+    }),
+    execute: async (_id, params) => safeToolJson(() => callBrowserDaemon({ stateRoot, method: "read", params })),
+  });
+}
+
+function browserScriptTool(stateRoot) {
+  return defineTool({
+    name: "browser_script",
+    label: "Browser Script",
+    description: "Execute arbitrary JavaScript in a specific browser tab. The code may return a JSON-serializable value or a Promise.",
+    parameters: Type.Object({
+      tabId: Type.String({ description: "Target tab id from browser_tabs or browser_open." }),
+      code: Type.String({ description: "JavaScript function body. Use return to send a result back." }),
+      awaitPromise: Type.Optional(Type.Boolean({ description: "Await a returned Promise. Default true." })),
+      timeoutMs: Type.Optional(Type.Number({ description: "Request timeout in milliseconds. Default 30000." })),
+    }),
+    execute: async (_id, params) => safeToolJson(() => callBrowserDaemon({
+      stateRoot,
+      method: "script",
+      params,
+      timeoutMs: params.timeoutMs ?? 30000,
+    })),
+  });
+}
+
+async function safeToolJson(run) {
+  try {
+    return toolJson(await run());
+  } catch (err) {
+    return toolJson({ ok: false, error: err.message }, { error: true });
+  }
+}
+
+function toolJson(payload, details = {}) {
+  return toolText(JSON.stringify(payload, null, 2), details);
+}

package/src/cli/args.mjs

@@ -28,7 +28,7 @@ export function parseCliArgs(argv) {
     allowPositionals: true,
   });
 
-  const commandName = ["login", "provider", "websearch", "memory"].includes(positionals[0]) ? positionals[0] : null;
+  const commandName = ["login", "provider", "websearch", "memory", "browser"].includes(positionals[0]) ? positionals[0] : null;
 
   return {
     command: commandName ? { name: commandName, args: positionals.slice(1) } : null,
@@ -70,6 +70,9 @@ Usage:
   march memory add <url>
   march memory list
   march memory remove <name>
+  march browser install    Install the developer browser extension
+  march browser status     Show browser daemon/extension status
+  march browser restart    Restart the browser daemon
 
 Options:
   -m, --model <id>     Initial model ID override

package/src/cli/commands/help-command.mjs

@@ -1,6 +1,6 @@
 export function formatHelpLines() {
   return [
-    "Commands: /new, /exit, /help, /hotkeys, /templates, /export jsonl, /export html, /export gist <jsonl|html>, /settings, /extensions, /providers, /providers <name>, /model, /models, /session, /status, /shell, /shell spawn [name], /save, /name, /copy, /mouse",
+    "Commands: /new, /exit, /help, /hotkeys, /templates, /export jsonl, /export html, /export gist <jsonl|html>, /settings, /extensions, /providers, /providers <name>, /model, /models, /session, /status, /shell, /shell spawn [name], /save, /name, /copy",
     "Sessions: /session opens previous sessions and restores the selected one.",
     "Shortcuts: Tab = toggle Do/Discuss, Esc = abort turn, Ctrl+C = abort turn / press twice to exit when idle, Ctrl+O = toggle tool output, Alt+S = shell pane, Alt+N = next shell, Alt+K/J = shell scroll, PageUp/PageDown = output scroll, Ctrl+G = external editor, Shift+Tab = thinking selector, Ctrl+T = thinking selector, Ctrl+L = model selector",
   ];

package/src/cli/fallback-ui.mjs

@@ -58,7 +58,6 @@ export function createJsonUI() {
     getInputText: () => "",
     insertTextAtCursor: () => {},
     openExternalEditor: () => {},
-    toggleMouse: () => false,
     toggleToolOutput: () => false,
     requestExit: () => {},
     close: () => {},
@@ -148,7 +147,6 @@ export function createPlainUI() {
     getInputText: () => "",
     insertTextAtCursor: () => {},
     openExternalEditor: () => {},
-    toggleMouse: () => false,
     toggleToolOutput: () => false,
     requestExit: () => {},
     close: () => {},

package/src/cli/input/autocomplete.mjs

@@ -14,7 +14,6 @@ const MARCH_COMMANDS = [
   { name: "copy", description: "Copy last assistant response to clipboard" },
   { name: "thinking", description: "Open thinking selector" },
   { name: "thinking list", description: "List available thinking levels" },
-  { name: "mouse", description: "Toggle mouse wheel and TUI selection copy" },
   { name: "hotkeys", description: "Show keyboard shortcuts and input prefixes" },
   { name: "templates", description: "List project prompt templates" },
   { name: "export jsonl", description: "Export current session turns as JSONL" },

package/src/cli/slash-commands.mjs

@@ -105,12 +105,6 @@ export async function handleSlashCommand(trimmed, {
     return { handled: true };
   }
 
-  if (trimmed === "/mouse") {
-    const on = ui.toggleMouse();
-    ui.writeln(on ? "Mouse tracking: ON (wheel scroll and TUI selection copy enabled)" : "Mouse tracking: OFF (native terminal selection enabled)");
-    return { handled: true };
-  }
-
   if (trimmed === "/status") {
     for (const line of statusCommand({
       runner,
@@ -145,6 +139,11 @@ export async function handleSlashCommand(trimmed, {
     return { handled: true };
   }
 
+  if (trimmed === "/mouse") {
+    ui.writeln("Mouse selection is always enabled.");
+    return { handled: true };
+  }
+
   const sessionSourceCommand = await handleSessionSourceCommand(trimmed, {
     ui,
     runner,

package/src/cli/tui/input/mouse-selection-controller.mjs

@@ -44,8 +44,7 @@ export function createMouseSelectionController({
   }
 
   return {
-    handleMouseInput(data, mouseOn) {
-      if (!mouseOn) return undefined;
+    handleMouseInput(data) {
       const mouse = parseMouseEvent(data);
       if (mouse?.type === "scroll") {
         if (shellDrawer.isVisible?.() && mouse.col > Math.floor((terminal.columns || 80) * 0.64)) {
@@ -76,7 +75,7 @@ export function createMouseSelectionController({
 
     handleCopyKey(data) {
       if (data !== "\x03") return undefined;
-      const text = selection.text();
+      const text = selection.copyText?.() ?? selection.text();
       if (!text) return undefined;
       selection.clear();
       copySelectionText(text);

package/src/cli/tui/layout/main-pane-layout.mjs

@@ -18,11 +18,12 @@ export class MainPaneLayout {
     const fixedHeight = statusTopLines.length + editorLines.length + statusBottomLines.length;
     const viewportHeight = Math.max(1, (this.terminal?.rows || 30) - fixedHeight);
     this.output.setViewportHeight(viewportHeight);
-    const outputLines = this.output.render(safeWidth);
+    const outputView = this.output.renderSelectable?.(safeWidth) ?? { lines: this.output.render(safeWidth), copyText: null };
+    const outputLines = outputView.lines;
     const outputTop = Math.max(0, viewportHeight - outputLines.length);
     const editorTop = viewportHeight + statusTopLines.length;
     this.selection?.setRegions?.([
-      { id: "output", topRow: outputTop, leftCol: 0, width: safeWidth, lines: outputLines },
+      { id: "output", topRow: outputTop, leftCol: 0, width: safeWidth, lines: outputLines, copyText: outputView.copyText },
       { id: "editor", topRow: editorTop, leftCol: 0, width: safeWidth, lines: editorLines },
     ]);
     const selectedOutputLines = this.selection?.applyRegion?.("output", outputLines) ?? outputLines;

package/src/cli/tui/output/selectable-copy.mjs

@@ -0,0 +1,107 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { marked } from "marked";
+import { renderMarkdown } from "../markdown-renderer.mjs";
+
+export function appendSelectableEntries(entries, block, lines, width) {
+  if (block.type !== "markdown") {
+    for (const line of lines) entries.push({ line, source: null, codeSource: null, baseRow: entries.length });
+    return;
+  }
+  const source = { kind: "markdown", text: block.text, startRow: entries.length, endRow: entries.length + lines.length - 1 };
+  const fragmentRanges = renderedFragmentRanges(block.text, width, entries.length);
+  for (const line of lines) {
+    const baseRow = entries.length;
+    const fragmentSource = fragmentRanges.find((range) => baseRow >= range.startRow && baseRow <= range.endRow) ?? null;
+    const codeSource = fragmentSource?.kind === "code" ? fragmentSource : null;
+    entries.push({ line, source, codeSource, fragmentSource, baseRow });
+  }
+}
+
+export function sliceEntriesWithTail(baseEntries, tailLine, range) {
+  if (!range) return tailLine == null ? baseEntries : [...baseEntries, { line: tailLine, source: null, codeSource: null, baseRow: baseEntries.length }];
+  const { start, end } = range;
+  const visible = baseEntries.slice(start, Math.min(end, baseEntries.length));
+  if (tailLine != null && end > baseEntries.length) visible.push({ line: tailLine, source: null, codeSource: null, baseRow: baseEntries.length });
+  return visible;
+}
+
+export function copySourceTextForRange(entries, range) {
+  if (!range) return "";
+  const selected = trimEmptyBoundaryEntries(entries.slice(range.start.row, range.end.row + 1));
+  const codeText = copyCompleteCodeSource(selected, entries, range);
+  if (codeText) return codeText;
+  const fragmentText = copyCompleteFragmentSource(selected, entries, range);
+  if (fragmentText) return fragmentText;
+  if (!selected.length || selected.some((entry) => !entry.source)) return "";
+  const sources = uniqueSources(selected, "source");
+  if (!sources.length || !sources.every((source) => sourceIsFullySelected(source, entries, range, "source"))) return "";
+  return sources.map((source) => source.text).join("\n\n");
+}
+
+function trimEmptyBoundaryEntries(entries) {
+  let start = 0;
+  let end = entries.length;
+  while (start < end && !entries[start].source && stripAnsi(entries[start].line).trim() === "") start += 1;
+  while (end > start && !entries[end - 1].source && stripAnsi(entries[end - 1].line).trim() === "") end -= 1;
+  return entries.slice(start, end);
+}
+
+function uniqueSources(entries, key) {
+  const result = [];
+  for (const entry of entries) {
+    const source = entry[key];
+    if (!source || result.includes(source)) continue;
+    result.push(source);
+  }
+  return result;
+}
+
+function copyCompleteCodeSource(selected, entries, range) {
+  if (!selected.length || selected.some((entry) => !entry.codeSource)) return "";
+  const sources = uniqueSources(selected, "codeSource");
+  if (sources.length !== 1 || !sourceIsFullySelected(sources[0], entries, range, "codeSource")) return "";
+  return sources[0].text;
+}
+
+function copyCompleteFragmentSource(selected, entries, range) {
+  if (!selected.length || selected.some((entry) => !entry.fragmentSource)) return "";
+  const sources = uniqueSources(selected, "fragmentSource");
+  if (sources.length !== 1 || !sourceIsFullySelected(sources[0], entries, range, "fragmentSource")) return "";
+  return sources[0].text;
+}
+
+function sourceIsFullySelected(source, entries, range, key) {
+  const startIndex = entries.findIndex((entry) => entry[key] === source && entry.baseRow === source.startRow);
+  const endIndex = entries.findLastIndex((entry) => entry[key] === source && entry.baseRow === source.endRow);
+  if (startIndex < 0 || endIndex < 0) return false;
+  if (range.start.row > startIndex || range.end.row < endIndex) return false;
+  const lastLine = stripAnsi(entries[endIndex]?.line ?? "");
+  const coversStart = range.start.row < startIndex || range.start.col <= 0;
+  const coversEnd = range.end.row > endIndex || range.end.col >= visibleWidth(lastLine);
+  return coversStart && coversEnd;
+}
+
+function renderedFragmentRanges(markdown, width, baseRow) {
+  let tokens = [];
+  try { tokens = marked.lexer(String(markdown ?? "")); } catch { return []; }
+  let row = baseRow;
+  const ranges = [];
+  for (const token of tokens) {
+    const raw = token.raw ?? token.text ?? "";
+    const lineCount = renderMarkdown(raw, width).length;
+    const range = sourceRangeForToken(token, raw, row, lineCount);
+    if (range) ranges.push(range);
+    row += lineCount;
+  }
+  return ranges;
+}
+
+function sourceRangeForToken(token, raw, row, lineCount) {
+  if (token.type === "code") return { kind: "code", text: String(token.text ?? ""), startRow: row, endRow: row + lineCount - 1 };
+  if (token.type === "table") return { kind: "table", text: String(raw).trimEnd(), startRow: row, endRow: row + lineCount - 1 };
+  return null;
+}
+
+function stripAnsi(text) {
+  return String(text ?? "").replace(/\x1b(?:\][^\x07]*(?:\x07|\x1b\\)|\[[0-?]*[ -/]*[@-~]|[@-Z\\-_])/g, "");
+}