march-cli 0.1.21 → 0.1.22

package/src/agent/runtime/ipc/ipc-peer.mjs

@@ -1,99 +1,99 @@
-const CHANNEL = "march-runtime";
-
-export function createRuntimeIpcPeer({ send, subscribe, target = {}, timeoutMs = 0 } = {}) {
-  if (typeof send !== "function") throw new Error("send is required");
-  if (typeof subscribe !== "function") throw new Error("subscribe is required");
-
-  let nextId = 1;
-  const pending = new Map();
-  const detach = subscribe((message) => handleMessage(message));
-
-  return {
-    call(method, ...args) {
-      const id = nextId++;
-      const result = waitForResult(id, { timeoutMs, pending });
-      send({ channel: CHANNEL, kind: "request", id, method, args });
-      return result;
-    },
-    notify(method, ...args) {
-      send({ channel: CHANNEL, kind: "notify", method, args });
-    },
-    dispose() {
-      detach?.();
-      for (const { reject, timer } of pending.values()) {
-        if (timer) clearTimeout(timer);
-        reject(new Error("runtime IPC peer disposed"));
-      }
-      pending.clear();
-    },
-  };
-
-  async function handleMessage(message) {
-    if (!isRuntimeMessage(message)) return;
-    if (message.kind === "result" || message.kind === "error") {
-      settlePending(message, pending);
-      return;
-    }
-    if (message.kind === "notify") {
-      await invokeTarget(message, target);
-      return;
-    }
-    if (message.kind === "request") {
-      try {
-        const result = await invokeTarget(message, target);
-        send({ channel: CHANNEL, kind: "result", id: message.id, result });
-      } catch (error) {
-        send({ channel: CHANNEL, kind: "error", id: message.id, error: serializeError(error) });
-      }
-    }
-  }
-}
-
-function waitForResult(id, { timeoutMs, pending }) {
-  return new Promise((resolve, reject) => {
-    const timer = timeoutMs > 0
-      ? setTimeout(() => {
-        pending.delete(id);
-        reject(new Error(`runtime IPC request timed out: ${id}`));
-      }, timeoutMs)
-      : null;
-    pending.set(id, { resolve, reject, timer });
-  });
-}
-
-function settlePending(message, pending) {
-  const entry = pending.get(message.id);
-  if (!entry) return;
-  pending.delete(message.id);
-  if (entry.timer) clearTimeout(entry.timer);
-  if (message.kind === "result") {
-    entry.resolve(message.result);
-  } else {
-    entry.reject(deserializeError(message.error));
-  }
-}
-
-async function invokeTarget(message, target) {
-  const method = target[message.method];
-  if (typeof method !== "function") throw new Error(`unknown runtime IPC method: ${message.method}`);
-  return method(...(message.args ?? []));
-}
-
-function isRuntimeMessage(message) {
-  return message?.channel === CHANNEL && typeof message.kind === "string";
-}
-
-function serializeError(error) {
-  return {
-    name: error?.name ?? "Error",
-    message: error?.message ?? String(error),
-    stack: error?.stack,
-  };
-}
-
-function deserializeError(error) {
-  const result = new Error(error?.message ?? "runtime IPC error");
-  result.name = error?.name ?? "Error";
-  if (error?.stack) result.stack = error.stack;
-  return result;
-}
+const CHANNEL = "march-runtime";
+
+export function createRuntimeIpcPeer({ send, subscribe, target = {}, timeoutMs = 0 } = {}) {
+  if (typeof send !== "function") throw new Error("send is required");
+  if (typeof subscribe !== "function") throw new Error("subscribe is required");
+
+  let nextId = 1;
+  const pending = new Map();
+  const detach = subscribe((message) => handleMessage(message));
+
+  return {
+    call(method, ...args) {
+      const id = nextId++;
+      const result = waitForResult(id, { timeoutMs, pending });
+      send({ channel: CHANNEL, kind: "request", id, method, args });
+      return result;
+    },
+    notify(method, ...args) {
+      send({ channel: CHANNEL, kind: "notify", method, args });
+    },
+    dispose() {
+      detach?.();
+      for (const { reject, timer } of pending.values()) {
+        if (timer) clearTimeout(timer);
+        reject(new Error("runtime IPC peer disposed"));
+      }
+      pending.clear();
+    },
+  };
+
+  async function handleMessage(message) {
+    if (!isRuntimeMessage(message)) return;
+    if (message.kind === "result" || message.kind === "error") {
+      settlePending(message, pending);
+      return;
+    }
+    if (message.kind === "notify") {
+      await invokeTarget(message, target);
+      return;
+    }
+    if (message.kind === "request") {
+      try {
+        const result = await invokeTarget(message, target);
+        send({ channel: CHANNEL, kind: "result", id: message.id, result });
+      } catch (error) {
+        send({ channel: CHANNEL, kind: "error", id: message.id, error: serializeError(error) });
+      }
+    }
+  }
+}
+
+function waitForResult(id, { timeoutMs, pending }) {
+  return new Promise((resolve, reject) => {
+    const timer = timeoutMs > 0
+      ? setTimeout(() => {
+        pending.delete(id);
+        reject(new Error(`runtime IPC request timed out: ${id}`));
+      }, timeoutMs)
+      : null;
+    pending.set(id, { resolve, reject, timer });
+  });
+}
+
+function settlePending(message, pending) {
+  const entry = pending.get(message.id);
+  if (!entry) return;
+  pending.delete(message.id);
+  if (entry.timer) clearTimeout(entry.timer);
+  if (message.kind === "result") {
+    entry.resolve(message.result);
+  } else {
+    entry.reject(deserializeError(message.error));
+  }
+}
+
+async function invokeTarget(message, target) {
+  const method = target[message.method];
+  if (typeof method !== "function") throw new Error(`unknown runtime IPC method: ${message.method}`);
+  return method(...(message.args ?? []));
+}
+
+function isRuntimeMessage(message) {
+  return message?.channel === CHANNEL && typeof message.kind === "string";
+}
+
+function serializeError(error) {
+  return {
+    name: error?.name ?? "Error",
+    message: error?.message ?? String(error),
+    stack: error?.stack,
+  };
+}
+
+function deserializeError(error) {
+  const result = new Error(error?.message ?? "runtime IPC error");
+  result.name = error?.name ?? "Error";
+  if (error?.stack) result.stack = error.stack;
+  return result;
+}

package/src/agent/runtime/ipc/process-ipc-transport.mjs

@@ -1,16 +1,16 @@
-import { createRuntimeIpcPeer } from "./ipc-peer.mjs";
-
-export function createProcessRuntimeIpcPeer({ processLike = process, target = {}, timeoutMs = 0 } = {}) {
-  return createRuntimeIpcPeer({
-    send: (message) => {
-      if (typeof processLike.send !== "function") throw new Error("process IPC send is unavailable");
-      processLike.send(message);
-    },
-    subscribe: (listener) => {
-      processLike.on("message", listener);
-      return () => processLike.off("message", listener);
-    },
-    target,
-    timeoutMs,
-  });
-}
+import { createRuntimeIpcPeer } from "./ipc-peer.mjs";
+
+export function createProcessRuntimeIpcPeer({ processLike = process, target = {}, timeoutMs = 0 } = {}) {
+  return createRuntimeIpcPeer({
+    send: (message) => {
+      if (typeof processLike.send !== "function") throw new Error("process IPC send is unavailable");
+      processLike.send(message);
+    },
+    subscribe: (listener) => {
+      processLike.on("message", listener);
+      return () => processLike.off("message", listener);
+    },
+    target,
+    timeoutMs,
+  });
+}

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

@@ -1,73 +1,73 @@
-export function createRemoteRunnerClient(peer, { initialState = null } = {}) {
-  let state = initialState;
-
-  const client = {
-    get engine() { return createEngineFacade(); },
-    get runtimeState() { return state; },
-    async init(options = {}) {
-      state = await peer.call("init", options);
-      return state;
-    },
-    async runTurn(prompt, userMessage, options = {}) {
-      const result = await peer.call("runTurn", prompt, userMessage, options);
-      await refreshState();
-      return result;
-    },
-    abort: () => peer.call("abort"),
-    async cycleModel() { return applyResultWithState(await peer.call("cycleModel")); },
-    async setModel(model) { return applyResultWithState(await peer.call("setModel", model)); },
-    getCurrentModel: () => state?.currentModel ?? null,
-    getScopedModels: () => state?.scopedModels ?? [],
-    getConfiguredProviders: () => state?.configuredProviders ?? [],
-    getSessionStats: () => state?.sessionStats ?? null,
-    async refreshState() { return refreshState(); },
-    getLastNotificationResult: () => peer.call("getLastNotificationResult"),
-    notifyTest: (options) => peer.call("notifyTest", options),
-    estimateContextTokens: (userMessage = "") => peer.call("estimateContextTokens", userMessage),
-    async setSessionName(name) { return applyResultWithState(await peer.call("setSessionName", name)); },
-    canSwitchPiSession: () => Boolean(state?.canSwitchPiSession),
-    async startNewSession() { return applyResultWithState(await peer.call("startNewSession")); },
-    getExtensionDiagnostics: () => state?.extensionDiagnostics ?? [],
-    getExtensionLifecycleState: () => state?.extensionLifecycleState ?? null,
-    getLspStatus: () => state?.lspStatus ?? null,
-    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)); },
-    getAvailableThinkingLevels: () => state?.availableThinkingLevels ?? [],
-    async dispose() {
-      await peer.call("dispose");
-      peer.dispose();
-    },
-  };
-
-  return client;
-
-  async function refreshState() {
-    state = await peer.call("getState");
-    return state;
-  }
-
-  function applyResultWithState(response) {
-    if (response && Object.hasOwn(response, "state")) {
-      state = response.state;
-      return response.result;
-    }
-    return response;
-  }
-
-  function createEngineFacade() {
-    const engine = state?.engine ?? {};
-    return {
-      ...engine,
-      hasRenderedPendingAssistantRecallHints: () => true,
-      takePendingAssistantRecallHints: () => [],
-      peekPendingAssistantRecallHints: () => [],
-      markPendingAssistantRecallHintsRendered: () => {},
-      getRecentRecallMemoryIds: () => [],
-      restoreSession: () => {
-        throw new Error("remote runner session restore is not available");
-      },
-    };
-  }
-}
+export function createRemoteRunnerClient(peer, { initialState = null } = {}) {
+  let state = initialState;
+
+  const client = {
+    get engine() { return createEngineFacade(); },
+    get runtimeState() { return state; },
+    async init(options = {}) {
+      state = await peer.call("init", options);
+      return state;
+    },
+    async runTurn(prompt, userMessage, options = {}) {
+      const result = await peer.call("runTurn", prompt, userMessage, options);
+      await refreshState();
+      return result;
+    },
+    abort: () => peer.call("abort"),
+    async cycleModel() { return applyResultWithState(await peer.call("cycleModel")); },
+    async setModel(model) { return applyResultWithState(await peer.call("setModel", model)); },
+    getCurrentModel: () => state?.currentModel ?? null,
+    getScopedModels: () => state?.scopedModels ?? [],
+    getConfiguredProviders: () => state?.configuredProviders ?? [],
+    getSessionStats: () => state?.sessionStats ?? null,
+    async refreshState() { return refreshState(); },
+    getLastNotificationResult: () => peer.call("getLastNotificationResult"),
+    notifyTest: (options) => peer.call("notifyTest", options),
+    estimateContextTokens: (userMessage = "") => peer.call("estimateContextTokens", userMessage),
+    async setSessionName(name) { return applyResultWithState(await peer.call("setSessionName", name)); },
+    canSwitchPiSession: () => Boolean(state?.canSwitchPiSession),
+    async startNewSession() { return applyResultWithState(await peer.call("startNewSession")); },
+    getExtensionDiagnostics: () => state?.extensionDiagnostics ?? [],
+    getExtensionLifecycleState: () => state?.extensionLifecycleState ?? null,
+    getLspStatus: () => state?.lspStatus ?? null,
+    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)); },
+    getAvailableThinkingLevels: () => state?.availableThinkingLevels ?? [],
+    async dispose() {
+      await peer.call("dispose");
+      peer.dispose();
+    },
+  };
+
+  return client;
+
+  async function refreshState() {
+    state = await peer.call("getState");
+    return state;
+  }
+
+  function applyResultWithState(response) {
+    if (response && Object.hasOwn(response, "state")) {
+      state = response.state;
+      return response.result;
+    }
+    return response;
+  }
+
+  function createEngineFacade() {
+    const engine = state?.engine ?? {};
+    return {
+      ...engine,
+      hasRenderedPendingAssistantRecallHints: () => true,
+      takePendingAssistantRecallHints: () => [],
+      peekPendingAssistantRecallHints: () => [],
+      markPendingAssistantRecallHintsRendered: () => {},
+      getRecentRecallMemoryIds: () => [],
+      restoreSession: () => {
+        throw new Error("remote runner session restore is not available");
+      },
+    };
+  }
+}

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

@@ -1,20 +1,20 @@
-export function createRemoteRuntimeUiClient(peer) {
-  return {
-    turnStart: () => peer.notify("uiEvent", { type: "turn_start" }),
-    turnEnd: () => peer.notify("uiEvent", { type: "turn_end" }),
-    assistantReplyEnd: () => peer.notify("uiEvent", { type: "assistant_reply_end" }),
-    textDelta: (delta) => peer.notify("uiEvent", { type: "text_delta", delta }),
-    thinkingStart: () => peer.notify("uiEvent", { type: "thinking_start" }),
-    thinkingDelta: (delta) => peer.notify("uiEvent", { type: "thinking_delta", delta }),
-    thinkingEnd: (tokens) => peer.notify("uiEvent", { type: "thinking_end", tokens }),
-    toolStart: (name, args) => peer.notify("uiEvent", { type: "tool_start", name, args }),
-    toolEnd: (name, isError, result) => peer.notify("uiEvent", { type: "tool_end", name, isError, result }),
-    retryStart: (event) => peer.notify("uiEvent", { type: "retry_start", ...event }),
-    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 }),
-    editDiff: (path, diffLines) => peer.notify("uiEvent", { type: "edit_diff", path, diffLines }),
-    requestPermission: (request) => peer.call("uiRequest", { type: "permission_request", ...request }),
-  };
-}
+export function createRemoteRuntimeUiClient(peer) {
+  return {
+    turnStart: () => peer.notify("uiEvent", { type: "turn_start" }),
+    turnEnd: () => peer.notify("uiEvent", { type: "turn_end" }),
+    assistantReplyEnd: () => peer.notify("uiEvent", { type: "assistant_reply_end" }),
+    textDelta: (delta) => peer.notify("uiEvent", { type: "text_delta", delta }),
+    thinkingStart: () => peer.notify("uiEvent", { type: "thinking_start" }),
+    thinkingDelta: (delta) => peer.notify("uiEvent", { type: "thinking_delta", delta }),
+    thinkingEnd: (tokens) => peer.notify("uiEvent", { type: "thinking_end", tokens }),
+    toolStart: (name, args) => peer.notify("uiEvent", { type: "tool_start", name, args }),
+    toolEnd: (name, isError, result) => peer.notify("uiEvent", { type: "tool_end", name, isError, result }),
+    retryStart: (event) => peer.notify("uiEvent", { type: "retry_start", ...event }),
+    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 }),
+    editDiff: (path, diffLines) => peer.notify("uiEvent", { type: "edit_diff", path, diffLines }),
+    requestPermission: (request) => peer.call("uiRequest", { type: "permission_request", ...request }),
+  };
+}