@ashx-j/lunr 0.2.25 → 0.2.27

package/dist/node-runtime/{chunk-5EFIU3OM.js → chunk-FTKEZL27.js}

@@ -1,7 +1,7 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
 import {
   getAgentDir
-} from "./chunk-FQMM2EZ2.js";
+} from "./chunk-64XTQNLA.js";
 
 // packages/coding-agent/dist/core/keybindings.js
 import { TUI_KEYBINDINGS, KeybindingsManager as TuiKeybindingsManager } from "@ashx-j/lunr-tui";

package/dist/node-runtime/chunk-FY4A63RK.js

@@ -0,0 +1,73 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+
+// packages/coding-agent/dist/core/computer-use/policy.js
+var settingsListeners = /* @__PURE__ */ new Set();
+function computerSettingsChanged(settings) {
+  for (let listener of settingsListeners)
+    listener(settings);
+}
+function onComputerSettingsChanged(listener) {
+  return settingsListeners.add(listener), () => {
+    settingsListeners.delete(listener);
+  };
+}
+var COMPUTER_TOOLS = [
+  "computer_load",
+  "computer_apps",
+  "computer_observe",
+  "computer_click",
+  "computer_hover",
+  "computer_drag",
+  "computer_key",
+  "computer_text",
+  "computer_window",
+  "computer_launch",
+  "computer_scroll",
+  "computer_end"
+];
+function computerPolicy(name, input) {
+  if (name.startsWith("computer_"))
+    switch (name) {
+      case "computer_load":
+      case "computer_apps":
+      case "computer_observe":
+      case "computer_end":
+        return { observation: !0, foreground: !1 };
+      case "computer_click":
+      case "computer_hover":
+      case "computer_drag":
+      case "computer_key":
+      case "computer_text":
+      case "computer_scroll":
+        return {
+          observation: !1,
+          foreground: name === "computer_hover" || input.foreground === !0 || input.desktop === !0
+        };
+      case "computer_window":
+      case "computer_launch":
+        return { observation: !1, foreground: !0 };
+      default:
+        throw new Error(`Unknown computer operation: ${name}`);
+    }
+}
+function computerRefusal(name, input, policy) {
+  let operation = computerPolicy(name, input);
+  if (!operation)
+    return "Unknown computer operation.";
+  if (policy.child)
+    return "Computer tools are available only to main agents.";
+  if (!policy.enabled)
+    return "Computer use is disabled in settings.";
+  if (operation.foreground && !policy.foreground)
+    return "Foreground control is disabled. Use background operations.";
+  if (!policy.vision && name !== "computer_end")
+    return "Image-only computer use requires an image-capable model. Select one before loading computer tools.";
+}
+
+export {
+  computerSettingsChanged,
+  onComputerSettingsChanged,
+  COMPUTER_TOOLS,
+  computerPolicy,
+  computerRefusal
+};

package/dist/node-runtime/chunk-FYIFPFXE.js

@@ -0,0 +1,98 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  typebox_exports
+} from "./chunk-PL6JKXWI.js";
+
+// packages/coding-agent/dist/core/computer-use/schemas.js
+var target = {
+  pid: typebox_exports.Integer({ minimum: 1 }),
+  window_id: typebox_exports.Integer({ minimum: 1 })
+}, observation = typebox_exports.String({
+  description: "Copy the latest image token exactly for this target. Single action, expires after 30 seconds. Failed actions consume it; capture again before acting."
+}), grounded = {
+  pid: typebox_exports.Optional(target.pid),
+  window_id: typebox_exports.Optional(target.window_id),
+  desktop: typebox_exports.Optional(typebox_exports.Boolean({ description: "Primary desktop instead of a window; requires foreground=true." })),
+  observation,
+  foreground: typebox_exports.Optional(typebox_exports.Boolean({
+    description: "Window focus escalation after verified background failure. Settings may forbid it."
+  }))
+}, coordinate = typebox_exports.Number({ minimum: 0 }), pixels = { x: coordinate, y: coordinate }, optionalPixels = { x: typebox_exports.Optional(coordinate), y: typebox_exports.Optional(coordinate) }, computerSchemas = {
+  computer_load: typebox_exports.Object({}, { additionalProperties: !1 }),
+  computer_apps: typebox_exports.Object({
+    pid: typebox_exports.Optional(target.pid),
+    query: typebox_exports.Optional(typebox_exports.String({
+      minLength: 1,
+      maxLength: 240,
+      description: "Case-insensitive literal substring in the requested app or window collection before pagination. Omit to list all. Required with include_windows."
+    })),
+    include_windows: typebox_exports.Optional(typebox_exports.Boolean({
+      description: "With a named app query and no pid, include windows for matching running PIDs (at most 5 PIDs and 50 window rows). Narrow the query or use pid if more match."
+    })),
+    offset: typebox_exports.Optional(typebox_exports.Integer({
+      minimum: 0,
+      maximum: Number.MAX_SAFE_INTEGER,
+      description: "Zero-based row offset, default 0. Pass the result's next_offset to retrieve the next 50 apps or windows."
+    }))
+  }, { additionalProperties: !1 }),
+  computer_observe: typebox_exports.Object({
+    pid: typebox_exports.Optional(target.pid),
+    window_id: typebox_exports.Optional(target.window_id),
+    desktop: typebox_exports.Optional(typebox_exports.Boolean({ description: "Capture the primary desktop instead of a window." })),
+    observation: typebox_exports.Optional(observation),
+    crop: typebox_exports.Optional(typebox_exports.Object({
+      x: coordinate,
+      y: coordinate,
+      width: typebox_exports.Number({ exclusiveMinimum: 0 }),
+      height: typebox_exports.Number({ exclusiveMinimum: 0 })
+    }, {
+      additionalProperties: !1,
+      description: "Region in the latest returned image's pixels; requires its observation token. Captures fresh pixels. Omit for full target."
+    }))
+  }, { additionalProperties: !1 }),
+  computer_click: typebox_exports.Object({
+    ...grounded,
+    ...pixels,
+    button: typebox_exports.Optional(typebox_exports.Union([typebox_exports.Literal("left"), typebox_exports.Literal("right")])),
+    count: typebox_exports.Optional(typebox_exports.Integer({ minimum: 1, maximum: 2 })),
+    modifier: typebox_exports.Optional(typebox_exports.Array(typebox_exports.String({ minLength: 1 }), { maxItems: 4 }))
+  }, { additionalProperties: !1 }),
+  computer_hover: typebox_exports.Object({
+    desktop: typebox_exports.Literal(!0, { description: "Primary desktop only; no window/PID hover." }),
+    foreground: typebox_exports.Literal(!0, {
+      description: "Moves the real pointer to the visible desktop target; foreground control must be allowed."
+    }),
+    observation,
+    ...pixels
+  }, { additionalProperties: !1 }),
+  computer_drag: typebox_exports.Object({ ...grounded, from_x: coordinate, from_y: coordinate, to_x: coordinate, to_y: coordinate }, { additionalProperties: !1 }),
+  computer_key: typebox_exports.Object({
+    ...grounded,
+    ...optionalPixels,
+    key: typebox_exports.Optional(typebox_exports.String({ minLength: 1, maxLength: 100 })),
+    keys: typebox_exports.Optional(typebox_exports.Array(typebox_exports.String({ minLength: 1, maxLength: 100 }), { minItems: 2, maxItems: 5 }))
+  }, { additionalProperties: !1 }),
+  computer_text: typebox_exports.Object({ ...grounded, ...optionalPixels, text: typebox_exports.String({ maxLength: 2e4 }) }, { additionalProperties: !1 }),
+  computer_window: typebox_exports.Object({
+    ...target,
+    observation,
+    action: typebox_exports.Union([typebox_exports.Literal("frame"), typebox_exports.Literal("focus")]),
+    x: typebox_exports.Optional(typebox_exports.Number()),
+    y: typebox_exports.Optional(typebox_exports.Number()),
+    width: typebox_exports.Optional(typebox_exports.Integer({ minimum: 1 })),
+    height: typebox_exports.Optional(typebox_exports.Integer({ minimum: 1 }))
+  }, { additionalProperties: !1 }),
+  computer_launch: typebox_exports.Object({ name: typebox_exports.String({ minLength: 1, maxLength: 500 }) }, { additionalProperties: !1 }),
+  computer_scroll: typebox_exports.Object({
+    ...grounded,
+    ...pixels,
+    direction: typebox_exports.Union([typebox_exports.Literal("up"), typebox_exports.Literal("down"), typebox_exports.Literal("left"), typebox_exports.Literal("right")]),
+    amount: typebox_exports.Integer({ minimum: 1, maximum: 50 }),
+    by: typebox_exports.Union([typebox_exports.Literal("line"), typebox_exports.Literal("page")])
+  }, { additionalProperties: !1 }),
+  computer_end: typebox_exports.Object({}, { additionalProperties: !1 })
+};
+
+export {
+  computerSchemas
+};

package/dist/node-runtime/{chunk-HMBGROQK.js → chunk-GLDXBBL6.js}

@@ -4,13 +4,13 @@ import {
 } from "./chunk-I6R76AG7.js";
 import {
   DynamicBorder
-} from "./chunk-6VYZ5UFP.js";
+} from "./chunk-FLGEEH27.js";
 import {
   keyHint
-} from "./chunk-GS42T6MX.js";
+} from "./chunk-QW3AAHWN.js";
 import {
   theme
-} from "./chunk-RDDAZOMU.js";
+} from "./chunk-JL4HYQXK.js";
 
 // packages/coding-agent/dist/modes/interactive/components/extension-input.js
 import { Container, getKeybindings, Input, Spacer, Text } from "@ashx-j/lunr-tui";

package/dist/node-runtime/{chunk-KWA4OC2J.js → chunk-H6YBCWKG.js}

@@ -5,7 +5,7 @@ import {
 import {
   NPM_CLI_PACKAGE,
   PACKAGE_NAME
-} from "./chunk-FQMM2EZ2.js";
+} from "./chunk-64XTQNLA.js";
 import {
   __toESM
 } from "./chunk-BRJX2PRC.js";

package/dist/node-runtime/{chunk-2MI5OPMN.js → chunk-HNNHHJAB.js}

@@ -3,6 +3,9 @@ import {
   runtimeScope
 } from "./chunk-IMLCWLPI.js";
 
+// packages/coding-agent/dist/core/usage-service.js
+import { createHash } from "node:crypto";
+
 // packages/coding-agent/dist/core/usage-adapters/shared.js
 async function fetchWithTimeout(url, init, timeoutMs = 1e4) {
   let controller = new AbortController(), timeout = setTimeout(() => controller.abort(), timeoutMs);
@@ -84,8 +87,8 @@ function detailWindow(label, detail) {
   if (usedPercent !== void 0)
     return { label, usedPercent, resetsAt: toEpochMs(object.resetTime) };
 }
-async function fetchKimiPlanUsage(runtime) {
-  let apiKey = (await runtime.getAuth(KIMI_PROVIDER_ID))?.auth.apiKey;
+async function fetchKimiPlanUsage(runtime, auth) {
+  let apiKey = (auth ? auth.resolution : await runtime.getAuth(KIMI_PROVIDER_ID))?.auth.apiKey;
   if (!apiKey)
     return;
   let response = await fetchWithTimeout(KIMI_USAGE_URL, {
@@ -218,8 +221,8 @@ function toPlanUsage(report) {
     ];
   });
 }
-async function fetchCodexPlanUsage(runtime) {
-  let headers = await resolveCodexHeaders(runtime);
+async function fetchCodexPlanUsage(runtime, auth) {
+  let headers = auth ? auth.codexHeaders : await resolveCodexHeaders(runtime);
   if (!headers)
     return;
   let response = await fetchWithTimeout(CODEX_USAGE_URL, { headers }), text = await response.text();
@@ -244,10 +247,10 @@ function weeklyWindow(config) {
     resetsAt: toEpochMs(period?.end)
   };
 }
-async function fetchXaiPlanUsage(runtime) {
-  if (!runtime.isUsingOAuth(XAI_PROVIDER_ID))
+async function fetchXaiPlanUsage(runtime, auth) {
+  if (!(auth?.oauth ?? runtime.isUsingOAuth(XAI_PROVIDER_ID)))
     return;
-  let accessToken = (await runtime.getAuth(XAI_PROVIDER_ID))?.auth.apiKey;
+  let accessToken = (auth ? auth.resolution : await runtime.getAuth(XAI_PROVIDER_ID))?.auth.apiKey;
   if (!accessToken)
     return;
   let response = await fetchWithTimeout(XAI_BILLING_URL, {
@@ -292,8 +295,8 @@ function limitLabel(limit) {
   let unit = asNumber(limit.unit), number = asNumber(limit.number);
   return unit === 1 && number !== void 0 ? `${number}d` : unit === 3 && number !== void 0 ? `${number}h` : unit === 5 && number !== void 0 ? `${number}m` : unit === 6 ? "Weekly" : "Limit";
 }
-async function fetchZaiPlanUsage(runtime) {
-  let apiKey = (await runtime.getAuth(ZAI_PROVIDER_ID))?.auth.apiKey;
+async function fetchZaiPlanUsage(runtime, auth) {
+  let apiKey = (auth ? auth.resolution : await runtime.getAuth(ZAI_PROVIDER_ID))?.auth.apiKey;
   if (!apiKey)
     return;
   let response = await fetchWithTimeout(ZAI_QUOTA_URL, {
@@ -361,7 +364,11 @@ function pickPlanWindow(usage, preferred) {
 function footerPlanLabel(window) {
   return isFiveHourPlanWindow(window) ? "5h" : isWeeklyPlanWindow(window) ? "wk" : window.label.length <= 4 ? window.label : window.label.slice(0, 4);
 }
-var cache = /* @__PURE__ */ new Map(), inflight = /* @__PURE__ */ new Map();
+var generation = 0, states = /* @__PURE__ */ new WeakMap();
+function stateFor(runtime) {
+  let state = states.get(runtime);
+  return state || (state = { accounts: /* @__PURE__ */ new Map(), authReads: /* @__PURE__ */ new Map(), cache: /* @__PURE__ */ new Map(), inflight: /* @__PURE__ */ new Map() }, states.set(runtime, state)), state;
+}
 function hasPlanUsageAdapter(providerId) {
   return providerId in ADAPTERS;
 }
@@ -372,24 +379,38 @@ async function getPlanUsageResult(providerId, runtime) {
   let adapter = ADAPTERS[providerId];
   if (!adapter)
     return {};
-  let now = Date.now(), cached = cache.get(providerId);
-  if (cached && cached.expiresAt > now)
+  let state = stateFor(runtime), requestGeneration = generation, reads = state.authReads.get(providerId) ?? { started: 0, settled: 0 };
+  state.authReads.set(providerId, reads);
+  let authRead = ++reads.started, auth;
+  try {
+    auth = providerId === "openai-codex" ? { codexHeaders: await resolveCodexHeaders(runtime), oauth: runtime.isUsingOAuth(providerId) } : { resolution: await runtime.getAuth(providerId), oauth: runtime.isUsingOAuth(providerId) };
+  } catch (error) {
+    return reads.settled <= authRead && (reads.settled = authRead, state.accounts.delete(providerId), state.cache.delete(providerId), state.inflight.delete(providerId)), { error: planUsageAuthError(error) };
+  }
+  if (generation !== requestGeneration || states.get(runtime) !== state)
+    return {};
+  let account = createHash("sha256").update(JSON.stringify(auth)).digest("hex"), previous = state.accounts.get(providerId);
+  if (reads.settled > authRead && previous !== account)
+    return {};
+  reads.settled = Math.max(reads.settled, authRead), previous !== account && (state.cache.delete(providerId), state.inflight.delete(providerId), state.accounts.set(providerId, account));
+  let cached = state.cache.get(providerId);
+  if (cached && cached.expiresAt > Date.now())
     return { usage: cached.value[0], usages: cached.value };
-  let pending = inflight.get(providerId);
+  let pending = state.inflight.get(providerId);
   if (pending)
     return pending;
-  let task = (async () => {
+  let isCurrent = () => generation === requestGeneration && states.get(runtime) === state && state.accounts.get(providerId) === account && state.inflight.get(providerId) === task, task = (async () => {
     try {
-      let value = await adapter(runtime), usages = value === void 0 ? [] : Array.isArray(value) ? value : [value];
-      return cache.set(providerId, { expiresAt: Date.now() + PLAN_USAGE_CACHE_TTL_MS, value: usages }), { usage: usages[0], usages };
+      let value = await adapter(runtime, auth), usages = value === void 0 ? [] : Array.isArray(value) ? value : [value];
+      return isCurrent() && state.cache.set(providerId, { expiresAt: Date.now() + PLAN_USAGE_CACHE_TTL_MS, value: usages }), { usage: usages[0], usages };
     } catch (error) {
       let authError = planUsageAuthError(error);
-      return authError ? { error: authError } : (cache.set(providerId, { expiresAt: Date.now() + PLAN_USAGE_CACHE_TTL_MS, value: [] }), {});
+      return authError ? { error: authError } : (isCurrent() && state.cache.set(providerId, { expiresAt: Date.now() + PLAN_USAGE_CACHE_TTL_MS, value: [] }), {});
     } finally {
-      inflight.delete(providerId);
+      isCurrent() && state.inflight.delete(providerId);
     }
   })();
-  return inflight.set(providerId, task), task;
+  return state.inflight.set(providerId, task), task;
 }
 async function getAllPlanUsageResults(currentProvider, runtime) {
   let stored = new Set((await runtime.listCredentials()).map((credential) => credential.providerId)), providers = Object.keys(ADAPTERS).filter((providerId) => stored.has(providerId) || providerId === currentProvider), results = await Promise.all(providers.map((providerId) => getPlanUsageResult(providerId, runtime)));
@@ -398,41 +419,38 @@ async function getAllPlanUsageResults(currentProvider, runtime) {
     errors: results.flatMap((result) => result.error ? [`${result.error}`] : [])
   };
 }
-function peekPlanUsage(providerId) {
-  return cache.get(providerId)?.value[0];
+function peekPlanUsage(providerId, runtime) {
+  return states.get(runtime)?.cache.get(providerId)?.value[0];
 }
 function clearPlanUsageCache() {
-  cache.clear(), inflight.clear();
-}
-var USAGE_SERVICE_BRIDGE_SYMBOL = /* @__PURE__ */ Symbol.for("@lunr/usage-service"), activeRuntime, activeUsageSettings, onUsageUpdate;
-function preferredWindow() {
-  return (runtimeScope.getStore()?.settingsManager ?? activeUsageSettings)?.getPlanUsageWindow() ?? "weekly";
-}
-var usageBridge = {
-  peek(providerId) {
-    return peekPlanUsage(providerId);
-  },
-  prefetch(providerId) {
-    let runtime = runtimeScope.getStore()?.modelRuntime ?? activeRuntime;
-    !runtime || !hasPlanUsageAdapter(providerId) || getPlanUsage(providerId, runtime).then(() => onUsageUpdate?.());
-  },
-  setOnUpdate(fn) {
-    onUsageUpdate = fn;
-  },
-  getPreferredWindow() {
-    return preferredWindow();
-  },
-  pickForFooter(providerId) {
-    let window = pickPlanWindow(peekPlanUsage(providerId), preferredWindow());
-    if (window)
-      return { label: footerPlanLabel(window), usedPercent: window.usedPercent };
-  }
-};
+  generation++, states = /* @__PURE__ */ new WeakMap();
+}
+var USAGE_SERVICE_BRIDGE_SYMBOL = /* @__PURE__ */ Symbol.for("@lunr/usage-service"), bridges = /* @__PURE__ */ new WeakMap();
 function registerUsageServiceBridge(runtime, settingsManager) {
-  activeRuntime = runtime, activeUsageSettings = settingsManager, globalThis[USAGE_SERVICE_BRIDGE_SYMBOL] = usageBridge;
+  let onUpdate, bridge = {
+    peek: (providerId) => peekPlanUsage(providerId, runtime),
+    prefetch(providerId) {
+      hasPlanUsageAdapter(providerId) && getPlanUsage(providerId, runtime).then(() => onUpdate?.());
+    },
+    setOnUpdate(fn) {
+      onUpdate = fn;
+    },
+    getPreferredWindow: () => settingsManager.getPlanUsageWindow(),
+    pickForFooter(providerId) {
+      let window = pickPlanWindow(peekPlanUsage(providerId, runtime), settingsManager.getPlanUsageWindow());
+      return window ? { label: footerPlanLabel(window), usedPercent: window.usedPercent } : void 0;
+    }
+  };
+  bridges.set(runtime, bridge), globalThis[USAGE_SERVICE_BRIDGE_SYMBOL] = {
+    peek: (providerId) => getUsageServiceBridge()?.peek(providerId),
+    prefetch: (providerId) => getUsageServiceBridge()?.prefetch(providerId),
+    pickForFooter: (providerId) => getUsageServiceBridge()?.pickForFooter(providerId),
+    getPreferredWindow: () => getUsageServiceBridge()?.getPreferredWindow() ?? "weekly",
+    setOnUpdate: (fn) => getUsageServiceBridge()?.setOnUpdate(fn)
+  };
 }
-function getUsageServiceBridge() {
-  return globalThis[USAGE_SERVICE_BRIDGE_SYMBOL];
+function getUsageServiceBridge(runtime = runtimeScope.getStore()?.modelRuntime) {
+  return runtime ? bridges.get(runtime) : void 0;
 }
 
 export {

package/dist/node-runtime/{chunk-6XL67VVY.js → chunk-HUD2RFJW.js}

@@ -2,10 +2,13 @@ import { createRequire as __lunrRequire } from "node:module"; const require = __
 import {
   browserEnabledDefault,
   notifyBrowserEnabledChange
-} from "./chunk-UOEDI7RP.js";
+} from "./chunk-4KNKQGHM.js";
 import {
   require_proper_lockfile
 } from "./chunk-URD2SLIT.js";
+import {
+  computerSettingsChanged
+} from "./chunk-FY4A63RK.js";
 import {
   MEMORY_CHAR_CAP_DEFAULT,
   MEMORY_CHAR_CAP_MAX,
@@ -16,7 +19,7 @@ import {
   getAgentDir,
   normalizePath,
   resolvePath
-} from "./chunk-FQMM2EZ2.js";
+} from "./chunk-64XTQNLA.js";
 import {
   __commonJS,
   __require,
@@ -18867,6 +18870,18 @@ var FileSettingsStorage = class {
     let value = this.settings.memoryCharCap;
     return typeof value == "number" && Number.isFinite(value) ? Math.min(MEMORY_CHAR_CAP_MAX, Math.max(MEMORY_CHAR_CAP_MIN, Math.floor(value))) : MEMORY_CHAR_CAP_DEFAULT;
   }
+  getComputerUse() {
+    return this.globalSettings.computerUse ?? !0;
+  }
+  setComputerUse(enabled) {
+    this.globalSettings.computerUse = enabled, this.markModified("computerUse"), this.save(), computerSettingsChanged({ enabled, foreground: this.getComputerForeground() });
+  }
+  getComputerForeground() {
+    return this.globalSettings.computerForeground ?? !0;
+  }
+  setComputerForeground(enabled) {
+    this.globalSettings.computerForeground = enabled, this.markModified("computerForeground"), this.save(), computerSettingsChanged({ enabled: this.getComputerUse(), foreground: enabled });
+  }
   getBrowserEnabled() {
     return this.globalSettings.browserEnabled ?? browserEnabledDefault();
   }

package/dist/node-runtime/{chunk-I54LGHWM.js → chunk-I2H5QMWW.js}

@@ -1,17 +1,17 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
 import {
   SessionManager
-} from "./chunk-2KIPT4HJ.js";
+} from "./chunk-EPR2F3GU.js";
 import {
   SessionOwnership,
   canonicalSessionPath,
   isSessionOwnerDead,
   readSessionOwner,
   writeSessionJson
-} from "./chunk-UAEOTO52.js";
+} from "./chunk-MNQXDFPV.js";
 import {
   getAgentDir
-} from "./chunk-FQMM2EZ2.js";
+} from "./chunk-64XTQNLA.js";
 
 // packages/coding-agent/dist/core/session-handoff.js
 import { createHash, randomUUID } from "node:crypto";

package/dist/node-runtime/chunk-IAZSK7KK.js

@@ -0,0 +1,108 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  applyExifOrientation,
+  formatDimensionNote,
+  resizeImage
+} from "./chunk-TCT6PCUR.js";
+import {
+  loadPhoton
+} from "./chunk-RQ2Q5IYR.js";
+
+// packages/coding-agent/dist/utils/image-convert.js
+async function convertImageBytesToPng(bytes) {
+  let photon = await loadPhoton();
+  if (!photon)
+    return null;
+  try {
+    let rawImage = photon.PhotonImage.new_from_byteslice(bytes), image = applyExifOrientation(photon, rawImage, bytes);
+    image !== rawImage && rawImage.free();
+    try {
+      return new Uint8Array(image.get_bytes());
+    } finally {
+      image.free();
+    }
+  } catch {
+    return null;
+  }
+}
+async function convertToPng(base64Data, mimeType) {
+  if (mimeType === "image/png")
+    return { data: base64Data, mimeType };
+  let bytes = new Uint8Array(Buffer.from(base64Data, "base64")), pngBytes = await convertImageBytesToPng(bytes);
+  return pngBytes ? {
+    data: Buffer.from(pngBytes).toString("base64"),
+    mimeType: "image/png"
+  } : null;
+}
+
+// packages/coding-agent/dist/utils/image-process.js
+function baseMimeType(mimeType) {
+  return mimeType.split(";")[0]?.trim().toLowerCase() ?? mimeType.toLowerCase();
+}
+function normalizeSupportedImageMimeType(mimeType) {
+  switch (baseMimeType(mimeType)) {
+    case "image/png":
+      return "image/png";
+    case "image/jpeg":
+    case "image/jpg":
+      return "image/jpeg";
+    case "image/gif":
+      return "image/gif";
+    case "image/webp":
+      return "image/webp";
+    default:
+      return null;
+  }
+}
+async function normalizeImage(bytes, mimeType) {
+  let normalizedMimeType = normalizeSupportedImageMimeType(mimeType);
+  if (normalizedMimeType)
+    return { bytes, mimeType: normalizedMimeType };
+  let pngBytes = await convertImageBytesToPng(bytes);
+  return pngBytes ? {
+    bytes: pngBytes,
+    mimeType: "image/png",
+    convertedFrom: baseMimeType(mimeType)
+  } : null;
+}
+function conversionHint(from, to) {
+  if (!(!from || from === to))
+    return `[Image converted from ${from} to ${to}.]`;
+}
+async function processImage(bytes, mimeType, options) {
+  let autoResizeImages = options?.autoResizeImages ?? !0, normalized = await normalizeImage(bytes, mimeType);
+  if (!normalized)
+    return {
+      ok: !1,
+      message: "[Image omitted: could not be converted to a supported inline image format.]"
+    };
+  if (autoResizeImages) {
+    let resized = await resizeImage(normalized.bytes, normalized.mimeType, options?.resizeOptions);
+    if (!resized)
+      return {
+        ok: !1,
+        message: "[Image omitted: could not be resized below the inline image size limit.]"
+      };
+    let hints2 = [], convertedHint2 = conversionHint(normalized.convertedFrom, resized.mimeType);
+    convertedHint2 && hints2.push(convertedHint2);
+    let dimensionNote = formatDimensionNote(resized);
+    return dimensionNote && hints2.push(dimensionNote), {
+      ok: !0,
+      data: resized.data,
+      mimeType: resized.mimeType,
+      hints: hints2
+    };
+  }
+  let hints = [], convertedHint = conversionHint(normalized.convertedFrom, normalized.mimeType);
+  return convertedHint && hints.push(convertedHint), {
+    ok: !0,
+    data: Buffer.from(normalized.bytes).toString("base64"),
+    mimeType: normalized.mimeType,
+    hints
+  };
+}
+
+export {
+  convertToPng,
+  processImage
+};

package/dist/node-runtime/{chunk-2HHLJWGD.js → chunk-IHHTWSXN.js}

@@ -4,26 +4,26 @@ import {
 } from "./chunk-YPHAIRZT.js";
 import {
   DefaultPackageManager
-} from "./chunk-LQP3RB67.js";
+} from "./chunk-UYRKUKFE.js";
 import {
   SettingsManager
-} from "./chunk-6XL67VVY.js";
+} from "./chunk-HUD2RFJW.js";
 import {
   KeybindingsManager
-} from "./chunk-5EFIU3OM.js";
+} from "./chunk-FTKEZL27.js";
 import {
   ExtensionSelectorComponent
-} from "./chunk-QH6YL7VK.js";
+} from "./chunk-252ZVPPF.js";
 import {
   ExtensionInputComponent
-} from "./chunk-HMBGROQK.js";
+} from "./chunk-GLDXBBL6.js";
 import {
   DynamicBorder
-} from "./chunk-6VYZ5UFP.js";
+} from "./chunk-FLGEEH27.js";
 import {
   keyHint,
   rawKeyHint
-} from "./chunk-GS42T6MX.js";
+} from "./chunk-QW3AAHWN.js";
 import {
   detectTerminalBackgroundFromEnv,
   detectTerminalThemeForAuto,
@@ -34,7 +34,7 @@ import {
   setRegisteredThemes,
   setTheme,
   theme
-} from "./chunk-RDDAZOMU.js";
+} from "./chunk-JL4HYQXK.js";
 import {
   APP_NAME,
   CONFIG_DIR_NAME,
@@ -42,7 +42,7 @@ import {
   PACKAGE_NAME,
   getAgentDir,
   getSettingsPath
-} from "./chunk-FQMM2EZ2.js";
+} from "./chunk-64XTQNLA.js";
 
 // packages/coding-agent/dist/cli/startup-ui.js
 import { ProcessTerminal, setKeybindings, TUI } from "@ashx-j/lunr-tui";

package/dist/node-runtime/{chunk-DAPBPCBP.js → chunk-IPP5BIV5.js}

@@ -1,11 +1,17 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
 
 // packages/coding-agent/dist/builtin-extensions/pi-web-access/activity.js
+import { AsyncLocalStorage } from "node:async_hooks";
 var ActivityMonitor = class {
   entries = [];
   maxEntries = 10;
   listeners = /* @__PURE__ */ new Set();
-  rateLimitInfo = { used: 0, max: 10, oldestTimestamp: null, windowMs: 6e4 };
+  rateLimitInfo = {
+    used: 0,
+    max: 10,
+    oldestTimestamp: null,
+    windowMs: 6e4
+  };
   nextId = 1;
   logStart(partial) {
     let id = `act-${this.nextId++}`, entry = {
@@ -37,7 +43,12 @@ var ActivityMonitor = class {
     return this.listeners.add(callback), () => this.listeners.delete(callback);
   }
   clear() {
-    this.entries = [], this.rateLimitInfo = { used: 0, max: 10, oldestTimestamp: null, windowMs: 6e4 }, this.notify();
+    this.entries = [], this.rateLimitInfo = {
+      used: 0,
+      max: 10,
+      oldestTimestamp: null,
+      windowMs: 6e4
+    }, this.notify();
   }
   notify() {
     for (let cb of this.listeners)
@@ -46,8 +57,19 @@ var ActivityMonitor = class {
       } catch {
       }
   }
-}, activityMonitor = new ActivityMonitor();
+}, activityScope = new AsyncLocalStorage(), standaloneActivity = new ActivityMonitor();
+function runWithActivity(monitor, fn) {
+  return activityScope.run(monitor, fn);
+}
+var activityMonitor = new Proxy(standaloneActivity, {
+  get(_target, key) {
+    let monitor = activityScope.getStore() ?? standaloneActivity, value = monitor[key];
+    return typeof value == "function" ? value.bind(monitor) : value;
+  }
+});
 
 export {
+  ActivityMonitor,
+  runWithActivity,
   activityMonitor
 };