local-commander-agent 0.3.6 → 0.3.7

package/README.md

@@ -19,8 +19,8 @@ Use **Windows 11 x64** and a currently supported Node.js LTS version meeting the
    ```
 
 2. The installer opens a browser. Sign in to [Local Commander](https://localcmd.app), check the displayed pairing code, and approve this computer. Approve only a pairing you just started yourself.
-3. Choose filesystem access in the local Windows dialog:
-   - **All connected drives — read and write:** approve all currently available drive letters shown in the dialog at once. There is no folder picker or separate approval for each drive.
+3. Choose access in the local Windows dialog:
+   - **Full access - all connected drives (default):** approve the available drive letters, file reads/writes, installed commands and localhost services at once. There is no folder picker or separate approval for Node.
    - **Selected folders:** choose one folder in the folder picker. It starts read/write; more folders and write permission can be added later.
 
    Cancel leaves existing permissions unchanged. On first setup, cancellation stops before enabling autostart or starting the agent. Existing grants are preserved when repeating installation or updating: an update never opts you into all drives.
@@ -34,11 +34,13 @@ Use **Windows 11 x64** and a currently supported Node.js LTS version meeting the
 
 You can close the installation terminal. The agent runs in the background and starts when this Windows user signs in. The PC must be awake and online for remote AI tasks. As a first test, ask the connected assistant to list the files in a folder you approved.
 
+Installation and update also add `localcommander` to your Windows **user PATH**. Open a new CMD/terminal window, then run `localcommander status`, `localcommander monitor --watch`, or `localcommander logs --follow` from any folder. No global npm installation is needed. The launcher uses your required Node.js installation and an installed copy of the CLI, so clearing npm's cache does not remove the command. Fetch newer releases with `npx local-commander-agent@latest update`. Uninstall removes Local Commander's PATH entry and launcher while preserving your other entries.
+
 ## What “all connected drives” means
 
 It expands the **filesystem scope** to the drive letters shown at the moment you consent. It includes available local fixed and removable drives. Mapped network drives and `subst` letters are not included. New drive letters, unavailable drives and unmounted volumes are not automatically added; run `configure-access` again after making the desired drive available. Grants are path/drive-letter based, not tied to a particular removable disk's hardware identity: reusing an approved letter gives access under that letter.
 
-This is not administrator access or an unrestricted shell. Windows permissions, protected Local Commander state/runtime and secret-file filters still apply to file tools. Direct command execution and localhost ports remain separately controlled. Read/write access is powerful: an assistant may read personal documents or change accessible files, and writing startup items, scripts or Git hooks can make programs run later as you. Treat drive-wide write access like permission to run programs. Folder controls are not an OS sandbox for an executable you separately allow. ChatGPT/Claude or your workspace may still ask for their own action confirmations.
+Full access allows installed commands resolved from absolute owner PATH entries or an absolute executable path, plus localhost services. Explicit command/port denials and write restrictions still apply. It does not elevate Windows privileges. Protected Local Commander state/runtime and secret-file filters apply to file tools; programs run with your Windows account's rights, so these controls are not an OS sandbox. ChatGPT/Claude or your workspace may still ask for their own action confirmations. Existing installations keep their current permissions until the owner runs `configure-access` and selects full access using a release that supports it.
 
 ## Manage the installation
 
@@ -72,7 +74,7 @@ npx local-commander-agent@latest workspaces
 npx local-commander-agent@latest revoke-workspace <workspaceGrantId>
 ```
 
-`configure-access` reopens the all-drives/selected-folder choice. **It replaces the current set of filesystem grants and clears their command and localhost permissions.** Choosing a restricted folder actually removes the old broader grants. `approve-workspace` adds another read/write folder without replacing the existing set. `workspaces` shows the grant IDs and permissions to use with the other commands. A successful change restarts an already-running agent to synchronize grants; cancellation does not restart it. A revoked drive is not silently re-added in the background.
+`configure-access` reopens the full-access/selected-folder choice. **It replaces current grants and their restrictions.** Full access enables commands and localhost by default; selected folders start read/write with separate command/port allowlists. Choosing a restricted folder removes old broader grants. `approve-workspace` adds another read/write folder without replacing the existing set. `workspaces` shows grant IDs, full/scoped mode and explicit denials. A successful change restarts an already-running agent to synchronize grants; cancellation does not restart it. A revoked drive is not silently re-added in the background.
 
 To enable or remove individual capabilities, replace the placeholders with a grant ID from `workspaces` and an executable path that actually exists on your PC:
 
@@ -86,7 +88,11 @@ npx local-commander-agent@latest deny-command <workspaceGrantId> node
 npx local-commander-agent@latest deny-localhost <workspaceGrantId> 3000
 ```
 
-`allow-command` associates an exact executable with the name the assistant uses; it does not accept a shell command string. Capability changes are local owner actions, not MCP settings the assistant can silently widen. The all-drives decision always requires the local dialog; there is no `--yes` or environment flag to approve it.
+`allow-command` associates an exact executable with the name the assistant uses; it does not accept a shell command string. Capability changes are local owner actions, not MCP settings the assistant can silently widen. The all-drives decision always requires the local dialog; there is no `--yes` or environment flag to approve it.
+
+Under full access, `deny-command` and `deny-localhost` exclude the named command or port while other commands/ports remain available. Native `.exe`/`.com` commands receive argument arrays directly. `.cmd`/`.bat` launchers use a hidden PowerShell wrapper and reject cmd metacharacters in arguments; use an explicit interpreter for more complex scripts. Allowing a general interpreter is not containment against it launching a denied program.
+
+The MCP discovery sequence is `workspace_list`, `diagnostics`, `execution_session_open`, requested work, output/status, then session close. Diagnostics reports quota separately from the device's execution slot limit. Its optional `repairSafe` mode releases only expired reservations from this OAuth connection that never acquired a dispatch lease. It never retries work, changes permissions or clears unknown executions.
 
 ## Troubleshooting
 
@@ -114,3 +120,21 @@ npx local-commander-agent@latest
 ```
 
 Enrollment retains the chosen origin. Changing this variable does not move an already paired device or turn the package into a standalone MCP server. Account/device enrollment, OAuth, the control plane and relay are still required.
+
+## Monitor the production connection from CMD
+
+After installing an agent release with monitoring support, run these commands from any CMD window:
+
+```cmd
+npx local-commander-agent@latest monitor
+npx local-commander-agent@latest monitor --watch
+npx local-commander-agent@latest logs --follow
+```
+
+If the CLI is already on PATH, use `localcommander monitor --watch` or `localcommander logs --follow`. `monitor --json` returns a machine-readable snapshot; `logs` prints recent events once. Ctrl+C exits a live view without stopping the agent. These commands only read local monitoring files; they do not install, pair, restart, dispatch cloud work or consume execution quota.
+
+The view lists this Windows user's reporting production-agent instances, process IDs, agent versions, enrolled server origin, relay connection state and recently observed execution sessions. A live process with a snapshot older than ten seconds is **stale**, not connected. An execution session is not an independently identified AI agent. **Model names are unavailable** because the current production relay does not transmit them.
+
+Each instance retains its last 100 connection/tool events and 32 recently observed sessions in `%LOCALAPPDATA%\LocalCommander\Monitor`. Logs show timestamps, tool names, result codes and session/execution IDs. They exclude credentials, command arguments, file paths, request bodies and tool output. The monitor refreshes every two seconds. `logs --follow` reports a gap if the bounded history is overwritten between reads. Last snapshots remain available after a stop; a new run replaces that state directory's snapshot.
+
+An older installed agent produces no monitoring snapshot even if it is running; the CLI reports that monitoring is unavailable. Publishing/installing the updated agent is required before these views can report its connection. The existing `status` command remains available for installation and process state.

package/bin/command-path.mjs

@@ -0,0 +1,102 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+const SHIM_MARKER = "@rem Local Commander managed command\r\n";
+const CLI_FILES = ["package.json", "bin/localcommander.mjs", "bin/monitor.mjs", "bin/command-path.mjs"];
+
+export function commandShim(version) {
+  if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(version)) throw Error("PACKAGE_VERSION_INVALID");
+  return SHIM_MARKER + '@echo off\r\nsetlocal DisableDelayedExpansion\r\nnode "%~dp0..\\Versions\\' + version +
+    '\\bin\\localcommander.mjs" %*\r\nexit /b %errorlevel%\r\n';
+}
+
+async function plainDirectory(directory) {
+  await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+  const stat = await fs.lstat(directory);
+  if (!stat.isDirectory() || stat.isSymbolicLink()) throw Error("INSTALL_DIRECTORY_INVALID");
+}
+async function regularOrMissing(file) {
+  const stat = await fs.lstat(file).catch(error => { if (error.code !== "ENOENT") throw error; });
+  if (stat && (!stat.isFile() || stat.isSymbolicLink())) throw Error("INSTALL_STATE_INVALID");
+}
+
+export async function installCommandFiles(packageRoot, installRoot, version) {
+  const shim = commandShim(version);
+  const runtime = path.join(installRoot, "Versions", version);
+  const bin = path.join(installRoot, "bin");
+  for (const directory of [installRoot, path.join(installRoot, "Versions"), runtime, path.join(runtime, "bin"), bin]) await plainDirectory(directory);
+  for (const file of CLI_FILES) {
+    const source = path.join(packageRoot, file), target = path.join(runtime, file);
+    await regularOrMissing(source);
+    await regularOrMissing(target);
+    if (path.resolve(source).toLowerCase() !== path.resolve(target).toLowerCase()) await fs.copyFile(source, target);
+  }
+  const target = path.join(bin, "localcommander.cmd");
+  await regularOrMissing(target);
+  const previous = await fs.readFile(target, "utf8").catch(error => { if (error.code !== "ENOENT") throw error; });
+  if (previous !== undefined && !previous.startsWith(SHIM_MARKER)) throw Error("COMMAND_SHIM_CONFLICT");
+  await fs.writeFile(target, shim, { mode: 0o600 });
+  return bin;
+}
+
+export async function removeCommandFile(installRoot) {
+  for (const directory of [installRoot, path.join(installRoot, "bin")]) {
+    const stat = await fs.lstat(directory).catch(error => { if (error.code !== "ENOENT") throw error; });
+    if (!stat) return;
+    if (!stat.isDirectory() || stat.isSymbolicLink()) throw Error("INSTALL_DIRECTORY_INVALID");
+  }
+  const file = path.join(installRoot, "bin", "localcommander.cmd");
+  await regularOrMissing(file);
+  const content = await fs.readFile(file, "utf8").catch(error => { if (error.code !== "ENOENT") throw error; });
+  if (content?.startsWith(SHIM_MARKER)) await fs.unlink(file);
+}
+
+// Read the registry's raw value so %VARIABLE% entries and its value type survive.
+export const USER_PATH_SCRIPT = String.raw`
+$ErrorActionPreference = 'Stop'
+$target = $env:LC_COMMAND_BIN
+$remove = $env:LC_COMMAND_PATH_REMOVE -eq '1'
+$key = [Microsoft.Win32.Registry]::CurrentUser.CreateSubKey('Environment')
+try {
+  $raw = $key.GetValue('Path', '', [Microsoft.Win32.RegistryValueOptions]::DoNotExpandEnvironmentNames)
+  if ($raw -isnot [string]) { throw 'USER_PATH_INVALID' }
+  $kind = [Microsoft.Win32.RegistryValueKind]::ExpandString
+  if ($key.GetValueNames() -contains 'Path') { $kind = $key.GetValueKind('Path') }
+  if ($kind -ne [Microsoft.Win32.RegistryValueKind]::String -and $kind -ne [Microsoft.Win32.RegistryValueKind]::ExpandString) { throw 'USER_PATH_INVALID' }
+  $entries = $raw.Split(';')
+  $kept = @($entries | Where-Object {
+    $expanded = [Environment]::ExpandEnvironmentVariables($_.Trim().Trim('"')).Replace('/', '\').TrimEnd('\')
+    -not [string]::Equals($expanded, $target.TrimEnd('\'), [StringComparison]::OrdinalIgnoreCase)
+  })
+  $next = $raw
+  if ($remove) { $next = [string]::Join(';', $kept) }
+  elseif ($kept.Count -eq $entries.Count) {
+    $separator = if ($raw.Length -gt 0 -and -not $raw.EndsWith(';')) { ';' } else { '' }
+    $next = $raw + $separator + $target
+  }
+  if ($next.Length -gt 32766) { throw 'USER_PATH_TOO_LONG' }
+  if ($next -cne $raw) { $key.SetValue('Path', $next, $kind) }
+} finally { $key.Dispose() }
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+public static class LocalCommanderEnvironment {
+  [DllImport("user32.dll", CharSet=CharSet.Unicode, SetLastError=true)]
+  public static extern IntPtr SendMessageTimeout(IntPtr window, uint message, IntPtr word, string value, uint flags, uint timeout, out UIntPtr result);
+}
+'@
+$result = [UIntPtr]::Zero
+[void][LocalCommanderEnvironment]::SendMessageTimeout([IntPtr]0xffff, 0x1a, [IntPtr]::Zero, 'Environment', 2, 1000, [ref]$result)
+Write-Output 'USER_PATH_READY'
+`;
+
+export function updateUserPath(bin, remove = false) {
+  if (!path.isAbsolute(bin) || /[;"\r\n\0]/.test(bin)) throw Error("COMMAND_PATH_INVALID");
+  const result = spawnSync(path.join(process.env.SystemRoot || "C:\\Windows", "System32/WindowsPowerShell/v1.0/powershell.exe"),
+    ["-NoLogo", "-NoProfile", "-NonInteractive", "-EncodedCommand", Buffer.from(USER_PATH_SCRIPT, "utf16le").toString("base64")], {
+      windowsHide: true, encoding: "utf8", timeout: 15_000,
+      env: { ...process.env, LC_COMMAND_BIN: bin, LC_COMMAND_PATH_REMOVE: remove ? "1" : "0" }
+    });
+  if (result.error || result.status !== 0 || result.stdout.trim() !== "USER_PATH_READY") throw Error("USER_PATH_UPDATE_FAILED");
+}

package/bin/localcommander.mjs

@@ -5,6 +5,8 @@ import path from "node:path";
 import { randomBytes } from "node:crypto";
 import { spawn, spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
+import { runMonitor } from "./monitor.mjs";
+import { installCommandFiles, removeCommandFile, updateUserPath } from "./command-path.mjs";
 
 const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const PACKAGE_META = JSON.parse(await fs.readFile(path.join(PACKAGE_ROOT, "package.json"), "utf8"));
@@ -43,6 +45,7 @@ function currentPath() {
   return path.join(appDataRoot(), "current.json");
 }
 function runtimeSource() {
+  if (PACKAGE_ROOT.toLowerCase() === path.join(versionsDirectory(), VERSION).toLowerCase()) return PACKAGE_ROOT;
   return path.join(PACKAGE_ROOT, "runtime");
 }
 function processFile() {
@@ -364,12 +367,17 @@ async function bootstrap({ chooseWorkspace = true } = {}) {
   }
   registerAutostart(runtimeDir);
   await startAgent();
+  const commandBin = await installCommandFiles(PACKAGE_ROOT, appDataRoot(), VERSION);
+  updateUserPath(commandBin);
   if (previous && previous.version !== VERSION) process.stdout.write("Updated Local Commander from " + previous.version + " to " + VERSION + ".\n");
   process.stdout.write("Local Commander " + VERSION + " is installed and running.\n");
+  process.stdout.write("The localcommander command is on your user PATH. Open a new CMD or terminal window to use it.\n");
 }
 async function uninstall(purgeState) {
   await stopAgent();
   removeAutostart();
+  updateUserPath(path.join(appDataRoot(), "bin"), true);
+  await removeCommandFile(appDataRoot());
   const versions = versionsDirectory();
   if (under(appDataRoot(), versions)) await fs.rm(versions, { recursive: true, force: true });
   await fs.rm(currentPath(), { force: true });
@@ -388,6 +396,9 @@ function help() {
     "Usage:",
     "  npx local-commander-agent@latest              install/pair/start",
     "  npx local-commander-agent@latest status       show local state",
+    "  npx local-commander-agent@latest monitor --watch  production connection and sessions",
+    "  npx local-commander-agent@latest monitor --json   monitoring snapshot as JSON",
+    "  npx local-commander-agent@latest logs --follow    recent production relay events",
     "  npx local-commander-agent@latest start        start background agent",
     "  npx local-commander-agent@latest stop         stop background agent",
     "  npx local-commander-agent@latest restart      restart background agent",
@@ -447,6 +458,10 @@ async function main() {
     process.stdout.write(JSON.stringify(await statusObject(), null, 2) + "\n");
     return;
   }
+  if (command === "monitor" || command === "logs") {
+    await runMonitor(path.join(appDataRoot(), "Monitor"), command, args);
+    return;
+  }
   if (command === "configure-access") {
     if (args.length) fail("ARGUMENT_INVALID");
     const current = await readCurrent();

package/bin/monitor.mjs

@@ -0,0 +1,131 @@
+import { lstat, open, readdir } from "node:fs/promises";
+import path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const STATES = new Set(["starting", "connecting", "connected", "disconnected", "stopped", "failed"]);
+const EVENTS = new Set([...STATES, "execute", "prepare", "status", "output", "cancel", "finished", "cancelled", "unknown", "result", "request_failed", "rejected", "connection_error"]);
+const iso = value => typeof value === "string" && /^\d{4}-\d\d-\d\dT[\d:.]+Z$/.test(value) && Number.isFinite(Date.parse(value));
+const invalid = () => { throw Error("MONITOR_DATA_INVALID"); };
+function pidAlive(pid) {
+  try { process.kill(pid, 0); return true; }
+  catch (error) { return error?.code === "EPERM"; }
+}
+
+// Explicit allowlist projection: never print extra fields from a local file.
+export function monitorView(raw, now = Date.now(), alive = pidAlive) {
+  if (!raw || raw.schemaVersion !== 1 || !UUID.test(raw.instanceId) || !Number.isSafeInteger(raw.pid) || raw.pid <= 0 ||
+      typeof raw.agentVersion !== "string" || !/^[A-Za-z0-9._+-]{1,64}$/.test(raw.agentVersion) || !iso(raw.updatedAt) ||
+      !STATES.has(raw.connection?.state) || !Array.isArray(raw.sessions) || raw.sessions.length > 32 ||
+      !Array.isArray(raw.events) || raw.events.length > 100) invalid();
+  let origin = null;
+  if (raw.connection.origin !== null) {
+    const url = new URL(raw.connection.origin);
+    if (url.origin !== raw.connection.origin || url.username || url.password ||
+        !(url.protocol === "https:" || (url.protocol === "http:" && ["127.0.0.1", "localhost", "[::1]"].includes(url.hostname)))) invalid();
+    origin = url.origin;
+  }
+  const sessions = raw.sessions.map(session => {
+    if (!session || !UUID.test(session.sessionId) || !UUID.test(session.workspaceGrantId) || !iso(session.lastSeenAt)) invalid();
+    return { sessionId: session.sessionId, workspaceGrantId: session.workspaceGrantId, lastSeenAt: session.lastSeenAt, model: null };
+  });
+  const events = raw.events.map(event => {
+    if (!event || !Number.isSafeInteger(event.seq) || event.seq < 1 || !iso(event.at) || !EVENTS.has(event.event) ||
+        (event.sessionId !== undefined && !UUID.test(event.sessionId)) || (event.executionId !== undefined && !UUID.test(event.executionId)) ||
+        (event.tool !== undefined && (typeof event.tool !== "string" || !/^[a-z_]{1,64}$/.test(event.tool))) ||
+        (event.code !== undefined && (typeof event.code !== "string" || !/^[A-Z0-9_]{1,64}$/.test(event.code)))) invalid();
+    return { seq: event.seq, at: event.at, event: event.event,
+      ...(event.sessionId ? { sessionId: event.sessionId } : {}), ...(event.executionId ? { executionId: event.executionId } : {}),
+      ...(event.tool ? { tool: event.tool } : {}), ...(event.code ? { code: event.code } : {}) };
+  });
+  const running = alive(raw.pid);
+  const age = now - Date.parse(raw.updatedAt);
+  const connection = !running ? "stopped" : age < -5000 || age > 10_000 ? "stale" : raw.connection.state;
+  return { instanceId: raw.instanceId, pid: raw.pid, agentVersion: raw.agentVersion, updatedAt: raw.updatedAt,
+    running, connection, origin, sessions, events };
+}
+
+export async function readMonitors(directory) {
+  let entries;
+  try {
+    const stat = await lstat(directory);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) invalid();
+    entries = (await readdir(directory)).filter(name => /^[a-f0-9]{64}\.json$/.test(name));
+  } catch (error) {
+    if (error?.code === "ENOENT") return { instances: [], unavailable: 0 };
+    return { instances: [], unavailable: 1 };
+  }
+  const instances = [];
+  let unavailable = Math.max(0, entries.length - 32);
+  for (const name of entries.slice(0, 32)) {
+    try {
+      const file = path.join(directory, name);
+      const stat = await lstat(file);
+      if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 128 * 1024) invalid();
+      const handle = await open(file, "r");
+      let contents;
+      try {
+        const buffer = Buffer.alloc(128 * 1024 + 1);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        if (bytesRead > 128 * 1024) invalid();
+        contents = buffer.subarray(0, bytesRead).toString("utf8");
+      } finally { await handle.close(); }
+      instances.push(monitorView(JSON.parse(contents)));
+    } catch { unavailable++; }
+  }
+  instances.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  return { instances, unavailable };
+}
+
+function logLine(instance, event) {
+  return [event.at, "pid=" + instance.pid, event.event, event.tool, event.code,
+    event.sessionId && "session=" + event.sessionId, event.executionId && "execution=" + event.executionId].filter(Boolean).join(" ");
+}
+
+export function formatMonitor(result) {
+  const lines = ["Local Commander production monitor", ""];
+  if (!result.instances.length) lines.push("No monitoring snapshots. Start an agent version that supports monitoring; older agents need an update.");
+  for (const instance of result.instances) {
+    lines.push("PID " + instance.pid + " | v" + instance.agentVersion + " | " + instance.connection.toUpperCase(),
+      "Server: " + (instance.origin ?? "Not connected yet") + " | Updated: " + instance.updatedAt,
+      "Observed execution sessions (not AI instance identities): " + instance.sessions.length);
+    for (const session of instance.sessions) lines.push("  " + session.sessionId + " | model: unavailable | last seen: " + session.lastSeenAt);
+    lines.push("Recent events:", ...instance.events.slice(-10).map(event => "  " + logLine(instance, event)), "");
+  }
+  if (result.unavailable) lines.push("Unavailable or omitted snapshots: " + result.unavailable);
+  lines.push("Models are unavailable: production relay does not report AI model names.");
+  return lines.join("\n") + "\n";
+}
+
+export async function runMonitor(directory, command, args) {
+  const allowed = command === "logs" ? ["--follow"] : ["--watch", "--json"];
+  if (new Set(args).size !== args.length || args.some(arg => !allowed.includes(arg))) throw Error("ARGUMENT_INVALID");
+  const repeat = args.includes("--watch") || args.includes("--follow");
+  const stop = new AbortController();
+  const abort = () => stop.abort();
+  process.once("SIGINT", abort);
+  process.once("SIGTERM", abort);
+  const seen = new Map();
+  try {
+    do {
+      const result = await readMonitors(directory);
+      if (command === "logs" && result.instances.length) {
+        for (const instance of result.instances) {
+          const after = seen.get(instance.instanceId) ?? 0;
+          if (after && instance.events[0]?.seq > after + 1) process.stdout.write("Earlier events were overwritten in the 100-event buffer.\n");
+          for (const event of instance.events) if (event.seq > after) process.stdout.write(logLine(instance, event) + "\n");
+          seen.set(instance.instanceId, instance.events.at(-1)?.seq ?? after);
+        }
+        for (const key of seen.keys()) if (!result.instances.some(instance => instance.instanceId === key)) seen.delete(key);
+        if (result.unavailable) process.stderr.write("Some monitoring snapshots are unavailable.\n");
+      } else {
+        if (repeat && process.stdout.isTTY && !args.includes("--json")) console.clear();
+        process.stdout.write(args.includes("--json") ? JSON.stringify(result) + "\n" : formatMonitor(result));
+      }
+      if (repeat) await delay(2000, undefined, { signal: stop.signal }).catch(error => { if (error.name !== "AbortError") throw error; });
+    } while (repeat && !stop.signal.aborted);
+  } finally {
+    process.removeListener("SIGINT", abort);
+    process.removeListener("SIGTERM", abort);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-commander-agent",
-  "version": "0.3.6",
+  "version": "0.3.7",
   "description": "Windows companion for Local Commander: connect AI clients to local files, approved commands and localhost. Requires https://localcmd.app.",
   "type": "module",
   "bin": {