@poe-platform/safe-bash 0.1.817 → 0.1.819

package/dist/safe-bash/command-chunks/{chunk-PU5DMQGG.js → chunk-RESJSUHH.js}

@@ -1,6 +1,6 @@
 import {
   OfficeError
-} from "./chunk-KM2SMMXZ.js";
+} from "./chunk-VJQ5OWS5.js";
 
 // packages/safe-bash-presentation-engine/src/font-metrics.ts
 var tables = /* @__PURE__ */ new WeakMap();

package/dist/safe-bash/command-chunks/{chunk-OCOJMKDP.js → chunk-RHXV2KG5.js}

@@ -1,10 +1,3 @@
-import {
-  PythonInvocationError,
-  parsePythonInvocation
-} from "./chunk-5EFNQ6FY.js";
-import {
-  pythonLlmProvider
-} from "./chunk-NQL3WNFI.js";
 import {
   createPythonPackageEnvironment,
   pythonDocumentPackages
@@ -12,6 +5,13 @@ import {
 import {
   pythonShellDispatchActive
 } from "./chunk-NHAG4DWL.js";
+import {
+  PythonInvocationError,
+  parsePythonInvocation
+} from "./chunk-5EFNQ6FY.js";
+import {
+  pythonLlmProvider
+} from "./chunk-YYRVGXJH.js";
 import {
   PythonFailure,
   isPythonFailureCategory,
@@ -179,6 +179,471 @@ import { readBytes, writeBytes } from "../../safe-bash-contracts/io.js";
 import { createOutputOperation } from "../../safe-bash-contracts/output.js";
 import { inheritYieldCheckpoint, yieldTurn } from "../../safe-bash-contracts/yield.js";
 
+// packages/safe-bash-command-python/src/llm-functions-loader.ts
+import { createLlmSpool, createLlmToolRegistry } from "../../safe-bash-command-llm/index.js";
+import { toByteSource } from "../../safe-bash-contracts/index.js";
+
+// packages/safe-bash-command-python/src/llm-functions-program.ts
+var pythonLlmFunctionsProgram = /* @__PURE__ */ (() => String.raw`
+import asyncio, codecs, inspect, json
+import safe_host
+from _poe_llm_capability import bridge
+from llm.cli import _tools_from_code, _gather_tools
+from llm import ToolOutput, Tool, Toolbox, get_tools, get_plugins
+from llm.models import _wrap_tools, _get_instance
+from llm_safe_host import _attachment_type
+
+
+def send(op, **fields):
+    return safe_host.call("llm_tools", dict(op=op, **fields))
+
+
+def load_definition(definition):
+    if "\n" in definition or not definition.endswith(".py"):
+        send("admit", size=len(definition.encode("utf-8")))
+        return definition
+    decoder = codecs.getincrementaldecoder("utf-8")()
+    chunks = []
+    try:
+        with open(definition, "rb") as source:
+            for chunk in iter(lambda: source.read(4096), b""):
+                send("admit", size=len(chunk))
+                chunks.append(decoder.decode(chunk))
+            chunks.append(decoder.decode(b"", final=True))
+    except FileNotFoundError:
+        from click import ClickException
+        raise ClickException("File not found: " + definition)
+    code = "".join(chunks).replace("\r\n", "\n").replace("\r", "\n")
+    return code + "\n" if "\n" not in code and code.endswith(".py") else code
+
+
+def write_text(identifier, value):
+    for offset in range(0, len(value), 4096):
+        send("text", id=identifier, text=value[offset:offset + 4096])
+
+
+def write_attachment(identifier, attachment):
+    mime = _attachment_type(attachment)
+    if attachment.content:
+        descriptor = dict(mimeType=mime, id=attachment.id())
+        handle = send("attachment", id=identifier, descriptor=descriptor)
+        content = memoryview(attachment.content)
+        for offset in range(0, len(content), 4096):
+            send("bytes", id=identifier, attachment=handle, bytes=list(content[offset:offset + 4096]))
+    elif attachment.path:
+        handle = send("attachment", id=identifier, descriptor=dict(mimeType=mime, id=attachment.id()))
+        with open(attachment.path, "rb") as source:
+            for chunk in iter(lambda: source.read(4096), b""):
+                send("bytes", id=identifier, attachment=handle, bytes=list(chunk))
+    elif attachment.url:
+        send("attachment", id=identifier, descriptor=dict(mimeType=mime, id=attachment.id(), url=attachment.url))
+    else:
+        send("attachment", id=identifier, descriptor=dict(mimeType=mime, id=attachment.id()))
+
+
+async def main():
+    definitions = send("definitions")
+    selection = send("selection")
+    names = selection.get("names", [])
+    discovery = selection.get("discovery", False)
+    tools = []
+    try:
+        plugin_query = selection.get("pluginQuery")
+        if plugin_query is not None:
+            plugins = get_plugins(plugin_query["all"])
+            hooks = set(plugin_query["hooks"])
+            if hooks:
+                plugins = [plugin for plugin in plugins if hooks.intersection(plugin["hooks"])]
+            send("plugins", plugins=plugins)
+        registered = get_tools() if discovery and not names else {}
+        functions = []
+        for definition in definitions:
+            functions.extend(_tools_from_code(load_definition(definition)))
+        if discovery:
+            if names:
+                registered = {tool.name: tool for tool in functions + _gather_tools(names, [])}
+            else:
+                for tool in functions:
+                    registered[tool.name] = tool
+            entries = [(key, tool, None) for key, tool in registered.items()]
+        else:
+            entries = [(tool.name, tool, None) for tool in functions]
+            for selection_index, selected in enumerate(_gather_tools(names, [])):
+                entries.extend((tool.name, tool, selection_index) for tool in _wrap_tools([selected]))
+        for key, tool, selection_index in entries:
+            if not isinstance(tool, Tool):
+                methods = []
+                for method in tool.method_tools():
+                    methods.append(dict(name=method.name, description=method.description,
+                        inputSchema=method.input_schema,
+                        signature=str(inspect.signature(method.implementation)).replace("(self, ", "(").replace("(self)", "()")))
+                send("toolbox", name=key, tools=methods)
+                continue
+            index = len(tools)
+            tools.append(tool)
+            send("register", index=index, name=tool.name, registryKey=key, description=tool.description,
+                 plugin=tool.plugin, selectionIndex=selection_index, inputSchema=tool.input_schema,
+                 signature=str(inspect.signature(tool.implementation)),
+                 asynchronous=inspect.iscoroutinefunction(tool.implementation))
+    except Exception as error:
+        send("failed", message=getattr(error, "message", str(error)))
+        return
+    send("ready", prepare=any(isinstance(_get_instance(tool.implementation), Toolbox) for tool in tools))
+    pending = set()
+    cancelled = False
+
+    async def execute(command):
+        identifier = command["id"]
+        try:
+            if command.get("prepare"):
+                asynchronous = command.get("asynchronous", False)
+                flag = "_async_prepared" if asynchronous else "_prepared"
+                instances = []
+                for tool in {tool.name: tool for tool in tools}.values():
+                    instance = _get_instance(tool.implementation)
+                    if isinstance(instance, Toolbox) and not getattr(instance, flag, False):
+                        instances.append(instance)
+                for instance in instances:
+                    if asynchronous:
+                        await instance.prepare_async()
+                    else:
+                        instance.prepare()
+                    setattr(instance, flag, True)
+                send("done", id=identifier)
+                return
+            output = tools[command["tool"]].implementation(**command["arguments"])
+            if inspect.isawaitable(output):
+                output = await output
+            attachments = []
+            if isinstance(output, ToolOutput):
+                attachments, output = output.attachments, output.output
+            if not isinstance(output, str):
+                output = json.dumps(output, default=repr)
+            write_text(identifier, output)
+            for attachment in attachments:
+                write_attachment(identifier, attachment)
+            send("done", id=identifier)
+        except Exception as error:
+            send("error", id=identifier, message=str(error))
+
+    def completed(task):
+        pending.discard(task)
+        # Host transport failures already reject all outstanding calls. Retrieve
+        # the exception so a completed task cannot leak an unobserved failure.
+        if not task.cancelled():
+            task.exception()
+
+    try:
+        while True:
+            command = await bridge.wait("begin", capability="llm_tools", value=dict(op="next"))
+            if command is None:
+                break
+            if command.get("cancel"):
+                cancelled = True
+                break
+            task = asyncio.create_task(execute(command))
+            pending.add(task)
+            task.add_done_callback(completed)
+        if pending and not cancelled:
+            await asyncio.gather(*pending)
+    finally:
+        for task in pending:
+            task.cancel()
+        if pending:
+            await asyncio.gather(*pending, return_exceptions=True)
+
+asyncio.run(main())
+`)();
+
+// packages/safe-bash-command-python/src/llm-functions-loader.ts
+function deferred() {
+  let resolve, reject;
+  const promise = new Promise((yes, no) => {
+    resolve = yes;
+    reject = no;
+  });
+  return { promise, resolve, reject };
+}
+function record(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Invalid Python tool protocol");
+  return value;
+}
+function createPythonLlmToolLoader(options) {
+  if (!options.createExecutor) throw new TypeError("Python tool loading requires an asynchronous executor");
+  const capabilitiesByArguments = /* @__PURE__ */ new WeakMap();
+  const command = createPythonExecutorCommands({ ...options, createCapabilities: (current) => {
+    const capabilities = options.createCapabilities?.(current) ?? {};
+    if (capabilities.llm_tools) throw new Error("Python tool capability is reserved");
+    const capability = capabilitiesByArguments.get(current.args);
+    if (!capability) throw new Error("Unknown Python tool invocation");
+    return { ...capabilities, llm_tools: capability };
+  } })[0];
+  return async ({ context, definitions, toolNames = [], discovery = false, pluginQuery, maxInputBytes, maxOutputBytes }) => {
+    if (!Array.isArray(definitions) || definitions.some((value) => typeof value !== "string")) throw new TypeError("Python tool definitions must be strings");
+    if (!Array.isArray(toolNames) || toolNames.some((value) => typeof value !== "string") || typeof discovery !== "boolean") throw new TypeError("Invalid Python tool selection");
+    if (pluginQuery && (typeof pluginQuery.all !== "boolean" || !Array.isArray(pluginQuery.hooks) || pluginQuery.hooks.some((value) => typeof value !== "string"))) throw new TypeError("Invalid Python plugin query");
+    for (const limit of [maxInputBytes, maxOutputBytes]) if (limit !== Infinity && (!Number.isSafeInteger(limit) || limit < 0)) throw new RangeError("Invalid Python tool byte limit");
+    context.signal.throwIfAborted();
+    const controller = new AbortController();
+    const runtimeController = new AbortController();
+    const signal = AbortSignal.any([context.signal, controller.signal]);
+    const ready = deferred();
+    const tools = [];
+    const toolboxes = [];
+    let plugins;
+    const spools = /* @__PURE__ */ new Set();
+    const jobs = /* @__PURE__ */ new Map();
+    const queue = [];
+    let waiter;
+    let serial = 0, controls = 0, loaded = false, initializationFailed = false, closed = false, closing;
+    const encoder = new TextEncoder();
+    const fail = (error) => {
+      ready.reject(error);
+      queue.length = 0;
+      if (waiter) {
+        waiter.resolve({ cancel: true });
+        waiter = void 0;
+      } else queue.push({ cancel: true });
+      for (const job of jobs.values()) job.result.reject(error);
+      jobs.clear();
+      controller.abort(error);
+    };
+    const aborted = () => fail(signal.reason);
+    signal.addEventListener("abort", aborted, { once: true });
+    const spool = async () => {
+      const value = await createLlmSpool(context.fs, context.cwd, signal);
+      spools.add(value);
+      if (closed || signal.aborted) {
+        await value.close();
+        spools.delete(value);
+        signal.throwIfAborted();
+        throw new Error("Python tool session is closed");
+      }
+      return value;
+    };
+    const source = (value) => ({ bytes: value.replay(), async dispose() {
+      try {
+        await value.close();
+      } finally {
+        spools.delete(value);
+      }
+    } });
+    const invoke = async (fields, callContext) => {
+      signal.throwIfAborted();
+      callContext.signal.throwIfAborted();
+      if (closed) throw new Error("Python tool session is closed");
+      const stop = () => fail(callContext.signal.reason);
+      callContext.signal.addEventListener("abort", stop, { once: true });
+      let output;
+      try {
+        output = await spool();
+        callContext.signal.throwIfAborted();
+        const result = deferred(), id = ++serial;
+        jobs.set(id, { result, output, attachments: [], files: /* @__PURE__ */ new Map(), bytes: 0, limit: Math.min(callContext.maxBytes, maxOutputBytes) });
+        const request = { id, ...fields };
+        if (waiter) {
+          waiter.resolve(request);
+          waiter = void 0;
+        } else queue.push(request);
+        return await result.promise;
+      } catch (error) {
+        if (output) {
+          await output.close();
+          spools.delete(output);
+        }
+        throw error;
+      } finally {
+        callContext.signal.removeEventListener("abort", stop);
+      }
+    };
+    const prepare = async (callContext, mode) => {
+      const result = await invoke({ prepare: true, asynchronous: mode.async }, callContext);
+      await result.source?.dispose();
+    };
+    const dispatch = async (value) => {
+      const message = record(value);
+      if (message.op !== "next" && message.op !== "failed") signal.throwIfAborted();
+      if (message.op === "definitions") return [...definitions];
+      if (message.op === "selection") return { names: [...toolNames], discovery, ...pluginQuery ? { pluginQuery: { all: pluginQuery.all, hooks: [...pluginQuery.hooks] } } : {} };
+      if (message.op === "admit") {
+        if (typeof message.size !== "number" || !Number.isSafeInteger(message.size) || message.size < 0) throw new TypeError("Invalid Python definition byte count");
+        controls += message.size;
+        if (controls > maxInputBytes) {
+          const error = new RangeError("Python tool definition byte limit exceeded");
+          fail(error);
+          throw error;
+        }
+        return null;
+      }
+      if (message.op === "failed") {
+        initializationFailed = true;
+        fail(new Error(String(message.message)));
+        return null;
+      }
+      if (message.op === "register" || message.op === "toolbox" || message.op === "plugins") {
+        controls += encoder.encode(JSON.stringify(message)).length;
+        if (controls > maxInputBytes) throw new RangeError("Python tool definition byte limit exceeded");
+      }
+      if (message.op === "plugins") {
+        if (loaded || plugins || !pluginQuery || !Array.isArray(message.plugins)) throw new TypeError("Invalid Python plugin discovery");
+        plugins = Object.freeze(message.plugins.map((value2) => {
+          const plugin = record(value2);
+          if (typeof plugin.name !== "string" || !Array.isArray(plugin.hooks) || plugin.hooks.some((hook) => typeof hook !== "string") || plugin.version !== void 0 && typeof plugin.version !== "string") throw new TypeError("Invalid Python plugin metadata");
+          return Object.freeze({ name: plugin.name, hooks: Object.freeze(plugin.hooks), ...typeof plugin.version === "string" ? { version: plugin.version } : {} });
+        }));
+        return null;
+      }
+      if (message.op === "toolbox") {
+        if (loaded || typeof message.name !== "string" || !Array.isArray(message.tools)) throw new TypeError("Invalid Python toolbox registration");
+        const methods = message.tools.map((value2) => {
+          const method = record(value2);
+          const tool = {
+            name: String(method.name),
+            inputSchema: record(method.inputSchema),
+            ...typeof method.description === "string" ? { description: method.description } : {},
+            ...typeof method.signature === "string" ? { signature: method.signature } : {}
+          };
+          if (typeof method.name !== "string") throw new TypeError("Invalid Python toolbox method");
+          createLlmToolRegistry([tool]);
+          return tool;
+        });
+        toolboxes.push({ name: message.name, tools: methods });
+        return null;
+      }
+      if (message.op === "register") {
+        if (loaded || message.index !== tools.length || typeof message.name !== "string" || typeof message.signature !== "string" || typeof message.asynchronous !== "boolean") throw new TypeError("Invalid Python tool registration");
+        const index = tools.length;
+        const tool = {
+          name: message.name,
+          inputSchema: record(message.inputSchema),
+          signature: message.signature,
+          ...typeof message.description === "string" ? { description: message.description } : {},
+          ...typeof message.plugin === "string" ? { plugin: message.plugin } : {},
+          ...typeof message.registryKey === "string" ? { registryKey: message.registryKey } : {},
+          ...typeof message.selectionIndex === "number" ? { selectionIndex: message.selectionIndex } : {},
+          async: message.asynchronous,
+          async implementation(args, callContext) {
+            return invoke({ tool: index, arguments: args }, callContext);
+          }
+        };
+        createLlmToolRegistry([tool]);
+        tools.push(tool);
+        return null;
+      }
+      if (message.op === "ready") {
+        if (loaded) throw new Error("Python tools already loaded");
+        if (message.prepare === true) for (let index = 0; index < tools.length; index++) tools[index] = { ...tools[index], prepare };
+        loaded = true;
+        ready.resolve();
+        return null;
+      }
+      if (message.op === "next") {
+        if (signal.aborted) return { cancel: true };
+        if (!loaded || waiter) throw new Error("Invalid Python tool request queue");
+        if (queue.length) return queue.shift();
+        waiter = deferred();
+        return waiter.promise;
+      }
+      if (typeof message.id !== "number") throw new TypeError("Invalid Python tool call identity");
+      const job = jobs.get(message.id);
+      if (!job) throw new Error("Unknown Python tool call");
+      if (message.op === "text" || message.op === "bytes") {
+        let bytes, target = job.output;
+        if (message.op === "text") {
+          if (typeof message.text !== "string" || message.text.length > 8192) throw new TypeError("Invalid Python tool output window");
+          bytes = encoder.encode(message.text);
+          if (bytes.length > 16384) throw new TypeError("Invalid Python tool output window");
+        } else {
+          if (!Array.isArray(message.bytes) || message.bytes.length > 4096 || message.bytes.some((value2) => typeof value2 !== "number" || !Number.isInteger(value2) || value2 < 0 || value2 > 255)) throw new TypeError("Invalid Python attachment window");
+          if (typeof message.attachment !== "number" || !job.files.has(message.attachment)) throw new Error("Unknown Python attachment");
+          target = job.files.get(message.attachment);
+          bytes = Uint8Array.from(message.bytes);
+        }
+        if (bytes.length > job.limit - job.bytes) throw new RangeError("Python tool output byte limit exceeded");
+        job.bytes += bytes.length;
+        await target.write(bytes);
+        return null;
+      }
+      if (message.op === "attachment") {
+        const metadata = record(message.descriptor);
+        if (typeof metadata.mimeType !== "string" || typeof metadata.id !== "string" || metadata.url !== void 0 && typeof metadata.url !== "string") throw new TypeError("Invalid Python tool attachment");
+        const size = encoder.encode(JSON.stringify(metadata)).length;
+        if (size > job.limit - job.bytes) throw new RangeError("Python tool attachment metadata limit exceeded");
+        job.bytes += size;
+        const index = job.attachments.length;
+        if (metadata.url !== void 0) job.attachments.push({ mimeType: metadata.mimeType, id: metadata.id, url: metadata.url });
+        else {
+          const file = await spool();
+          job.files.set(index, file);
+          job.attachments.push({ mimeType: metadata.mimeType, id: metadata.id, source: source(file) });
+        }
+        return index;
+      }
+      if (message.op === "error") {
+        jobs.delete(message.id);
+        await Promise.all([job.output, ...job.files.values()].map(async (value2) => {
+          await value2.close();
+          spools.delete(value2);
+        }));
+        job.result.reject(new Error(String(message.message)));
+        return null;
+      }
+      if (message.op === "done") {
+        jobs.delete(message.id);
+        job.result.resolve({ source: source(job.output), attachments: job.attachments });
+        return null;
+      }
+      throw new TypeError("Invalid Python tool operation");
+    };
+    const capability = { async call(value) {
+      try {
+        return await dispatch(value);
+      } catch (error) {
+        fail(error);
+        throw error;
+      }
+    } };
+    const { registerCleanup: ignoredParentCleanup, ...isolatedContext } = context;
+    const invocation = { ...isolatedContext, signal: runtimeController.signal, command: "python", args: ["-c", pythonLlmFunctionsProgram], stdin: toByteSource("") };
+    capabilitiesByArguments.set(invocation.args, capability);
+    const running = Promise.resolve().then(() => command.execute(invocation)).then(
+      (result) => {
+        if (!closed) fail(new Error(`Python tool interpreter exited with status ${result.exitCode}`));
+      },
+      (error) => {
+        if (!closed) fail(error);
+      }
+    );
+    const close = () => closing ??= (async () => {
+      closed = true;
+      if (loaded && !signal.aborted && !jobs.size) {
+        if (waiter) {
+          waiter.resolve(null);
+          waiter = void 0;
+        } else queue.push(null);
+      } else {
+        controller.abort(new Error("Python tool session closed"));
+        if (!loaded && !initializationFailed) runtimeController.abort(signal.reason);
+      }
+      await running;
+      capabilitiesByArguments.delete(invocation.args);
+      controller.abort(new Error("Python tool session closed"));
+      signal.removeEventListener("abort", aborted);
+      await Promise.all([...spools].map((value) => value.close()));
+      spools.clear();
+    })();
+    context.registerCleanup?.(close);
+    try {
+      signal.throwIfAborted();
+      await ready.promise;
+      return { tools: Object.freeze(tools), toolboxes: Object.freeze(toolboxes), ...plugins ? { plugins } : {}, close };
+    } catch (error) {
+      await close();
+      throw error;
+    }
+  };
+}
+
 // packages/safe-bash-command-python/src/llm-manifest.ts
 var pythonLlmManifest = {
   "llm": "0.27.1",
@@ -489,7 +954,55 @@ function installPythonLlmPackages(runtime, assets) {
   runtime.FS.writeFile(metadata + "/entry_points.txt", new TextEncoder().encode("[llm]\nsafe_host = llm_safe_host\n"));
   runtime.globals.set("_safe_llm_wheel_paths", JSON.stringify(paths));
   try {
-    runtime.runPython('import json, sys; sys.path.extend(json.loads(_safe_llm_wheel_paths)); import llm.plugins; llm.plugins.DEFAULT_PLUGINS = (); llm.plugins.LLM_LOAD_PLUGINS = "llm-safe-host"; llm.plugins.load_plugins(); from llm_safe_host import restrict_providers; restrict_providers()');
+    runtime.runPython(String.raw`
+import json, sys
+sys.path.extend(json.loads(_safe_llm_wheel_paths))
+def _install_safe_llm_import():
+    if any(getattr(finder, "_safe_llm_provider", False) for finder in sys.meta_path):
+        return
+    def configure_plugins(module):
+        module.DEFAULT_PLUGINS = ("llm.default_plugins.default_tools",)
+        module.LLM_LOAD_PLUGINS = "llm-safe-host"
+
+    def configure_provider(module):
+        configure_plugins(module.plugins)
+        module.plugins.load_plugins()
+        from llm_safe_host import restrict_providers
+        restrict_providers()
+
+    class HostLlmFinder:
+        _safe_llm_provider = True
+        def find_spec(self, fullname, path=None, target=None):
+            if fullname not in ("llm", "llm.plugins"):
+                return None
+            for finder in tuple(sys.meta_path):
+                if finder is self:
+                    continue
+                spec = finder.find_spec(fullname, path, target)
+                if spec is None:
+                    continue
+                original = spec.loader
+                class HostLlmLoader:
+                    def create_module(self, spec):
+                        return original.create_module(spec)
+                    def exec_module(self, module):
+                        original.exec_module(module)
+                        if fullname == "llm.plugins":
+                            configure_plugins(module)
+                        else:
+                            configure_provider(module)
+                    def __getattr__(self, name):
+                        return getattr(original, name)
+                spec.loader = HostLlmLoader()
+                return spec
+            return None
+
+    sys.meta_path.insert(0, HostLlmFinder())
+    if "llm" in sys.modules:
+        configure_provider(sys.modules["llm"])
+_install_safe_llm_import()
+del _install_safe_llm_import
+`);
   } finally {
     runtime.globals.delete("_safe_llm_wheel_paths");
   }
@@ -945,6 +1458,7 @@ function pythonExecutorCommands(options) {
 }
 
 export {
+  createPythonLlmToolLoader,
   pythonLlmPackages,
   installPythonLlmPackages,
   createPythonExecutorCommands,

package/dist/safe-bash/command-chunks/{chunk-7B2MHKIW.js → chunk-RKON2TGI.js}

@@ -1,7 +1,7 @@
 import {
   InvalidHandleError,
   ValueError
-} from "./chunk-G3FK5VVG.js";
+} from "./chunk-HTBUIRTH.js";
 
 // packages/safe-bash-presentation-engine/src/xml-view.ts
 var states = /* @__PURE__ */ new WeakMap();

package/dist/safe-bash/command-chunks/{chunk-OIHQXURE.js → chunk-ROE6KD4C.js}

@@ -5,7 +5,7 @@ import {
   UnsupportedEditError,
   activeXmlChildren,
   displayXml
-} from "./chunk-LZY46GYY.js";
+} from "./chunk-QMWBKR4C.js";
 import {
   documentDialects
 } from "./chunk-WLANDWNW.js";

package/dist/safe-bash/command-chunks/{chunk-ITXSHOLP.js → chunk-RQTFK7AV.js}

@@ -2,12 +2,12 @@ import {
   equal,
   indexValue,
   sliceValue
-} from "./chunk-VWRHPDCD.js";
+} from "./chunk-ZIDESNHW.js";
 import {
   JqError,
   JqLimitError,
   isObject
-} from "./chunk-5VO534FR.js";
+} from "./chunk-3K5FCRUG.js";
 import {
   encoder
 } from "./chunk-KK2T6Z7J.js";

package/dist/safe-bash/command-chunks/{chunk-BKK4MS3V.js → chunk-RR6XG2I6.js}

@@ -1,7 +1,7 @@
 import {
   docxOperationSchemas,
   splitDocxType
-} from "./chunk-FEKECRJP.js";
+} from "./chunk-EBTKM7KX.js";
 
 // packages/safe-bash-docx-engine/src/part-provider.ts
 var nativeStoryTypes = ["DocumentPart", "StoryPart", "HeaderPart", "FooterPart", "CommentsPart"];

package/dist/safe-bash/command-chunks/{chunk-CFMJXJS5.js → chunk-RTUDDAAY.js}

@@ -80,6 +80,11 @@ var PatchPublication = class {
       if (parent2 === "/") break;
     }
     const context = this.context;
+    const capabilities = await host(context, async () => await context.fs.capabilitiesFor?.(path, { signal: context.signal, create: true }) ?? context.fs.capabilities);
+    const retained = !this.trusted && capabilities.retainedStagingCleanup === true && capabilities.retainedStagingWrite !== false;
+    if (!retained && (!context.fs.writeFileConditional || capabilities.atomicFileMutation !== true && capabilities.trustedOwnedStaging !== true)) {
+      throw new ToolError("filesystem does not support conditional staging writes");
+    }
     const parent = ancestors[ancestors.length - 1].stat;
     let staging;
     let operation;
@@ -105,15 +110,15 @@ var PatchPublication = class {
           data: new Uint8Array()
         }, {
           parent,
-          retainCleanup: !this.trusted,
+          retainCleanup: retained,
           signal: context.signal,
           ...mode === void 0 ? {} : { mode },
           ...mtimeMs === void 0 ? {} : { atimeMs: mtimeMs, mtimeMs }
         });
-        if (!this.trusted && (!staging.writer || !staging.cleanup)) throw new ToolError("filesystem does not support retained staging writes");
+        if (retained && (!staging.writer || !staging.cleanup)) throw new ToolError("filesystem does not support retained staging writes");
         for await (const bytes of readBytes(typeof source === "string" ? targetBytes(source) : source, context.signal)) {
           if (closed) throw new ToolError("patch publication is closed");
-          if (this.trusted) {
+          if (!retained) {
             const stat2 = await context.fs.writeFileConditional(staging.file.path, bytes, {
               parent: staging.directory.stat,
               expected: staging.file.stat,
@@ -125,7 +130,7 @@ var PatchPublication = class {
             staging = { ...staging, file: { ...staging.file, stat: stat2 } };
           } else await staging.writer.write(bytes, { signal: context.signal });
         }
-        const stat = this.trusted ? staging.file.stat : await staging.writer.finish({ signal: context.signal });
+        const stat = !retained ? staging.file.stat : await staging.writer.finish({ signal: context.signal });
         context.signal.throwIfAborted();
         if (closed) throw new ToolError("patch publication is closed");
         if (this.trusted) await this.validate(path);

package/dist/safe-bash/command-chunks/{chunk-FAU2KL6I.js → chunk-S5MBHFLB.js}

@@ -1,10 +1,10 @@
 import {
   PackageNotFoundError
-} from "./chunk-G3FK5VVG.js";
+} from "./chunk-HTBUIRTH.js";
 import {
   OfficeError,
   resolveOfficeResources
-} from "./chunk-KM2SMMXZ.js";
+} from "./chunk-VJQ5OWS5.js";
 
 // packages/safe-bash-presentation-engine/src/bytes.ts
 function admitLimits(context, options, output) {