march-cli 0.1.13 → 0.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "march-cli",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "March CLI — terminal-native coding agent with context reconstruction",
   "type": "module",
   "main": "./src/main.mjs",
@@ -14,6 +14,7 @@
   "scripts": {
     "dev": "cd .. && node march-cli/bin/march.mjs",
     "test": "node test/smoke.test.mjs",
+    "test:fast": "node test/fast.test.mjs",
     "test:real": "npm run test:shell-runtime-real && npm run test:shell-tui-real && npm run test:tui-key-real",
     "test:shell-runtime-real": "node test/shell-real-runtime.acceptance.mjs",
     "test:shell-tui-real": "node test/shell-tui-real.acceptance.mjs",

package/src/agent/command-exec-tool.mjs

@@ -6,6 +6,8 @@ import { toolText } from "./tool-result.mjs";
 import { stripAnsi } from "../text/ansi.mjs";
 
 const OUTPUT_LIMIT = 64 * 1024;
+const DEFAULT_COMMAND_TIMEOUT_SECONDS = 60;
+const COMMAND_KILL_GRACE_MS = 1000;
 
 export function createCommandExecTool({ cwd }) {
   return defineTool({
@@ -15,13 +17,13 @@ export function createCommandExecTool({ cwd }) {
     parameters: Type.Object({
       command: Type.String({ description: "Command to execute" }),
       shell: Type.Optional(Type.String({ description: "auto (default), bash, or powershell" })),
-      timeout: Type.Optional(Type.Number({ description: "Timeout in seconds; default 60" })),
+      timeout: Type.Optional(Type.Number({ description: "Timeout in seconds; default 60", default: DEFAULT_COMMAND_TIMEOUT_SECONDS })),
     }),
-    execute: async (_toolCallId, params) => executeCommand({ cwd, ...params }),
+    execute: async (_toolCallId, params, signal) => executeCommand({ cwd, signal, ...params }),
   });
 }
 
-export async function executeCommand({ cwd, command, shell = "auto", timeout = 60, spawnImpl = spawn }) {
+export async function executeCommand({ cwd, command, shell = "auto", timeout = DEFAULT_COMMAND_TIMEOUT_SECONDS, signal, spawnImpl = spawn, killProcessTreeImpl = killProcessTree, forceSettleMs = COMMAND_KILL_GRACE_MS }) {
   let resolved;
   try {
     resolved = resolveCommandShell(shell);
@@ -29,14 +31,18 @@ export async function executeCommand({ cwd, command, shell = "auto", timeout = 6
     return toolText(`Error: ${err.message}`, { error: true });
   }
 
-  const timeoutMs = Math.max(1, Number(timeout) || 60) * 1000;
+  const timeoutSeconds = Math.max(0.001, Number(timeout) || DEFAULT_COMMAND_TIMEOUT_SECONDS);
+  const timeoutMs = timeoutSeconds * 1000;
   const result = await spawnCommand(spawnImpl, resolved.bin, [...resolved.args, String(command ?? "")], {
     cwd,
     timeoutMs,
+    signal,
     windowsHide: true,
+    killProcessTreeImpl,
+    forceSettleMs,
   });
   if (result.error) {
-    const detail = result.timedOut ? ` (timed out after ${timeout}s)` : "";
+    const detail = result.timedOut ? ` (timed out after ${timeoutSeconds}s)` : "";
     return toolText(`Error: ${result.error.message}${detail}`, { error: true });
   }
   const stdout = stripAnsi(result.stdout ?? "");
@@ -57,12 +63,23 @@ function spawnCommand(spawnImpl, bin, args, options) {
     let stderr = "";
     let settled = false;
     let timedOut = false;
-    const child = spawnImpl(bin, args, { cwd: options.cwd, windowsHide: options.windowsHide });
+    let aborted = false;
+    let forceTimer = null;
+    const child = spawnImpl(bin, args, {
+      cwd: options.cwd,
+      windowsHide: options.windowsHide,
+      detached: process.platform !== "win32",
+    });
     const timer = setTimeout(() => {
       timedOut = true;
-      child.kill?.("SIGTERM");
+      terminateChild(new Error("Command timed out"));
     }, options.timeoutMs);
-    timer.unref?.();
+    const onAbort = () => {
+      aborted = true;
+      terminateChild(new Error("Command aborted"));
+    };
+    if (options.signal?.aborted) queueMicrotask(onAbort);
+    else options.signal?.addEventListener?.("abort", onAbort, { once: true });
 
     child.stdout?.setEncoding?.("utf8");
     child.stderr?.setEncoding?.("utf8");
@@ -71,16 +88,42 @@ function spawnCommand(spawnImpl, bin, args, options) {
     child.once?.("error", (error) => finish({ error }));
     child.once?.("close", (status, signal) => finish({ status, signal }));
 
+    function terminateChild(error) {
+      if (settled) return;
+      options.killProcessTreeImpl?.(child);
+      forceTimer ??= setTimeout(() => finish({ error }), options.forceSettleMs);
+    }
+
     function finish(result) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      const error = result.error ?? (timedOut ? Object.assign(new Error("Command timed out"), { code: "ETIMEDOUT" }) : null);
-      resolve({ ...result, error, stdout, stderr, timedOut });
+      clearTimeout(forceTimer);
+      options.signal?.removeEventListener?.("abort", onAbort);
+      const error = result.error ?? (timedOut ? Object.assign(new Error("Command timed out"), { code: "ETIMEDOUT" }) : null) ?? (aborted ? Object.assign(new Error("Command aborted"), { code: "ABORT_ERR" }) : null);
+      resolve({ ...result, error, stdout, stderr, timedOut, aborted });
     }
   });
 }
 
+function killProcessTree(child, platform = process.platform) {
+  if (!child?.pid) {
+    child?.kill?.("SIGTERM");
+    return;
+  }
+  if (platform === "win32") {
+    try {
+      spawnSync("taskkill", ["/PID", String(child.pid), "/T", "/F"], { windowsHide: true, stdio: "ignore", timeout: 5000 });
+      return;
+    } catch {}
+  }
+  try {
+    process.kill(-child.pid, "SIGTERM");
+    return;
+  } catch {}
+  child.kill?.("SIGTERM");
+}
+
 function appendLimited(current, chunk) {
   const next = current + String(chunk ?? "");
   return next.length <= OUTPUT_LIMIT ? next : next.slice(-OUTPUT_LIMIT);

package/src/agent/{read-file-tool.mjs → file-tools/read-file-tool.mjs}

@@ -2,7 +2,7 @@ import { readFileSync, readdirSync, statSync } from "node:fs";
 import { resolve } from "node:path";
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { toolText } from "./tool-result.mjs";
+import { toolText } from "../tool-result.mjs";
 
 const DEFAULT_LIMIT = 30;
 const DEFAULT_DIRECTORY_LIMIT = 200;
@@ -47,7 +47,7 @@ export function readFileSlice({ engine, path, offset = 1, limit = DEFAULT_LIMIT
   const count = clampLimit(limit);
   const selected = lines.slice(start - 1, start - 1 + count);
   const end = start + selected.length - 1;
-  const body = selected.map((line, index) => `${start + index} | ${line}`).join("\n");
+  const body = selected.map((line, index) => `${start + index}| ${line}`).join("\n");
   const header = `--- ${absPath} (lines ${start}-${end} of ${lines.length}) ---`;
   const remaining = lines.length - end;
   const footer = remaining > 0 ? `\n\n[${remaining} more lines in file. Use offset=${end + 1} to continue.]` : "";

package/src/agent/file-tools/read-image-tool.mjs

@@ -0,0 +1,76 @@
+import { readFileSync, statSync } from "node:fs";
+import { extname } from "node:path";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { currentModelImageInputError } from "../vision-capability.mjs";
+const IMAGE_MIME_BY_EXT = new Map([
+  [".png", "image/png"],
+  [".jpg", "image/jpeg"],
+  [".jpeg", "image/jpeg"],
+  [".webp", "image/webp"],
+  [".gif", "image/gif"],
+]);
+
+export function createReadImageTool({ engine, getCurrentModel = null }) {
+  return defineTool({
+    name: "read_image",
+    label: "Read Image",
+    description: "Read a local image file and send it to the model as an image attachment. Supports png, jpg/jpeg, webp, and gif.",
+    parameters: Type.Object({
+      path: Type.String({ description: "Absolute or relative path to the image file" }),
+    }),
+    execute: async (_toolCallId, params) => {
+      const capabilityError = currentModelImageInputError(getCurrentModel);
+      if (capabilityError) return imageError(capabilityError, { unsupportedModel: true });
+      return readImageFile({ engine, ...params });
+    },
+  });
+}
+
+export function readImageFile({ engine, path }) {
+  const absPath = engine.resolvePath(path);
+  let stat;
+  try {
+    stat = statSync(absPath);
+  } catch (err) {
+    return imageError(`Error reading image ${absPath}: ${err.message}`, { path: absPath });
+  }
+  if (stat.isDirectory()) {
+    return imageError(`Error reading image ${absPath}: this is a directory. Use ls(path) or find(pattern, path) to inspect it.`, { path: absPath, isDirectory: true });
+  }
+
+  const mimeType = IMAGE_MIME_BY_EXT.get(extname(absPath).toLowerCase());
+  if (!mimeType) {
+    return imageError(`Error reading image ${absPath}: unsupported image type. Supported types: png, jpg, jpeg, webp, gif.`, { path: absPath });
+  }
+
+  let data;
+  try {
+    data = readFileSync(absPath).toString("base64");
+  } catch (err) {
+    return imageError(`Error reading image ${absPath}: ${err.message}`, { path: absPath });
+  }
+
+  const size = formatSize(stat.size);
+  return {
+    content: [
+      { type: "text", text: `Read image file: ${absPath}\nMIME: ${mimeType}\nSize: ${size}` },
+      { type: "image", data, mimeType },
+    ],
+    details: {
+      path: absPath,
+      mimeType,
+      sizeBytes: stat.size,
+    },
+  };
+}
+
+function imageError(text, details = {}) {
+  return { content: [{ type: "text", text }], details: { ...details, error: true } };
+}
+
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}

package/src/agent/runner.mjs

@@ -52,14 +52,11 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
   const engine = new ContextEngine({ cwd, modelId, provider, namespace, memoryRoot, profilePaths, shellRuntime, lspService, injections: mcpInjections, maxTurns, trimBatch });
   const resolvedSessionManager = resolveRunnerSessionManager(cwd, sessionManager);
   const sessionBinding = createSessionBinding(null);
-  let currentModelCallKind = "model", currentTurnId = null;
-  let currentPromptForContext = "";
+  let currentModelCallKind = "model", currentTurnId = null, currentPromptForContext = "";
   let currentTurnContextMode = "rebuild";
   let nextTurnContextMode = "rebuild";
   let pendingMidTurnRecallHints = [];
-  let lastNotificationResult = null;
-  let runtimeHost = null;
-  let lifecycleAdapter = null;
+  let lastNotificationResult = null, runtimeHost = null, lifecycleAdapter = null;
   let _currentFastEntry = null;
   if (useRuntimeHost) {
     runtimeHost = await createRunnerRuntimeHost({
@@ -83,6 +80,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
       cwd, provider, modelId, modelRegistry, engine, ui: runtimeUi,
       memoryTools, shellRuntime, lspService, mcpTools, webTools, permissionController,
       authStorage: resolvedAuth, projectMarchDir,
+      getCurrentModel: () => sessionBinding.get()?.model ?? selectedModel,
     });
     const { session } = await createAgentSessionImpl({
       cwd, agentDir: stateRoot, ...sessionOptions,
@@ -226,10 +224,12 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
     getExtensionDiagnostics() { return runtimeHost?.getDiagnostics?.() ?? []; },
     getExtensionLifecycleState() { return lifecycleAdapter.getState(); },
     getLspStatus() { return lspService.snapshot(); },
-    async switchPiSession(sessionPath) {
+    async switchPiSession(sessionPath, restoreState = null) {
       if (!runtimeHost) throw new Error("pi runtime host is not enabled");
       nextTurnContextMode = "rebuild";
-      return runtimeHost.switchSession(sessionPath);
+      const result = await runtimeHost.switchSession(sessionPath);
+      if (!result?.cancelled && restoreState) engine.restoreSession(restoreState, null, { replace: true });
+      return result;
     },
     cycleThinkingLevel() {
       const level = sessionBinding.get().cycleThinkingLevel();

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

@@ -30,7 +30,7 @@ export function createRemoteRunnerClient(peer, { initialState = null } = {}) {
     getExtensionDiagnostics: () => state?.extensionDiagnostics ?? [],
     getExtensionLifecycleState: () => state?.extensionLifecycleState ?? null,
     getLspStatus: () => state?.lspStatus ?? null,
-    async switchPiSession(sessionPath) { return applyResultWithState(await peer.call("switchPiSession", sessionPath)); },
+    async switchPiSession(sessionPath, restoreState = null) { return applyResultWithState(await peer.call("switchPiSession", sessionPath, restoreState)); },
     async cycleThinkingLevel() { return applyResultWithState(await peer.call("cycleThinkingLevel")); },
     getThinkingLevel: () => state?.engine?.thinkingLevel ?? null,
     async setThinkingLevel(level) { return applyResultWithState(await peer.call("setThinkingLevel", level)); },

package/src/agent/runtime/runner-ipc-target.mjs

@@ -67,8 +67,8 @@ export function createRunnerIpcTarget({ createRunnerImpl, runnerOptions = {} } =
     getLspStatus() {
       return getRunner().getLspStatus();
     },
-    async switchPiSession(sessionPath) {
-      const result = await getRunner().switchPiSession(sessionPath);
+    async switchPiSession(sessionPath, restoreState = null) {
+      const result = await getRunner().switchPiSession(sessionPath, restoreState);
       return { result, state: getRunnerState(runner) };
     },
     cycleThinkingLevel() {
@@ -123,4 +123,3 @@ export function getRunnerState(runner) {
     extensionLifecycleState: runner.getExtensionLifecycleState?.() ?? null,
   };
 }
-

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

@@ -62,6 +62,7 @@ export async function createRunnerRuntimeHost({
         authStorage,
         projectMarchDir,
         hostedTools,
+        getCurrentModel: () => sessionBinding.get()?.model ?? null,
       });
     },
   });

package/src/agent/screen-tools/list-windows-tool.mjs

@@ -0,0 +1,39 @@
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { listWindowsWindows } from "./windows-screen.mjs";
+
+export function createListWindowsTool({ listWindowsImpl = listWindowsWindows } = {}) {
+  return defineTool({
+    name: "list_windows",
+    label: "List Windows",
+    description: "List visible desktop windows so the model can choose a windowId for screen({ target: 'window', windowId }).",
+    parameters: Type.Object({
+      limit: Type.Optional(Type.Number({ description: "Maximum windows to return; default 30" })),
+    }),
+    execute: async (_toolCallId, params = {}) => listWindowsTool({ listWindowsImpl, ...params }),
+  });
+}
+
+export function listWindowsTool({ listWindowsImpl = listWindowsWindows, limit = 30 } = {}) {
+  const result = listWindowsImpl();
+  if (!result?.ok) return textResult(`Error listing windows: ${result?.message || "unknown error"}`, { error: true });
+  const windows = (result.windows ?? []).slice(0, normalizeLimit(limit));
+  if (windows.length === 0) return textResult("No visible windows found.", { windows: [] });
+  const lines = ["Visible windows:"];
+  for (const item of windows) {
+    const process = item.process ? ` (${item.process})` : "";
+    const bounds = item.bounds ? ` ${item.bounds.width}x${item.bounds.height}+${item.bounds.x},${item.bounds.y}` : "";
+    const minimized = item.minimized ? " minimized" : "";
+    lines.push(`- ${item.id}${process}${bounds}${minimized}: ${item.title}`);
+  }
+  lines.push("Use screen({ target: 'window', windowId }) to capture a listed window.");
+  return textResult(lines.join("\n"), { windows });
+}
+
+function normalizeLimit(limit) {
+  return Number.isFinite(limit) && limit > 0 ? Math.min(Math.floor(limit), 100) : 30;
+}
+
+function textResult(text, details = {}) {
+  return { content: [{ type: "text", text }], details };
+}

package/src/agent/screen-tools/screen-tool.mjs

@@ -0,0 +1,49 @@
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { currentModelImageInputError } from "../vision-capability.mjs";
+import { captureScreenWindows } from "./windows-screen.mjs";
+
+export function createScreenTool({ getCurrentModel = null, captureScreenImpl = captureScreenWindows } = {}) {
+  return defineTool({
+    name: "screen",
+    label: "Screen Capture",
+    description: "Capture the current desktop or a visible window and send it to the model as an image attachment.",
+    parameters: Type.Object({
+      target: Type.Optional(Type.String({ description: "desktop (default) or window" })),
+      windowId: Type.Optional(Type.String({ description: "Window id from list_windows when target is window" })),
+    }),
+    execute: async (_toolCallId, params = {}) => captureScreenTool({ getCurrentModel, captureScreenImpl, ...params }),
+  });
+}
+
+export function captureScreenTool({ getCurrentModel = null, captureScreenImpl = captureScreenWindows, target = "desktop", windowId = null } = {}) {
+  const capabilityError = currentModelImageInputError(getCurrentModel);
+  if (capabilityError) return screenError(capabilityError, { unsupportedModel: true });
+  const normalizedTarget = target === "window" ? "window" : "desktop";
+  const result = captureScreenImpl({ target: normalizedTarget, windowId });
+  if (!result?.ok) return screenError(`Error capturing screen: ${result?.message || "unknown error"}`, { target: normalizedTarget, windowId });
+
+  const bounds = result.bounds ?? {};
+  const label = normalizedTarget === "window" ? `window ${result.windowId || windowId}` : "desktop";
+  return {
+    content: [
+      { type: "text", text: `Captured ${label} screenshot\nMIME: ${result.mimeType || "image/png"}\nBounds: ${formatBounds(bounds)}` },
+      { type: "image", data: result.data, mimeType: result.mimeType || "image/png" },
+    ],
+    details: {
+      target: normalizedTarget,
+      windowId: result.windowId ?? windowId ?? undefined,
+      bounds,
+      mimeType: result.mimeType || "image/png",
+    },
+  };
+}
+
+function screenError(text, details = {}) {
+  return { content: [{ type: "text", text }], details: { ...details, error: true } };
+}
+
+function formatBounds(bounds) {
+  const { x = 0, y = 0, width = 0, height = 0 } = bounds ?? {};
+  return `${width}x${height} at ${x},${y}`;
+}

package/src/agent/screen-tools/windows-screen.mjs

@@ -0,0 +1,133 @@
+import { execFileSync } from "node:child_process";
+
+const POWERSHELL = process.env.SystemRoot ? `${process.env.SystemRoot}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe` : "powershell.exe";
+const MAX_BUFFER = 80 * 1024 * 1024;
+
+export function listWindowsWindows() {
+  return runJson(LIST_WINDOWS_SCRIPT);
+}
+
+export function captureScreenWindows({ target = "desktop", windowId = null } = {}) {
+  if (target === "window") {
+    if (!windowId) return { ok: false, message: "windowId is required when target is window" };
+    return runJson(CAPTURE_WINDOW_SCRIPT.replace("__WINDOW_ID__", escapePowershellString(windowId)));
+  }
+  return runJson(CAPTURE_DESKTOP_SCRIPT);
+}
+
+function runJson(script) {
+  if (process.platform !== "win32") return { ok: false, message: `screen tools are not supported on ${process.platform}` };
+  try {
+    const output = execFileSync(POWERSHELL, ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", script], {
+      encoding: "utf8",
+      maxBuffer: MAX_BUFFER,
+      windowsHide: true,
+    }).trim();
+    return JSON.parse(output);
+  } catch (err) {
+    return { ok: false, message: `failed to run Windows screen capture: ${err.stderr || err.message}` };
+  }
+}
+
+function escapePowershellString(value) {
+  return String(value).replaceAll("'", "''");
+}
+
+const WIN32_TYPE = String.raw`
+using System;
+using System.Text;
+using System.Runtime.InteropServices;
+public static class MarchWin32 {
+  public delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
+  [StructLayout(LayoutKind.Sequential)] public struct RECT { public int Left; public int Top; public int Right; public int Bottom; }
+  [DllImport("user32.dll")] public static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);
+  [DllImport("user32.dll")] public static extern bool IsWindowVisible(IntPtr hWnd);
+  [DllImport("user32.dll")] public static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int count);
+  [DllImport("user32.dll")] public static extern int GetWindowTextLength(IntPtr hWnd);
+  [DllImport("user32.dll")] public static extern bool GetWindowRect(IntPtr hWnd, out RECT rect);
+  [DllImport("user32.dll")] public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint processId);
+  [DllImport("user32.dll")] public static extern bool IsIconic(IntPtr hWnd);
+}
+`;
+
+const LIST_WINDOWS_SCRIPT = String.raw`
+Add-Type -TypeDefinition @'
+${WIN32_TYPE}
+'@
+$items = New-Object System.Collections.Generic.List[object]
+[MarchWin32]::EnumWindows({ param($hwnd, $lparam)
+  if (-not [MarchWin32]::IsWindowVisible($hwnd)) { return $true }
+  $length = [MarchWin32]::GetWindowTextLength($hwnd)
+  if ($length -le 0) { return $true }
+  $builder = New-Object System.Text.StringBuilder ($length + 1)
+  [void][MarchWin32]::GetWindowText($hwnd, $builder, $builder.Capacity)
+  $rect = New-Object MarchWin32+RECT
+  if (-not [MarchWin32]::GetWindowRect($hwnd, [ref]$rect)) { return $true }
+  $width = $rect.Right - $rect.Left
+  $height = $rect.Bottom - $rect.Top
+  if ($width -le 0 -or $height -le 0) { return $true }
+  $pidValue = 0
+  [void][MarchWin32]::GetWindowThreadProcessId($hwnd, [ref]$pidValue)
+  $processName = $null
+  try { $processName = (Get-Process -Id $pidValue -ErrorAction Stop).ProcessName } catch {}
+  $items.Add([ordered]@{
+    id = ("0x{0:x}" -f $hwnd.ToInt64())
+    title = $builder.ToString()
+    process = $processName
+    pid = $pidValue
+    bounds = [ordered]@{ x = $rect.Left; y = $rect.Top; width = $width; height = $height }
+    minimized = [MarchWin32]::IsIconic($hwnd)
+  }) | Out-Null
+  return $true
+}, [IntPtr]::Zero) | Out-Null
+[ordered]@{ ok = $true; windows = $items } | ConvertTo-Json -Compress -Depth 5
+`;
+
+const CAPTURE_DESKTOP_SCRIPT = String.raw`
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+$bounds = [System.Windows.Forms.SystemInformation]::VirtualScreen
+$bitmap = New-Object System.Drawing.Bitmap $bounds.Width, $bounds.Height
+$graphics = [System.Drawing.Graphics]::FromImage($bitmap)
+$graphics.CopyFromScreen($bounds.Left, $bounds.Top, 0, 0, $bounds.Size)
+$stream = New-Object System.IO.MemoryStream
+$bitmap.Save($stream, [System.Drawing.Imaging.ImageFormat]::Png)
+$graphics.Dispose(); $bitmap.Dispose()
+[ordered]@{
+  ok = $true; data = [Convert]::ToBase64String($stream.ToArray()); mimeType = "image/png";
+  target = "desktop"; bounds = [ordered]@{ x = $bounds.Left; y = $bounds.Top; width = $bounds.Width; height = $bounds.Height }
+} | ConvertTo-Json -Compress -Depth 5
+`;
+
+const CAPTURE_WINDOW_SCRIPT = String.raw`
+Add-Type -AssemblyName System.Drawing
+Add-Type -TypeDefinition @'
+${WIN32_TYPE}
+'@
+$rawId = '__WINDOW_ID__'
+$hex = $rawId -replace '^0x',''
+try { $hwnd = [IntPtr]::new([Convert]::ToInt64($hex, 16)) } catch {
+  [ordered]@{ ok = $false; message = "invalid windowId: $rawId" } | ConvertTo-Json -Compress; exit 0
+}
+if ([MarchWin32]::IsIconic($hwnd)) {
+  [ordered]@{ ok = $false; message = "window is minimized and cannot be captured" } | ConvertTo-Json -Compress; exit 0
+}
+$rect = New-Object MarchWin32+RECT
+if (-not [MarchWin32]::GetWindowRect($hwnd, [ref]$rect)) {
+  [ordered]@{ ok = $false; message = "window not found: $rawId" } | ConvertTo-Json -Compress; exit 0
+}
+$width = $rect.Right - $rect.Left; $height = $rect.Bottom - $rect.Top
+if ($width -le 0 -or $height -le 0) {
+  [ordered]@{ ok = $false; message = "window has empty bounds: $rawId" } | ConvertTo-Json -Compress; exit 0
+}
+$bitmap = New-Object System.Drawing.Bitmap $width, $height
+$graphics = [System.Drawing.Graphics]::FromImage($bitmap)
+$graphics.CopyFromScreen($rect.Left, $rect.Top, 0, 0, (New-Object System.Drawing.Size $width, $height))
+$stream = New-Object System.IO.MemoryStream
+$bitmap.Save($stream, [System.Drawing.Imaging.ImageFormat]::Png)
+$graphics.Dispose(); $bitmap.Dispose()
+[ordered]@{
+  ok = $true; data = [Convert]::ToBase64String($stream.ToArray()); mimeType = "image/png";
+  target = "window"; windowId = $rawId; bounds = [ordered]@{ x = $rect.Left; y = $rect.Top; width = $width; height = $height }
+} | ConvertTo-Json -Compress -Depth 5
+`;

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

@@ -17,6 +17,7 @@ export function resolveRunnerSessionOptions({
   permissionController = null,
   authStorage = null,
   projectMarchDir = null,
+  getCurrentModel = null,
 }) {
   if (engine.cwd !== cwd) {
     throw new Error(`Runtime session cwd mismatch: engine=${engine.cwd}, session=${cwd}`);
@@ -28,7 +29,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 });
+  const customTools = createMarchCustomTools({ cwd, engine, ui, memoryTools, shellRuntime, lspService, mcpTools, webTools, permissionController, authStorage, projectMarchDir, getCurrentModel: () => getCurrentModel?.() ?? model });
   const customToolNames = customTools.map((tool) => tool.name);
   const tools = [
     ...customToolNames.filter((name) => name === "read"),

package/src/agent/tools.mjs

@@ -1,22 +1,29 @@
-import { defineTool } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
 import { createCommandExecTool } from "./command-exec-tool.mjs";
 import { createContextStatsTool } from "./context-stats-tool.mjs";
 import { createEditFileTool } from "./file-edit-tool.mjs";
-import { createReadFileTool } from "./read-file-tool.mjs";
+import { createReadFileTool } from "./file-tools/read-file-tool.mjs";
+import { createReadImageTool } from "./file-tools/read-image-tool.mjs";
+import { createScreenTool } from "./screen-tools/screen-tool.mjs";
+import { createListWindowsTool } from "./screen-tools/list-windows-tool.mjs";
 import { toolText } from "./tool-result.mjs";
 import { createShellTools } from "../shell/tools.mjs";
-import { createWebTools } from "../web/tools.mjs";
 import { initImageGen } from "../image-gen/index.mjs";
 import { createSuperGrokTool } from "../supergrok/tool.mjs";
-export function createMarchCustomTools({ cwd, engine, ui, memoryTools = [], shellRuntime = null, lspService = null, mcpTools = [], webTools = [], permissionController = null, authStorage = null, projectMarchDir = null }) {
+
+export function createMarchCustomTools({ cwd, engine, ui, memoryTools = [], shellRuntime = null, lspService = null, mcpTools = [], webTools = [], permissionController = null, authStorage = null, projectMarchDir = null, getCurrentModel = null }) {
   const commandExecTool = createCommandExecTool({ cwd });
   const contextStatsTool = createContextStatsTool({ engine });
   const editFileTool = createEditFileTool({ engine, ui, lspService });
   const readFileTool = createReadFileTool({ engine });
+  const readImageTool = createReadImageTool({ engine, getCurrentModel });
+  const screenTool = createScreenTool({ getCurrentModel });
+  const listWindowsTool = createListWindowsTool();
 
   const tools = [
     readFileTool,
+    readImageTool,
+    screenTool,
+    listWindowsTool,
     contextStatsTool,
     commandExecTool,
     editFileTool,
@@ -33,7 +40,7 @@ export function createMarchCustomTools({ cwd, engine, ui, memoryTools = [], shel
   return tools.map((tool) => {
     const execute = tool.execute;
     if (!execute) return tool;
-    const wrapped = async (toolCallId, params) => {
+    const wrapped = async (toolCallId, params, signal, onUpdate) => {
       const decision = await permissionController.requestApproval(
         tool.name,
         params,
@@ -44,7 +51,7 @@ export function createMarchCustomTools({ cwd, engine, ui, memoryTools = [], shel
       if (decision.behavior === "deny") {
         return toolText(`Permission denied: ${decision.message}`, { error: true, permissionDenied: true });
       }
-      return execute(toolCallId, params);
+      return execute(toolCallId, params, signal, onUpdate);
     };
     return { ...tool, execute: wrapped };
   });

package/src/agent/vision-capability.mjs

@@ -0,0 +1,14 @@
+export function modelSupportsImageInput(model) {
+  if (!model || typeof model !== "object") return false;
+  if (Array.isArray(model.input) && model.input.includes("image")) return true;
+  if (model.capabilities?.images === true || model.capabilities?.vision === true) return true;
+  return false;
+}
+
+export function currentModelImageInputError(getCurrentModel) {
+  if (typeof getCurrentModel !== "function") return null;
+  const model = getCurrentModel();
+  if (modelSupportsImageInput(model)) return null;
+  const label = model ? `${model.name || model.id || "unknown"} (${model.provider || "unknown provider"})` : "unknown";
+  return `Current model does not support image input: ${label}. Switch to a vision-capable model before using read_image or screen.`;
+}

package/src/cli/args.mjs

@@ -11,6 +11,8 @@ export function parseCliArgs(argv) {
       extension: { type: "string", short: "e", multiple: true },
       extension: { type: "string", short: "e", multiple: true },
       config: { type: "boolean" },
+      "include-key": { type: "boolean" },
+      "profile-only": { type: "boolean" },
       "dump-context": { type: "boolean" },
       "pi-sessions": { type: "boolean" },
       "pi-runtime-host": { type: "boolean" },
@@ -33,6 +35,8 @@ export function parseCliArgs(argv) {
     extensions: values.extension ?? [],
     dumpContext: values["dump-context"] ?? false,
     providerConfig: values.config ?? false,
+    includeKey: values["include-key"] ?? false,
+    profileOnly: values["profile-only"] ?? false,
     piSessions: values["pi-sessions"] ?? false,
     piRuntimeHost: values["pi-runtime-host"] ?? false,
     shellRuntime: values["no-shell-runtime"] ? false : true,
@@ -50,6 +54,8 @@ Usage:
   march [options]            (starts REPL)
   march login [provider]     Login to an OAuth provider
   march provider --config    Configure provider credentials
+  march provider share [id]  Share a provider profile
+  march provider accept <token>
   march websearch --config  Configure web search credentials
 
 Options:
@@ -58,6 +64,8 @@ Options:
   --resume <id>        Resume a pi session by default
   --json               JSON output mode (no TUI)
   --config             With provider/websearch command, open configuration
+  --include-key        With provider share, include API key
+  --profile-only       With provider share, omit API key
   --dump-context       Write every prompt sent to the model under .march/context-dumps/
   --pi-sessions        Force pi JSONL SessionManager persistence
   --pi-runtime-host    Force pi AgentSessionRuntime host path