@ashx-j/lunr 0.2.25 → 0.2.27

package/dist/node-runtime/{chunk-2KIPT4HJ.js → chunk-EPR2F3GU.js}

@@ -9,18 +9,18 @@ import {
   SessionOwnershipError,
   canonicalSessionPath,
   writeSessionJson
-} from "./chunk-UAEOTO52.js";
+} from "./chunk-MNQXDFPV.js";
 import {
   getAgentDir,
   getSessionsDir,
   normalizePath,
   resolvePath
-} from "./chunk-FQMM2EZ2.js";
+} from "./chunk-64XTQNLA.js";
 
 // packages/coding-agent/dist/core/session-manager.js
 import { uuidv7 } from "@ashx-j/lunr-agent";
 import { createHash, randomUUID } from "crypto";
-import { appendFileSync, closeSync, createReadStream, existsSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, statSync, writeFileSync } from "fs";
+import { appendFileSync, closeSync, createReadStream, existsSync, fchmodSync, fsyncSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";
 import { readdir, stat } from "fs/promises";
 import { join, resolve } from "path";
 import { createInterface } from "readline";
@@ -326,6 +326,23 @@ async function listSessionsFromDir(dir, onProgress, progressOffset = 0, progress
   }
   return sessions;
 }
+function writeSessionEntries(file, entries) {
+  let mode = existsSync(file) ? statSync(file).mode & 511 : 384, temp = `${file}.${randomUUID()}.tmp`, fd = openSync(temp, "wx", mode);
+  try {
+    try {
+      fchmodSync(fd, mode);
+      for (let entry of entries)
+        writeFileSync(fd, `${JSON.stringify(entry)}
+`);
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    renameSync(temp, file);
+  } finally {
+    existsSync(temp) && unlinkSync(temp);
+  }
+}
 var SessionManager = class _SessionManager {
   sessionId = "";
   sessionFile;
@@ -333,6 +350,7 @@ var SessionManager = class _SessionManager {
   cwd;
   persist;
   flushed = !1;
+  needsAppendSeparator = !1;
   fileEntries = [];
   byId = /* @__PURE__ */ new Map();
   labelsById = /* @__PURE__ */ new Map();
@@ -419,7 +437,15 @@ var SessionManager = class _SessionManager {
   }
   loadSessionFile(sessionFile) {
     if (this.claim(sessionFile), this.sessionFile = resolvePath(sessionFile), existsSync(this.sessionFile)) {
-      if (this.fileEntries = loadEntriesFromFile(this.sessionFile), this.fileEntries.length === 0) {
+      this.fileEntries = loadEntriesFromFile(this.sessionFile);
+      let fd = openSync(this.sessionFile, "r");
+      try {
+        let size = statSync(this.sessionFile).size, lastByte = Buffer.alloc(1);
+        this.needsAppendSeparator = size > 0 && readSync(fd, lastByte, 0, 1, size - 1) === 1 && lastByte[0] !== 10;
+      } finally {
+        closeSync(fd);
+      }
+      if (this.fileEntries.length === 0) {
         let explicitPath = this.sessionFile;
         if (statSync(explicitPath).size > 0)
           throw new Error(`Session file is not a valid pi session: ${explicitPath}`);
@@ -450,7 +476,7 @@ var SessionManager = class _SessionManager {
       cwd: this.cwd,
       parentSession: options?.parentSession
     };
-    if (this.fileEntries = [header], this.byId.clear(), this.labelsById.clear(), this.labelTimestampsById.clear(), this.leafId = null, this.flushed = !1, this.permissionMode = void 0, this.persist) {
+    if (this.fileEntries = [header], this.byId.clear(), this.labelsById.clear(), this.labelTimestampsById.clear(), this.leafId = null, this.flushed = !1, this.needsAppendSeparator = !1, this.permissionMode = void 0, this.persist) {
       let fileTimestamp = timestamp.replace(/[:.]/g, "-");
       this.sessionFile = join(this.getSessionDir(), `${fileTimestamp}_${this.sessionId}.jsonl`);
     }
@@ -461,17 +487,19 @@ var SessionManager = class _SessionManager {
     for (let entry of this.fileEntries)
       entry.type !== "session" && (this.byId.set(entry.id, entry), this.leafId = entry.id, entry.type === "label" && (entry.label ? (this.labelsById.set(entry.targetId, entry.label), this.labelTimestampsById.set(entry.targetId, entry.timestamp)) : (this.labelsById.delete(entry.targetId), this.labelTimestampsById.delete(entry.targetId))));
   }
+  /** Replace only after the sibling log is written, synced and closed.
+   * Rename protects the previous log on write failure, not against every power-loss scenario.
+   */
   _rewriteFile() {
     if (this.assertWritable(), !this.persist || !this.sessionFile)
       return;
-    let fd = openSync(this.sessionFile, "w");
-    try {
-      for (let entry of this.fileEntries)
-        writeFileSync(fd, `${JSON.stringify(entry)}
-`);
-    } finally {
-      closeSync(fd);
-    }
+    let file = this.ownership?.owner.file ?? this.sessionFile;
+    writeSessionEntries(file, this.fileEntries), this.needsAppendSeparator = !1;
+  }
+  _appendToFile(entry) {
+    this.sessionFile && (appendFileSync(this.sessionFile, `${this.needsAppendSeparator ? `
+` : ""}${JSON.stringify(entry)}
+`), this.needsAppendSeparator = !1);
   }
   isPersisted() {
     return this.persist;
@@ -495,13 +523,11 @@ var SessionManager = class _SessionManager {
     if (this.assertWritable(), !this.persist || !this.sessionFile)
       return;
     if (!this.fileEntries.some((e) => e.type === "message" && e.message.role === "assistant")) {
-      this.flushed ? appendFileSync(this.sessionFile, `${JSON.stringify(entry)}
-`) : this.flushed = !1;
+      this.flushed ? this._appendToFile(entry) : this.flushed = !1;
       return;
     }
     if (this.flushed)
-      appendFileSync(this.sessionFile, `${JSON.stringify(entry)}
-`);
+      this._appendToFile(entry);
     else {
       let fd = openSync(this.sessionFile, "wx");
       try {
@@ -748,7 +774,7 @@ var SessionManager = class _SessionManager {
   branch(branchFromId) {
     if (this.assertWritable(), !this.byId.has(branchFromId))
       throw new Error(`Entry ${branchFromId} not found`);
-    this.leafId = branchFromId, this.flush();
+    this.moveLeaf(branchFromId);
   }
   /**
    * Reset the leaf pointer to null (before any entries).
@@ -756,7 +782,16 @@ var SessionManager = class _SessionManager {
    * Use this when navigating to re-edit the first user message.
    */
   resetLeaf() {
-    this.assertWritable(), this.leafId = null, this.flush();
+    this.assertWritable(), this.moveLeaf(null);
+  }
+  moveLeaf(leafId) {
+    let previous = this.leafId;
+    this.leafId = leafId;
+    try {
+      this.flush();
+    } catch (error) {
+      throw this.leafId = previous, error;
+    }
   }
   /**
    * Start a new branch with a summary of the abandoned path.
@@ -815,7 +850,20 @@ var SessionManager = class _SessionManager {
         };
         pathEntryIds.add(labelEntry.id), labelEntries2.push(labelEntry), parentId2 = labelEntry.id;
       }
-      return this.claim(newSessionFile), this.fileEntries = [header, ...pathWithoutLabels, ...labelEntries2], this.sessionId = newSessionId, this.ownership?.bindSession(this.sessionId), this.sessionFile = newSessionFile, this._buildIndex(), this.fileEntries.some((e) => e.type === "message" && e.message.role === "assistant") ? (this._rewriteFile(), this.flushed = !0) : this.flushed = !1, newSessionFile;
+      let entries = [header, ...pathWithoutLabels, ...labelEntries2], hasAssistant = entries.some((e) => e.type === "message" && e.message.role === "assistant");
+      this.saveLeaf();
+      let nextOwnership = new SessionOwnership(canonicalSessionPath(newSessionFile)), wroteFork = !1;
+      try {
+        nextOwnership.bindSession(newSessionId), hasAssistant && (writeSessionEntries(nextOwnership.owner.file, entries), wroteFork = !0), this.ownership?.release();
+      } catch (error) {
+        if (wroteFork)
+          try {
+            unlinkSync(nextOwnership.owner.file);
+          } catch {
+          }
+        throw nextOwnership.release(), error;
+      }
+      return this.ownership = nextOwnership, this.fileEntries = entries, this.sessionId = newSessionId, this.sessionFile = newSessionFile, this._buildIndex(), this.flushed = hasAssistant, this.needsAppendSeparator = !1, newSessionFile;
     }
     let labelEntries = [], parentId = pathWithoutLabels[pathWithoutLabels.length - 1]?.id || null;
     for (let { targetId, label, timestamp: labelTimestamp } of labelsToWrite) {

package/dist/node-runtime/{chunk-CSFI6YXL.js → chunk-ES6PBSIE.js}

@@ -1,7 +1,7 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
 import {
   getBinDir
-} from "./chunk-FQMM2EZ2.js";
+} from "./chunk-64XTQNLA.js";
 
 // packages/coding-agent/dist/utils/shell.js
 import { existsSync } from "node:fs";

package/dist/node-runtime/{chunk-IF24A3FH.js → chunk-EVM653DD.js}

@@ -7,10 +7,10 @@ import {
 } from "./chunk-OBMWP3I5.js";
 import {
   killTrackedDetachedChildren
-} from "./chunk-CSFI6YXL.js";
+} from "./chunk-ES6PBSIE.js";
 import {
   theme
-} from "./chunk-RDDAZOMU.js";
+} from "./chunk-JL4HYQXK.js";
 
 // packages/coding-agent/dist/modes/rpc/rpc-mode.js
 import * as crypto from "node:crypto";
@@ -417,10 +417,10 @@ async function runRpcMode(runtimeHost) {
   }, detachInput = () => {
   };
   async function shutdown(exitCode = 0, signal) {
-    shuttingDown && process.exit(exitCode), shuttingDown = !0;
+    shuttingDown && process.exit(exitCode), shuttingDown = !0, session.stopAdmission();
     for (let cleanup of signalCleanupHandlers)
       cleanup();
-    unsubscribe?.(), unsubscribeBackpressure?.(), await runtimeHost.dispose(), detachInput(), process.stdin.pause(), signal !== "SIGTERM" && await flushRawStdout(), process.exit(exitCode);
+    await runtimeHost.dispose(), unsubscribe?.(), unsubscribeBackpressure?.(), detachInput(), process.stdin.pause(), signal !== "SIGTERM" && await flushRawStdout(), process.exit(exitCode);
   }
   async function checkShutdownRequested() {
     shutdownRequested && await shutdown();

package/dist/node-runtime/{chunk-HTFRRDSF.js → chunk-F2SMQ6ES.js}

@@ -6,7 +6,7 @@ import {
   CONFIG_DIR_NAME,
   canonicalizePath,
   resolvePath
-} from "./chunk-FQMM2EZ2.js";
+} from "./chunk-64XTQNLA.js";
 import {
   __toESM
 } from "./chunk-BRJX2PRC.js";
@@ -18,6 +18,7 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 var TRUST_REQUIRING_PROJECT_CONFIG_RESOURCES = [
   "settings.json",
+  "mcp.json",
   "extensions",
   "skills",
   "prompts",
@@ -119,7 +120,7 @@ function withTrustFileLock(path, fn) {
 }
 function hasTrustRequiringProjectResources(cwd) {
   let homeDir = canonicalizePath(resolvePath(process.env.HOME || homedir())), userAgentsSkillsDir = join(homeDir, ".agents", "skills"), currentDir = canonicalizePath(resolvePath(cwd)), configDir = join(currentDir, CONFIG_DIR_NAME);
-  if (TRUST_REQUIRING_PROJECT_CONFIG_RESOURCES.some((entry) => existsSync(join(configDir, entry))))
+  if ([".mcp.json", ".pi/mcp.json", ".vscode/mcp.json", ".pi-lsp.json"].some((entry) => existsSync(join(currentDir, entry))) || TRUST_REQUIRING_PROJECT_CONFIG_RESOURCES.some((entry) => existsSync(join(configDir, entry))))
     return !0;
   for (; ; ) {
     let agentsSkillsDir = join(currentDir, ".agents", "skills");

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

@@ -0,0 +1,114 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  getInstructionsRoot
+} from "./chunk-BDRGN3L2.js";
+import {
+  CONFIG_DIR_NAME,
+  canonicalizeTargetPath,
+  getAgentDir,
+  resolvePath
+} from "./chunk-64XTQNLA.js";
+
+// packages/coding-agent/dist/core/tools/path-utils.js
+import { accessSync, constants } from "node:fs";
+import { access } from "node:fs/promises";
+var NARROW_NO_BREAK_SPACE = "\u202F";
+function tryMacOSScreenshotPath(filePath) {
+  return filePath.replace(/ (AM|PM)\./gi, `${NARROW_NO_BREAK_SPACE}$1.`);
+}
+function tryNFDVariant(filePath) {
+  return filePath.normalize("NFD");
+}
+function tryCurlyQuoteVariant(filePath) {
+  return filePath.replace(/'/g, "\u2019");
+}
+function fileExists(filePath) {
+  try {
+    return accessSync(filePath, constants.F_OK), !0;
+  } catch {
+    return !1;
+  }
+}
+async function pathExists(filePath) {
+  try {
+    return await access(filePath, constants.F_OK), !0;
+  } catch {
+    return !1;
+  }
+}
+function resolveToCwd(filePath, cwd) {
+  return resolvePath(filePath, cwd, { normalizeUnicodeSpaces: !0, stripAtPrefix: !0 });
+}
+function resolveReadPath(filePath, cwd) {
+  let resolved = resolveToCwd(filePath, cwd);
+  if (fileExists(resolved))
+    return resolved;
+  let amPmVariant = tryMacOSScreenshotPath(resolved);
+  if (amPmVariant !== resolved && fileExists(amPmVariant))
+    return amPmVariant;
+  let nfdVariant = tryNFDVariant(resolved);
+  if (nfdVariant !== resolved && fileExists(nfdVariant))
+    return nfdVariant;
+  let curlyVariant = tryCurlyQuoteVariant(resolved);
+  if (curlyVariant !== resolved && fileExists(curlyVariant))
+    return curlyVariant;
+  let nfdCurlyVariant = tryCurlyQuoteVariant(nfdVariant);
+  return nfdCurlyVariant !== resolved && fileExists(nfdCurlyVariant) ? nfdCurlyVariant : resolved;
+}
+async function resolveReadPathAsync(filePath, cwd) {
+  let resolved = resolveToCwd(filePath, cwd);
+  if (await pathExists(resolved))
+    return resolved;
+  let amPmVariant = tryMacOSScreenshotPath(resolved);
+  if (amPmVariant !== resolved && await pathExists(amPmVariant))
+    return amPmVariant;
+  let nfdVariant = tryNFDVariant(resolved);
+  if (nfdVariant !== resolved && await pathExists(nfdVariant))
+    return nfdVariant;
+  let curlyVariant = tryCurlyQuoteVariant(resolved);
+  if (curlyVariant !== resolved && await pathExists(curlyVariant))
+    return curlyVariant;
+  let nfdCurlyVariant = tryCurlyQuoteVariant(nfdVariant);
+  return nfdCurlyVariant !== resolved && await pathExists(nfdCurlyVariant) ? nfdCurlyVariant : resolved;
+}
+
+// packages/coding-agent/dist/core/protected-targets.js
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+var GLOBAL_AGENTS_FILE_WRITE_BLOCK_REASON = "The agents instruction tree is user-managed. The agent cannot change ~/.lunr/agent/agents/.", MEMORY_FILE_DIRECT_WRITE_BLOCK_REASON = "Memory is model-managed through the memory tools. Do not directly change ~/.lunr/simple-memory/memory.md.", SETTINGS_FILE_DIRECT_WRITE_BLOCK_REASON = "lunR settings are user-managed through /settings. Do not directly change settings.json.";
+function normalize(path) {
+  let normalized = resolve(path);
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function isWithin(target, root) {
+  let rel = relative(root, target);
+  return rel === "" || !isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${sep}`);
+}
+function protectedTargetWriteReason(path, cwd) {
+  try {
+    let target = resolveToCwd(path, cwd), targets = [normalize(target), normalize(canonicalizeTargetPath(target))], agentDir = getAgentDir(), policies = [
+      { path: getInstructionsRoot(agentDir), tree: !0, reason: GLOBAL_AGENTS_FILE_WRITE_BLOCK_REASON },
+      { path: join(dirname(agentDir), "simple-memory", "memory.md"), reason: MEMORY_FILE_DIRECT_WRITE_BLOCK_REASON },
+      { path: join(agentDir, "settings.json"), reason: SETTINGS_FILE_DIRECT_WRITE_BLOCK_REASON },
+      { path: join(cwd, CONFIG_DIR_NAME, "settings.json"), reason: SETTINGS_FILE_DIRECT_WRITE_BLOCK_REASON },
+      {
+        path: join(agentDir, "install-features.json"),
+        reason: "Optional features are user-managed through lunr features; Browser is managed in /settings. Do not change install-features.json directly."
+      }
+    ];
+    for (let policy of policies) {
+      let roots = [normalize(policy.path), normalize(canonicalizeTargetPath(policy.path))];
+      if (targets.some((candidate) => roots.some((root) => policy.tree ? isWithin(candidate, root) : candidate === root)))
+        return policy.reason;
+    }
+  } catch (error) {
+    return `Cannot validate mutation target: ${error instanceof Error ? error.message : String(error)}`;
+  }
+}
+
+export {
+  pathExists,
+  resolveToCwd,
+  resolveReadPath,
+  resolveReadPathAsync,
+  protectedTargetWriteReason
+};

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

@@ -0,0 +1,290 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  Client,
+  StdioClientTransport
+} from "./chunk-VSUEAI7O.js";
+import {
+  CUA_VERSION,
+  installRuntime,
+  runtimeEnvironment
+} from "./chunk-ZIQUS5QO.js";
+
+// packages/coding-agent/dist/core/computer-use/adapter.js
+import { mkdir, mkdtemp as mkdtemp2, realpath as realpath2, rm as rm2 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join3 } from "node:path";
+import { setTimeout as delay2 } from "node:timers/promises";
+
+// packages/coding-agent/dist/core/computer-use/macos-runtime.js
+import { execFile, spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { mkdtemp, open, realpath, rm } from "node:fs/promises";
+import { connect } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { promisify } from "node:util";
+var exec = promisify(execFile);
+function macLaunchArguments(app, socket, home, lifetime) {
+  let environment = {
+    HOME: home,
+    ...Object.fromEntries(Object.entries(runtimeEnvironment()).filter(([name]) => name.startsWith("CUA_")))
+  };
+  return [
+    "-n",
+    "-g",
+    "-W",
+    "-a",
+    app,
+    "--stdin",
+    lifetime,
+    ...Object.entries(environment).flatMap(([name, value]) => ["--env", `${name}=${value}`]),
+    "--args",
+    "serve",
+    "--embedded",
+    "--parent-liveness-stdio",
+    "--socket",
+    socket,
+    "--permission-mode",
+    "standard",
+    "--no-overlay"
+  ];
+}
+function request(socket, method, args) {
+  return new Promise((resolve, reject) => {
+    let stream = connect(socket), buffer = "";
+    stream.setTimeout(1e3, () => stream.destroy(new Error("Private computer endpoint timed out."))), stream.on("error", reject), stream.on("connect", () => stream.write(`${JSON.stringify({ method, args })}
+`)), stream.on("data", (chunk) => {
+      if (buffer += chunk.toString(), buffer.length > 65536) {
+        stream.destroy(new Error("Invalid private endpoint metadata."));
+        return;
+      }
+      if (buffer.includes(`
+`)) {
+        try {
+          let reply = JSON.parse(buffer.slice(0, buffer.indexOf(`
+`)));
+          if (!reply || typeof reply != "object" || !("result" in reply) || !reply.result || typeof reply.result != "object")
+            throw new Error("Private endpoint refused metadata.");
+          resolve(Object.fromEntries(Object.entries(reply.result)));
+        } catch (error) {
+          reject(error);
+        }
+        stream.destroy();
+      }
+    }), stream.on("end", () => reject(new Error("Private computer endpoint closed.")));
+  });
+}
+var MacRuntime = class {
+  directory;
+  lifetime;
+  exited;
+  pid;
+  get processId() {
+    return this.pid;
+  }
+  socket;
+  closing;
+  async start(app, signal) {
+    let directory = await mkdtemp(join(await realpath(tmpdir()), "lunr-cua-"));
+    this.directory = directory;
+    let socket = join(directory, "driver.sock");
+    this.socket = socket;
+    let lifetime = join(directory, "lifetime");
+    await exec("/usr/bin/mkfifo", ["-m", "600", lifetime], { timeout: 5e3, signal }), this.lifetime = await open(lifetime, constants.O_RDWR), signal.throwIfAborted();
+    let launcher = spawn("/usr/bin/open", macLaunchArguments(app, socket, directory, lifetime), {
+      env: runtimeEnvironment(),
+      stdio: "ignore"
+    });
+    this.exited = new Promise((resolve, reject) => {
+      launcher.once("error", reject), launcher.once("exit", (code) => code === 0 ? resolve() : reject(new Error(`LaunchServices exited ${code}.`)));
+    }), this.exited.catch(() => {
+    });
+    let deadline = Date.now() + 15e3;
+    for (; Date.now() < deadline; ) {
+      signal.throwIfAborted();
+      try {
+        let metadata = await request(socket, "metadata");
+        if (metadata.driver_version !== CUA_VERSION || metadata.embedded !== !0 || typeof metadata.pid != "number" || metadata.pid < 1)
+          throw new Error("Private runtime has incompatible metadata.");
+        return this.pid = metadata.pid, socket;
+      } catch {
+        await Promise.race([
+          delay(100, void 0, { signal }),
+          this.exited.then(() => {
+            throw new Error("Computer app exited during startup.");
+          })
+        ]);
+      }
+    }
+    throw new Error("Private macOS runtime startup timed out. Check CuaDriver Accessibility and Screen Recording grants.");
+  }
+  close() {
+    return this.closing ??= this.stop(), this.closing;
+  }
+  async stop() {
+    if (await this.lifetime?.close(), this.lifetime = void 0, this.socket && this.pid && await request(this.socket, "shutdown_if_pid", { expected_pid: this.pid }).catch(() => {
+    }), this.exited) {
+      let timeout = new AbortController();
+      try {
+        await Promise.race([
+          this.exited,
+          delay(1e4, void 0, { signal: timeout.signal }).then(() => {
+            throw new Error("Owned macOS app shutdown is unconfirmed. Desktop lease retained.");
+          })
+        ]);
+      } finally {
+        timeout.abort();
+      }
+    }
+    this.directory && await rm(this.directory, { recursive: !0, force: !0 });
+  }
+};
+
+// packages/coding-agent/dist/core/computer-use/windows-desktop.js
+import { execFile as execFile2 } from "node:child_process";
+import { join as join2 } from "node:path";
+import { promisify as promisify2 } from "node:util";
+var exec2 = promisify2(execFile2), WINDOWS_DESKTOP_PROBE = `
+$ErrorActionPreference = 'Stop'
+Add-Type -TypeDefinition @'
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Text;
+public static class LunrDesktopProbe {
+ [DllImport("user32.dll", SetLastError=true)] static extern IntPtr OpenInputDesktop(uint flags, bool inherit, uint access);
+ [DllImport("user32.dll")] static extern bool CloseDesktop(IntPtr desktop);
+ [DllImport("user32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern bool GetUserObjectInformation(IntPtr handle, int index, StringBuilder info, uint length, out uint needed);
+ [DllImport("wtsapi32.dll", SetLastError=true)] static extern bool WTSQuerySessionInformation(IntPtr server, int session, int info, out IntPtr buffer, out uint bytes);
+ [DllImport("wtsapi32.dll")] static extern void WTSFreeMemory(IntPtr buffer);
+ public static bool Ready() {
+  int session = Process.GetCurrentProcess().SessionId;
+  if (session == 0) return false;
+  IntPtr buffer; uint bytes;
+  if (!WTSQuerySessionInformation(IntPtr.Zero, session, 8, out buffer, out bytes)) return false;
+  try { if (bytes < 4 || Marshal.ReadInt32(buffer) != 0) return false; }
+  finally { WTSFreeMemory(buffer); }
+  IntPtr desktop = OpenInputDesktop(0, false, 1);
+  if (desktop == IntPtr.Zero) return false;
+  try {
+   var name = new StringBuilder(256); uint needed;
+   return GetUserObjectInformation(desktop, 2, name, 512, out needed) && name.ToString() == "Default";
+  } finally { CloseDesktop(desktop); }
+ }
+}
+'@
+if ([LunrDesktopProbe]::Ready()) { 'ready' } else { 'unavailable' }
+`;
+async function assertInteractiveDesktop(signal) {
+  if (process.platform !== "win32")
+    return;
+  let command = join2(process.env.SystemRoot ?? "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe"), { stdout } = await exec2(command, ["-NoProfile", "-NonInteractive", "-Command", WINDOWS_DESKTOP_PROBE], {
+    timeout: 5e3,
+    windowsHide: !0,
+    signal
+  });
+  if (stdout.trim() !== "ready")
+    throw new Error("Computer use requires an active, unlocked Windows desktop. No login, unlock, or elevation is attempted.");
+}
+
+// packages/coding-agent/dist/core/computer-use/adapter.js
+var DriverCallError = class extends Error {
+  phase;
+  dispatched;
+  constructor(phase, dispatched) {
+    super(phase === "adapter_preflight" ? "Computer adapter preflight failed." : "Computer native request failed."), this.phase = phase, this.dispatched = dispatched;
+  }
+}, CuaAdapter = class {
+  client;
+  transport;
+  mac;
+  stateDirectory;
+  connecting;
+  closing;
+  abort = new AbortController();
+  processObserver;
+  setProcessObserver(observer) {
+    this.processObserver = observer;
+  }
+  async connect(signal) {
+    let { command, app } = await installRuntime(signal);
+    signal.throwIfAborted();
+    let args = ["mcp", "--direct", "--embedded", "--no-overlay"];
+    app && (this.mac = new MacRuntime(), args = ["mcp", "--embedded", "--socket", await this.mac.start(app, signal), "--no-overlay"]), signal.throwIfAborted();
+    let state = await mkdtemp2(join3(await realpath2(tmpdir2()), "lunr-cua-client-"));
+    this.stateDirectory = state;
+    let appData = join3(state, "AppData");
+    if (await mkdir(appData), signal.throwIfAborted(), this.transport = new StdioClientTransport({
+      command,
+      args,
+      stderr: "pipe",
+      env: {
+        ...runtimeEnvironment(),
+        HOME: state,
+        USERPROFILE: state,
+        APPDATA: appData,
+        LOCALAPPDATA: appData,
+        XDG_CONFIG_HOME: appData,
+        XDG_STATE_HOME: appData
+      }
+    }), this.transport.stderr?.on("data", () => {
+    }), this.client = new Client({ name: "lunr-computer-use", version: CUA_VERSION }), await this.client.connect(this.transport, { timeout: 15e3, signal }), signal.throwIfAborted(), this.client.getServerVersion()?.version !== CUA_VERSION)
+      throw new Error("Computer runtime version mismatch.");
+    let pids = [this.transport.pid, ...this.mac ? [this.mac.processId] : []];
+    for (let pid of pids) {
+      if (typeof pid != "number" || !Number.isInteger(pid) || pid < 1)
+        throw new Error("Computer runtime process identity is missing. Input refused.");
+      await this.processObserver?.(pid);
+    }
+  }
+  async call(name, args, signal) {
+    let combined = AbortSignal.any([this.abort.signal, ...signal ? [signal] : []]);
+    combined.throwIfAborted();
+    let dispatched = !1;
+    try {
+      if (await assertInteractiveDesktop(combined), combined.throwIfAborted(), this.connecting ??= this.connect(AbortSignal.any([combined, AbortSignal.timeout(6e4)])), await this.connecting, combined.throwIfAborted(), !this.client)
+        throw new Error("Computer connection closed.");
+      return dispatched = !0, await this.client.callTool({ name, arguments: args }, void 0, {
+        timeout: name === "launch_app" ? 45e3 : 15e3,
+        signal: combined
+      });
+    } catch (error) {
+      let wasCancelled = combined.aborted;
+      try {
+        await this.close();
+      } catch {
+      }
+      throw wasCancelled ? error : new DriverCallError(dispatched ? "native_request" : "adapter_preflight", dispatched);
+    }
+  }
+  close() {
+    return this.abort.abort(), this.closing ??= this.stop(), this.closing;
+  }
+  async stop() {
+    await this.connecting?.catch(() => {
+    });
+    let pid = this.transport?.pid;
+    if (await this.client?.close(), await this.transport?.close(), pid) {
+      let deadline = Date.now() + 5e3;
+      for (; ; ) {
+        try {
+          process.kill(pid, 0);
+        } catch (error) {
+          if (error instanceof Error && "code" in error && error.code === "ESRCH")
+            break;
+          throw error;
+        }
+        if (Date.now() >= deadline)
+          throw new Error("Owned computer process shutdown is unconfirmed. Desktop lease retained.");
+        await delay2(50);
+      }
+    }
+    await this.mac?.close(), this.stateDirectory && await rm2(this.stateDirectory, { recursive: !0, force: !0 }), this.client = void 0, this.transport = void 0;
+  }
+};
+
+export {
+  DriverCallError,
+  CuaAdapter
+};

package/dist/node-runtime/{chunk-GYIXXQAO.js → chunk-FIRA54AC.js}

@@ -5,7 +5,7 @@ import {
 import {
   buildSessionContext,
   sessionEntryToContextMessages
-} from "./chunk-2KIPT4HJ.js";
+} from "./chunk-EPR2F3GU.js";
 import {
   convertToLlm,
   createBranchSummaryMessage,
@@ -14,7 +14,7 @@ import {
 } from "./chunk-FVDOXRUD.js";
 import {
   isValidThinkingLevel
-} from "./chunk-E24EO34J.js";
+} from "./chunk-WPXUR3HE.js";
 
 // packages/coding-agent/dist/core/compaction/utils.js
 function createFileOps() {
@@ -921,9 +921,6 @@ async function findInitialModel(options) {
 }
 
 export {
-  createFileOps,
-  extractFileOpsFromMessage,
-  computeFileLists,
   serializeConversation,
   DEFAULT_COMPACTION_SETTINGS,
   calculateContextTokens,

package/dist/node-runtime/{chunk-6VYZ5UFP.js → chunk-FLGEEH27.js}

@@ -1,7 +1,7 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
 import {
   theme
-} from "./chunk-RDDAZOMU.js";
+} from "./chunk-JL4HYQXK.js";
 
 // packages/coding-agent/dist/modes/interactive/components/dynamic-border.js
 var DynamicBorder = class {