@poe-platform/safe-bash 0.1.803 → 0.1.804

package/dist/safe-bash/chunks/chunk-GDYNCWRV.js

@@ -1,161 +0,0 @@
-import {
-  composeAgentCommands,
-  createAgentCommandPlugin,
-  createRegexExecutors
-} from "./chunk-RYFQ3LZG.js";
-import {
-  commandRuntimeIdentity
-} from "./chunk-7R5BDCG7.js";
-import {
-  init_platform
-} from "./chunk-B7TAL7S5.js";
-
-// packages/safe-bash/src/plugins/index.ts
-init_platform();
-
-// packages/safe-bash/src/lazy-gh.ts
-init_platform();
-
-// packages/safe-bash/src/plugins/lazy-command.ts
-init_platform();
-function createLazyCommandLoader(load) {
-  let pending;
-  return () => pending ??= Promise.resolve().then(load).catch((error) => {
-    pending = void 0;
-    throw error;
-  });
-}
-async function waitForCode(pending, signal) {
-  signal.throwIfAborted();
-  let abort;
-  const cancelled = new Promise((_resolve, reject) => {
-    abort = () => reject(signal.reason);
-    signal.addEventListener("abort", abort, { once: true });
-  });
-  try {
-    return await Promise.race([pending, cancelled]);
-  } finally {
-    signal.removeEventListener("abort", abort);
-  }
-}
-function createLazyCommands(metadata, load) {
-  return Object.freeze(
-    metadata.map(
-      (item) => Object.freeze({
-        ...item,
-        runtimeIdentity: commandRuntimeIdentity,
-        async execute(context) {
-          context.signal.throwIfAborted();
-          const factory = await waitForCode(load(), context.signal);
-          context.signal.throwIfAborted();
-          const definition = factory().find((command) => command.name === item.name);
-          if (!definition) throw new Error(`Lazy command loader did not provide ${item.name}`);
-          return definition.execute(context);
-        }
-      })
-    )
-  );
-}
-function lazyCommandPlugin(name, commands, replace = false) {
-  return {
-    name,
-    setup(host) {
-      if (!replace)
-        for (const command of commands) {
-          const existing = host.commands.get(command.name);
-          if (existing && !(command.fallback && !existing.fallback))
-            throw new Error(`Command already registered: ${command.name}`);
-        }
-      for (const command of commands) host.commands.register(command, { replace });
-    }
-  };
-}
-
-// packages/safe-bash/src/lazy-gh.ts
-var loadgh = /* @__PURE__ */ createLazyCommandLoader(() => import("./gh-6WU6PXL4.js"));
-var ghMetadata = [
-  { name: "gh", description: "Work seamlessly with GitHub from the command line" }
-];
-var createGhCommand = (options = {}) => {
-  const backends = /* @__PURE__ */ new WeakMap();
-  return createLazyCommands(ghMetadata, async () => {
-    const module = await loadgh();
-    return () => [{
-      ...ghMetadata[0],
-      async execute(context) {
-        let backend = options.backend ?? backends.get(context.fs);
-        if (!backend) {
-          backend = module.createGitHubBackend({
-            defaultHost: options.defaultHost,
-            defaultUser: options.defaultUser,
-            defaultToken: options.defaultToken,
-            now: options.now
-          });
-          backends.set(context.fs, backend);
-        }
-        return module.createGhCommand({ ...options, backend }).execute(context);
-      }
-    }];
-  })[0];
-};
-var createGhCommands = (options = {}) => [createGhCommand(options)];
-var ghCommands = (options = {}) => lazyCommandPlugin("gh-commands", createGhCommands(options), options.replace ?? false);
-
-// packages/safe-bash/src/plugins/worker-recipes.ts
-init_platform();
-var agentWorkerRecipes = /* @__PURE__ */ new WeakMap();
-var agentWorkerPlugins = /* @__PURE__ */ new WeakSet();
-function captureAgentWorkerRecipe(options) {
-  if (typeof structuredClone !== "function") return void 0;
-  const seen = /* @__PURE__ */ new Set();
-  const portable = (value) => {
-    if (value === null || typeof value !== "object") return typeof value !== "function" && typeof value !== "symbol";
-    if (seen.has(value)) return true;
-    seen.add(value);
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== null && prototype !== Object.prototype && prototype !== Array.prototype) return false;
-    if (Object.getOwnPropertySymbols(value).length) return false;
-    return Object.entries(Object.getOwnPropertyDescriptors(value)).every(([key, descriptor]) => "value" in descriptor && (descriptor.enumerable || Array.isArray(value) && key === "length") && portable(descriptor.value));
-  };
-  return portable(options) ? structuredClone(options) : void 0;
-}
-
-// packages/safe-bash/src/plugins/index.ts
-function createAgentCommands(options = {}) {
-  const commands = composeAgentCommands(options, createRegexExecutors(options), createGhCommands(options.gh));
-  const recipe = captureAgentWorkerRecipe(options);
-  for (const command of commands) {
-    if (recipe) agentWorkerRecipes.set(command.execute, recipe);
-  }
-  return commands;
-}
-function agentCommands(options = {}) {
-  const regex = Object.freeze({ ...options.regex });
-  const base = createAgentCommandPlugin({ ...options, regex }, createRegexExecutors({ ...options, regex }), createGhCommands(options.gh));
-  const recipe = captureAgentWorkerRecipe(options);
-  const plugin = {
-    name: "agent-commands",
-    setup(host) {
-      const previous = new Map(host.commands.list().map((command) => [command.name, command.execute]));
-      base.setup(host);
-      if (recipe) for (const definition of host.commands.list()) {
-        if (previous.get(definition.name) !== definition.execute) agentWorkerRecipes.set(definition.execute, recipe);
-      }
-    },
-    ...base.dispose ? { dispose: base.dispose } : {}
-  };
-  if (recipe) agentWorkerPlugins.add(plugin);
-  return plugin;
-}
-
-export {
-  createLazyCommandLoader,
-  createLazyCommands,
-  lazyCommandPlugin,
-  ghMetadata,
-  createGhCommand,
-  createGhCommands,
-  ghCommands,
-  createAgentCommands,
-  agentCommands
-};

package/dist/safe-bash/chunks/chunk-IWDICZVK.js

@@ -1,20 +0,0 @@
-import {
-  __toESM,
-  init_platform,
-  require_buffer
-} from "./chunk-B7TAL7S5.js";
-
-// packages/safe-bash/src/portable-buffer.ts
-init_platform();
-var import_buffer = __toESM(require_buffer(), 1);
-if (typeof globalThis.Buffer === "undefined") {
-  const decoder = new TextDecoder("utf8", { ignoreBOM: true });
-  Object.defineProperty(import_buffer.Buffer.prototype, "utf8Slice", {
-    configurable: true,
-    writable: true,
-    value(start, end) {
-      return decoder.decode(this.subarray(start, end));
-    }
-  });
-  globalThis.Buffer = import_buffer.Buffer;
-}