march-cli 0.1.27 → 0.1.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "march-cli",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "description": "March CLI — terminal-native coding agent with context reconstruction",
   "type": "module",
   "main": "./src/main.mjs",

package/src/agent/runner.mjs

@@ -81,7 +81,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
     });
   } else {
     const sessionOptions = resolveRunnerSessionOptions({
-      cwd, provider, modelId, modelRegistry, engine, ui: runtimeUi,
+      cwd, stateRoot, provider, modelId, modelRegistry, engine, ui: runtimeUi,
       memoryTools, shellRuntime, lspService, mcpTools, webTools, permissionController,
       authStorage: resolvedAuth, projectMarchDir,
       getCurrentModel: () => sessionBinding.get()?.model ?? selectedModel,

package/src/agent/runtime/remote-ui-client.mjs

@@ -13,7 +13,7 @@ export function createRemoteRuntimeUiClient(peer) {
     retryEnd: (event) => peer.notify("uiEvent", { type: "retry_end", ...event }),
     status: (text) => peer.notify("uiEvent", { type: "status", text }),
     debugLines: (lines) => peer.notify("uiEvent", { type: "debug_lines", lines }),
-    memoryHint: ({ source, hints }) => peer.notify("uiEvent", { type: "memory_hint", source, hints }),
+    recall: ({ source, hints }) => peer.notify("uiEvent", { type: "recall", source, hints }),
     editDiff: (path, diffLines) => peer.notify("uiEvent", { type: "edit_diff", path, diffLines }),
     requestPermission: (request) => peer.call("uiRequest", { type: "permission_request", ...request }),
   };

package/src/agent/runtime/runner-runtime-host.mjs

@@ -48,6 +48,7 @@ export async function createRunnerRuntimeHost({
       registerCustomProviders(activeModelRegistry, providers);
       return resolveRunnerSessionOptions({
         cwd: sessionCwd,
+        stateRoot,
         provider,
         modelId,
         modelRegistry: activeModelRegistry,

package/src/agent/runtime/ui-event-bridge.mjs

@@ -50,7 +50,7 @@ export function createRuntimeUiClient(eventBus) {
     retryEnd: (event) => eventBus.emit({ type: "retry_end", ...event }),
     status: (text) => eventBus.emit({ type: "status", text }),
     debugLines: (lines) => eventBus.emit({ type: "debug_lines", lines }),
-    memoryHint: ({ source, hints }) => eventBus.emit({ type: "memory_hint", source, hints }),
+    recall: ({ source, hints }) => eventBus.emit({ type: "recall", source, hints }),
     editDiff: (path, diffLines) => eventBus.emit({ type: "edit_diff", path, diffLines }),
     requestPermission: (request) => eventBus.request({ type: "permission_request", ...request }),
   };
@@ -71,7 +71,7 @@ export function dispatchRuntimeUiEvent(ui, event) {
     case "retry_end": return ui.retryEnd?.(pickRetryEnd(event));
     case "status": return ui.status?.(event.text);
     case "debug_lines": return writeDebugLines(ui, event.lines);
-    case "memory_hint": return ui.memoryHint?.({ source: event.source, hints: event.hints });
+    case "recall": return ui.recall?.({ source: event.source, hints: event.hints });
     case "edit_diff": return ui.editDiff?.(event.path, event.diffLines);
     case "permission_request": return ui.requestPermission?.({ toolName: event.toolName, params: event.params, category: event.category });
     default: return undefined;

package/src/agent/session/session-options.mjs

@@ -17,6 +17,7 @@ export function resolveRunnerSessionOptions({
   permissionController = null,
   authStorage = null,
   projectMarchDir = null,
+  stateRoot = null,
   getCurrentModel = null,
 }) {
   if (engine.cwd !== cwd) {
@@ -29,7 +30,7 @@ export function resolveRunnerSessionOptions({
     ?? (provider && modelId ? getModel(provider, modelId) : null);
   if (!model) throw new Error(`Model not found: ${provider}/${modelId}`);
 
-  const customTools = createMarchCustomTools({ cwd, engine, ui, memoryTools, shellRuntime, lspService, mcpTools, webTools, permissionController, authStorage, projectMarchDir, getCurrentModel: () => getCurrentModel?.() ?? model });
+  const customTools = createMarchCustomTools({ cwd, engine, ui, memoryTools, shellRuntime, lspService, mcpTools, webTools, permissionController, authStorage, projectMarchDir, stateRoot, getCurrentModel: () => getCurrentModel?.() ?? model });
   const customToolNames = customTools.map((tool) => tool.name);
   const tools = [
     ...customToolNames.filter((name) => name === "read"),

package/src/agent/tools.mjs

@@ -9,8 +9,9 @@ import { toolText } from "./tool-result.mjs";
 import { createShellTools } from "../shell/tools.mjs";
 import { initImageGen } from "../image-gen/index.mjs";
 import { createSuperGrokTool } from "../supergrok/tool.mjs";
+import { createBrowserTools } from "../browser/tools/index.mjs";
 
-export function createMarchCustomTools({ cwd, engine, ui, memoryTools = [], shellRuntime = null, lspService = null, mcpTools = [], webTools = [], permissionController = null, authStorage = null, projectMarchDir = null, getCurrentModel = null }) {
+export function createMarchCustomTools({ cwd, engine, ui, memoryTools = [], shellRuntime = null, lspService = null, mcpTools = [], webTools = [], permissionController = null, authStorage = null, projectMarchDir = null, stateRoot = null, getCurrentModel = null }) {
   const commandExecTool = createCommandExecTool({ cwd });
   const contextStatsTool = createContextStatsTool({ engine });
   const editFileTool = createEditFileTool({ engine, ui, lspService });
@@ -31,6 +32,7 @@ export function createMarchCustomTools({ cwd, engine, ui, memoryTools = [], shel
     ...memoryTools,
     ...mcpTools,
     ...webTools,
+    ...createBrowserTools({ stateRoot }),
     ...(authStorage ? [createSuperGrokTool({ authStorage, projectMarchDir })] : []),
     ...(authStorage ? initImageGen({ authStorage, projectMarchDir }) : []),
   ];

package/src/agent/turn/turn-runner.mjs

@@ -42,7 +42,7 @@ export async function runRunnerTurn({
       if (hints.length > 0) {
         midTurnRecallHints.push(...hints);
         queueMidTurnRecallHints(activeSession, hints, logger);
-        ui.memoryHint?.({ source: "assistant", hints });
+        ui.recall?.({ source: "assistant", hints });
       }
     }
   });
@@ -93,7 +93,7 @@ function queueMidTurnRecallHints(session, hints, logger) {
   const content = formatRecallHints("assistant", hints);
   if (!content) return;
   const injected = session.sendCustomMessage?.({
-    customType: "march.memory_hint",
+    customType: "march.recall",
     content,
     display: false,
     details: { source: "assistant" },

package/src/browser/cli/command.mjs

@@ -0,0 +1,61 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { ensureBrowserDaemon, stopBrowserDaemon } from "../client/lifecycle.mjs";
+import { readBrowserDaemonState } from "../client/state.mjs";
+import { requestBrowserDaemon } from "../client/http.mjs";
+import { installedBrowserExtensionPath, syncBrowserExtensionInstall } from "../extension-install.mjs";
+import { openBrowserUrl } from "./open-url.mjs";
+
+export async function runBrowserCommand(args, { stateRoot = join(homedir(), ".march") } = {}) {
+  const subcommand = args.command.args[0] ?? "status";
+  if (subcommand === "install") return await installBrowser({ stateRoot });
+  if (subcommand === "status") return await printStatus({ stateRoot });
+  if (subcommand === "restart") return await restartBrowserDaemon({ stateRoot });
+  if (subcommand === "daemon" && args.foreground) return await runForegroundDaemon({ stateRoot });
+  process.stderr.write("Usage: march browser install|status|restart\n");
+  return 1;
+}
+
+async function installBrowser({ stateRoot }) {
+  const extensionPath = syncBrowserExtensionInstall(stateRoot);
+  const state = await ensureBrowserDaemon({ stateRoot });
+  await openBrowserUrl("chrome://extensions");
+  process.stdout.write(`March Browser developer install\n\n`);
+  process.stdout.write(`1. Chrome extensions page opened: chrome://extensions\n`);
+  process.stdout.write(`2. Enable Developer mode.\n`);
+  process.stdout.write(`3. Click Load unpacked.\n`);
+  process.stdout.write(`4. Select this folder:\n   ${extensionPath}\n`);
+  process.stdout.write(`5. If the extension is already loaded, click its Reload button.\n\n`);
+  process.stdout.write(`Daemon: ${state.url}\n`);
+  process.stdout.write(`Extension WebSocket: ${state.wsUrl}\n`);
+  return await printStatus({ stateRoot });
+}
+
+async function printStatus({ stateRoot }) {
+  const state = readBrowserDaemonState(stateRoot);
+  try {
+    const status = await requestBrowserDaemon(state.url, "/status", null, { timeoutMs: 800 });
+    process.stdout.write(`Browser daemon: running pid=${status.pid}\n`);
+    process.stdout.write(`Browser extension: ${status.extensionConnected ? "connected" : "not connected"}\n`);
+    process.stdout.write(`Extension path: ${installedBrowserExtensionPath(stateRoot)}\n`);
+    return 0;
+  } catch {
+    process.stdout.write("Browser daemon: not running\n");
+    process.stdout.write(`Extension path: ${installedBrowserExtensionPath(stateRoot)}\n`);
+    return 0;
+  }
+}
+
+async function restartBrowserDaemon({ stateRoot }) {
+  await stopBrowserDaemon({ stateRoot });
+  await ensureBrowserDaemon({ stateRoot });
+  return await printStatus({ stateRoot });
+}
+
+async function runForegroundDaemon({ stateRoot }) {
+  const { createBrowserDaemonServer } = await import("../daemon/server.mjs");
+  const server = createBrowserDaemonServer({ stateRoot });
+  await server.start();
+  process.stdout.write(`Browser daemon foreground: ${readBrowserDaemonState(stateRoot).url}\n`);
+  return new Promise(() => {});
+}

package/src/browser/cli/open-url.mjs

@@ -0,0 +1,21 @@
+import { spawn } from "node:child_process";
+
+export function openBrowserUrl(url) {
+  return new Promise((resolve, reject) => {
+    const { command, args } = openUrlCommand(url);
+    const child = spawn(command, args, { detached: true, stdio: "ignore", windowsHide: true });
+    child.once("error", reject);
+    child.once("spawn", () => {
+      child.unref();
+      resolve();
+    });
+  });
+}
+
+function openUrlCommand(url) {
+  if (process.platform === "win32") {
+    return { command: "powershell.exe", args: ["-NoProfile", "-Command", "Start-Process $args[0]", url] };
+  }
+  if (process.platform === "darwin") return { command: "open", args: [url] };
+  return { command: "xdg-open", args: [url] };
+}

package/src/browser/client/http.mjs

@@ -0,0 +1,18 @@
+export async function requestBrowserDaemon(url, path, body = null, { timeoutMs = 5000 } = {}) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(`${url}${path}`, {
+      method: body ? "POST" : "GET",
+      headers: body ? { "content-type": "application/json" } : undefined,
+      body: body ? JSON.stringify(body) : undefined,
+      signal: controller.signal,
+    });
+    const text = await response.text();
+    const payload = text ? JSON.parse(text) : null;
+    if (!response.ok) throw new Error(payload?.error ?? `Browser daemon HTTP ${response.status}`);
+    return payload;
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/src/browser/client/lifecycle.mjs

@@ -0,0 +1,57 @@
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+import { readBrowserDaemonState, removeBrowserDaemonState } from "./state.mjs";
+import { requestBrowserDaemon } from "./http.mjs";
+
+export async function ensureBrowserDaemon({ stateRoot, quiet = true } = {}) {
+  const state = readBrowserDaemonState(stateRoot);
+  if (await pingBrowserDaemon(state.url)) return state;
+
+  removeBrowserDaemonState(stateRoot);
+  const child = spawn(process.execPath, [daemonEntryPath(), "--state-root", stateRoot], {
+    detached: true,
+    stdio: quiet ? "ignore" : "inherit",
+    windowsHide: true,
+  });
+  child.once("error", () => {});
+  child.unref();
+
+  const deadline = Date.now() + 4000;
+  let lastError = null;
+  while (Date.now() < deadline) {
+    await sleep(120);
+    try {
+      const next = readBrowserDaemonState(stateRoot);
+      if (await pingBrowserDaemon(next.url)) return next;
+    } catch (err) {
+      lastError = err;
+    }
+  }
+  throw new Error(`Browser daemon did not start${lastError ? `: ${lastError.message}` : ""}`);
+}
+
+export async function pingBrowserDaemon(url) {
+  try {
+    const status = await requestBrowserDaemon(url, "/status", null, { timeoutMs: 700 });
+    return Boolean(status?.ok);
+  } catch {
+    return false;
+  }
+}
+
+export async function stopBrowserDaemon({ stateRoot } = {}) {
+  const state = readBrowserDaemonState(stateRoot);
+  try {
+    await requestBrowserDaemon(state.url, "/shutdown", {}, { timeoutMs: 1500 });
+  } catch {}
+  removeBrowserDaemonState(stateRoot);
+}
+
+function daemonEntryPath() {
+  return resolve(dirname(fileURLToPath(import.meta.url)), "../daemon/entry.mjs");
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/browser/client/rpc.mjs

@@ -0,0 +1,8 @@
+import { ensureBrowserDaemon } from "./lifecycle.mjs";
+import { requestBrowserDaemon } from "./http.mjs";
+
+export async function callBrowserDaemon({ stateRoot, method, params = {}, timeoutMs = 30000 }) {
+  const state = await ensureBrowserDaemon({ stateRoot });
+  const response = await requestBrowserDaemon(state.url, "/rpc", { method, params, timeoutMs }, { timeoutMs: timeoutMs + 1000 });
+  return response.result;
+}

package/src/browser/client/state.mjs

@@ -0,0 +1,35 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { BROWSER_DAEMON_HOST, BROWSER_DAEMON_PORT, BROWSER_DAEMON_STATE_FILE } from "../daemon/constants.mjs";
+
+export function browserDaemonStatePath(stateRoot) {
+  return join(stateRoot, BROWSER_DAEMON_STATE_FILE);
+}
+
+export function defaultBrowserDaemonState() {
+  return {
+    pid: null,
+    url: `http://${BROWSER_DAEMON_HOST}:${BROWSER_DAEMON_PORT}`,
+    wsUrl: `ws://${BROWSER_DAEMON_HOST}:${BROWSER_DAEMON_PORT}/extension`,
+    startedAt: null,
+  };
+}
+
+export function readBrowserDaemonState(stateRoot) {
+  const path = browserDaemonStatePath(stateRoot);
+  if (!existsSync(path)) return defaultBrowserDaemonState();
+  try {
+    return { ...defaultBrowserDaemonState(), ...JSON.parse(readFileSync(path, "utf8")) };
+  } catch {
+    return defaultBrowserDaemonState();
+  }
+}
+
+export function writeBrowserDaemonState(stateRoot, state) {
+  mkdirSync(stateRoot, { recursive: true });
+  writeFileSync(browserDaemonStatePath(stateRoot), JSON.stringify(state, null, 2));
+}
+
+export function removeBrowserDaemonState(stateRoot) {
+  try { rmSync(browserDaemonStatePath(stateRoot), { force: true }); } catch {}
+}

package/src/browser/daemon/constants.mjs

@@ -0,0 +1,3 @@
+export const BROWSER_DAEMON_PORT = 4328;
+export const BROWSER_DAEMON_HOST = "127.0.0.1";
+export const BROWSER_DAEMON_STATE_FILE = "browser-daemon.json";

package/src/browser/daemon/entry.mjs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createBrowserDaemonServer } from "./server.mjs";
+
+const args = parseArgs(process.argv.slice(2));
+const stateRoot = args["state-root"] ?? join(homedir(), ".march");
+const server = createBrowserDaemonServer({ stateRoot });
+
+process.on("SIGTERM", () => server.shutdown().then(() => process.exit(0)));
+process.on("SIGINT", () => server.shutdown().then(() => process.exit(0)));
+
+try {
+  await server.start();
+} catch (err) {
+  process.stderr.write(`Browser daemon failed: ${err.message}\n`);
+  process.exitCode = 1;
+}
+
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    if (!argv[i].startsWith("--")) continue;
+    const key = argv[i].slice(2);
+    out[key] = argv[i + 1]?.startsWith("--") ? true : argv[++i];
+  }
+  return out;
+}

package/src/browser/daemon/server.mjs

@@ -0,0 +1,146 @@
+import { createServer } from "node:http";
+import WebSocket, { WebSocketServer } from "ws";
+import { BROWSER_DAEMON_HOST, BROWSER_DAEMON_PORT } from "./constants.mjs";
+import { writeBrowserDaemonState } from "../client/state.mjs";
+
+export function createBrowserDaemonServer({ stateRoot, port = BROWSER_DAEMON_PORT } = {}) {
+  const bridge = createExtensionBridge();
+  const server = createServer((req, res) => handleHttp(req, res, bridge, () => shutdown()));
+  const wss = new WebSocketServer({ noServer: true });
+
+  server.on("upgrade", (req, socket, head) => {
+    if (new URL(req.url, "http://localhost").pathname !== "/extension") {
+      socket.destroy();
+      return;
+    }
+    wss.handleUpgrade(req, socket, head, (ws) => bridge.attach(ws));
+  });
+
+  async function start() {
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(port, BROWSER_DAEMON_HOST, resolve);
+    });
+    const address = server.address();
+    const actualPort = typeof address === "object" ? address.port : port;
+    writeBrowserDaemonState(stateRoot, {
+      pid: process.pid,
+      url: `http://${BROWSER_DAEMON_HOST}:${actualPort}`,
+      wsUrl: `ws://${BROWSER_DAEMON_HOST}:${actualPort}/extension`,
+      startedAt: Date.now(),
+    });
+  }
+
+  async function shutdown() {
+    bridge.close();
+    wss.close();
+    await new Promise((resolve) => server.close(resolve));
+  }
+
+  return { start, shutdown, bridge };
+}
+
+function createExtensionBridge() {
+  let socket = null;
+  const pending = new Map();
+
+  function attach(ws) {
+    if (socket && socket.readyState === WebSocket.OPEN) socket.close();
+    socket = ws;
+    ws.on("message", (data) => handleExtensionMessage(data));
+    ws.on("close", () => {
+      if (socket === ws) socket = null;
+    });
+  }
+
+  async function request(method, params = {}, timeoutMs = 30000) {
+    if (!socket || socket.readyState !== WebSocket.OPEN) throw new Error("Browser extension is not connected. Run: march browser install");
+    const id = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+    const message = JSON.stringify({ id, method, params });
+    return await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        reject(new Error(`Browser extension request timed out: ${method}`));
+      }, timeoutMs);
+      pending.set(id, { resolve, reject, timer });
+      socket.send(message, (err) => {
+        if (!err) return;
+        clearTimeout(timer);
+        pending.delete(id);
+        reject(err);
+      });
+    });
+  }
+
+  function handleExtensionMessage(data) {
+    let msg;
+    try { msg = JSON.parse(String(data)); } catch { return; }
+    const entry = pending.get(msg.id);
+    if (!entry) return;
+    clearTimeout(entry.timer);
+    pending.delete(msg.id);
+    msg.ok === false ? entry.reject(new Error(formatExtensionError(msg.error))) : entry.resolve(msg.result);
+  }
+
+  function close() {
+    for (const [id, entry] of pending) {
+      clearTimeout(entry.timer);
+      entry.reject(new Error("Browser daemon is shutting down"));
+      pending.delete(id);
+    }
+    socket?.close();
+  }
+
+  return { attach, request, close, isConnected: () => Boolean(socket && socket.readyState === WebSocket.OPEN) };
+}
+
+async function handleHttp(req, res, bridge, shutdown) {
+  try {
+    const path = new URL(req.url, "http://localhost").pathname;
+    if (req.method === "GET" && path === "/status") {
+      return sendJson(res, 200, { ok: true, pid: process.pid, extensionConnected: bridge.isConnected() });
+    }
+    if (req.method === "POST" && path === "/rpc") {
+      const body = await readJson(req);
+      const result = await bridge.request(body.method, body.params, body.timeoutMs);
+      return sendJson(res, 200, { ok: true, result });
+    }
+    if (req.method === "POST" && path === "/shutdown") {
+      sendJson(res, 200, { ok: true });
+      setTimeout(() => shutdown().then(() => process.exit(0)), 10);
+      return;
+    }
+    sendJson(res, 404, { ok: false, error: "Not found" });
+  } catch (err) {
+    sendJson(res, 500, { ok: false, error: err.message });
+  }
+}
+
+function readJson(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => { body += chunk; });
+    req.on("end", () => {
+      try { resolve(body ? JSON.parse(body) : {}); } catch (err) { reject(err); }
+    });
+    req.on("error", reject);
+  });
+}
+
+function sendJson(res, status, payload) {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(payload));
+}
+
+export function formatExtensionError(error) {
+  if (!error) return "Browser extension request failed";
+  if (typeof error === "string") return error;
+  if (typeof error.stack === "string" && error.stack) return error.stack;
+  if (typeof error.message === "string" && error.message) return error.message;
+  if (error.message && typeof error.message === "object") return safeStringify(error.message);
+  return safeStringify(error);
+}
+
+function safeStringify(value) {
+  try { return JSON.stringify(value); } catch { return String(value); }
+}