@yukino.js/yukino 0.0.1

package/dist/lib/chunk-QYBQT2DM.js

@@ -0,0 +1,655 @@
+import {
+  createChildLogger
+} from "./chunk-6OMQD7MK.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/config/index.ts
+var config_exports = {};
+__export(config_exports, {
+  ConfigError: () => ConfigError,
+  DEFAULT_CONTEXT_WINDOW: () => DEFAULT_CONTEXT_WINDOW,
+  DEFAULT_MAX_OUTPUT_TOKENS: () => DEFAULT_MAX_OUTPUT_TOKENS,
+  DEFAULT_THINKING_LEVEL: () => DEFAULT_THINKING_LEVEL,
+  HookConfigSchema: () => HookConfigSchema,
+  MIN_THINKING_ANSWER_TOKENS: () => MIN_THINKING_ANSWER_TOKENS,
+  MIN_THINKING_BUDGET_TOKENS: () => MIN_THINKING_BUDGET_TOKENS,
+  ProviderConfigSchema: () => ProviderConfigSchema,
+  THINKING_BUDGETS: () => THINKING_BUDGETS,
+  THINKING_LEVELS: () => THINKING_LEVELS,
+  clampThinkingLevel: () => clampThinkingLevel,
+  forkEnabled: () => forkEnabled,
+  getContextWindow: () => getContextWindow,
+  getMaxOutputTokens: () => getMaxOutputTokens,
+  getSupportedThinkingLevels: () => getSupportedThinkingLevels,
+  getThinkingLevel: () => getThinkingLevel,
+  globalConfigPath: () => globalConfigPath,
+  isValidThinkingLevel: () => isValidThinkingLevel,
+  loadConfig: () => loadConfig,
+  loadProjectMcpServers: () => loadProjectMcpServers,
+  resolveAPIKey: () => resolveAPIKey,
+  thinkingBudgetForLevel: () => thinkingBudgetForLevel,
+  toAnthropicThinkingEffort: () => toAnthropicThinkingEffort,
+  toReasoningEffort: () => toReasoningEffort,
+  withProjectMcpServers: () => withProjectMcpServers,
+  withProviderDefaults: () => withProviderDefaults
+});
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import {
+  getParseErrorMessage,
+  safeParse
+} from "@modelcontextprotocol/sdk/server/zod-compat.js";
+import yaml from "js-yaml";
+import { z } from "zod";
+var log = createChildLogger({ module: "config" });
+var ENV_KEY_MAP = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  "openai-compat": "OPENAI_API_KEY"
+};
+function isKeyofTypeofEnvKeyMap(k) {
+  return VALID_PROTOCOLS.has(k);
+}
+var VALID_PROTOCOLS = new Set(Object.keys(ENV_KEY_MAP));
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+function globalConfigPath() {
+  return join(homedir(), ".yukino", "config.yaml");
+}
+var THINKING_LEVELS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+var ReasoningEffortSchema = z.enum([
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+]);
+var AnthropicEffortSchema = z.enum(["low", "medium", "high", "xhigh", "max"]);
+var ThinkingLevelMapSchema = z.strictObject({
+  off: z.literal("none").nullable().optional(),
+  minimal: ReasoningEffortSchema.nullable().optional(),
+  low: ReasoningEffortSchema.nullable().optional(),
+  medium: ReasoningEffortSchema.nullable().optional(),
+  high: ReasoningEffortSchema.nullable().optional(),
+  xhigh: ReasoningEffortSchema.nullable().optional(),
+  max: ReasoningEffortSchema.nullable().optional()
+});
+var ProviderConfigSchema = z.looseObject({
+  name: z.string(),
+  /**
+   * enum: ["anthropic", "openai", "openai-compat"]
+   */
+  protocol: z.enum(["anthropic", "openai", "openai-compat"]),
+  base_url: z.string(),
+  model: z.string(),
+  api_key: z.string().optional(),
+  thinking: z.enum(THINKING_LEVELS).optional(),
+  /** Explicit capability metadata, never inferred from model names. */
+  reasoning: z.boolean().optional(),
+  thinking_level_map: ThinkingLevelMapSchema.optional(),
+  /** Only Anthropic uses this mode; existing configurations use budgets. */
+  thinking_mode: z.enum(["budget", "adaptive"]).optional(),
+  context_window: z.coerce.number().optional(),
+  /**
+   * The model's output ceiling (PI's `model.maxTokens`). Clamped to the
+   * context window; reasoning shares this ceiling instead of raising it.
+   */
+  max_output_tokens: z.coerce.number().optional()
+});
+var DEFAULT_THINKING_LEVEL = "high";
+var DEFAULT_CONTEXT_WINDOW = 1e6;
+var DEFAULT_MAX_OUTPUT_TOKENS = 128e3;
+var THINKING_BUDGETS = {
+  minimal: 1024,
+  low: 2048,
+  medium: 8192,
+  high: 16384,
+  xhigh: 32768,
+  max: 65536
+};
+var MIN_THINKING_BUDGET_TOKENS = 1024;
+var MIN_THINKING_ANSWER_TOKENS = 1024;
+function isValidThinkingLevel(value) {
+  return THINKING_LEVELS.some((level) => level === value);
+}
+function getThinkingLevel(provider) {
+  return clampThinkingLevel(
+    provider,
+    provider.thinking ?? DEFAULT_THINKING_LEVEL
+  );
+}
+function thinkingBudgetForLevel(level) {
+  return level === "off" ? 0 : THINKING_BUDGETS[level];
+}
+function toReasoningEffort(level, provider) {
+  if (provider?.reasoning === false) {
+    return null;
+  }
+  if (level === "off") {
+    return "none";
+  }
+  const mapped = provider?.thinking_level_map?.[level];
+  if (mapped !== void 0) {
+    return mapped;
+  }
+  if (provider?.protocol === "anthropic" && provider.thinking_mode === "adaptive") {
+    if (level === "minimal") {
+      return "low";
+    }
+    if (level === "xhigh") {
+      return "high";
+    }
+  }
+  return level;
+}
+function toAnthropicThinkingEffort(level, provider) {
+  const parsed = AnthropicEffortSchema.safeParse(
+    toReasoningEffort(level, provider)
+  );
+  return parsed.success ? parsed.data : null;
+}
+function getSupportedThinkingLevels(provider) {
+  if (provider.reasoning === false || provider.protocol === "anthropic" && provider.thinking_mode !== "adaptive" && getMaxOutputTokens(provider) < MIN_THINKING_BUDGET_TOKENS + MIN_THINKING_ANSWER_TOKENS) {
+    return ["off"];
+  }
+  return THINKING_LEVELS.filter((level) => {
+    if (level === "off") {
+      return true;
+    }
+    if (provider.protocol === "anthropic" && provider.thinking_mode === "adaptive") {
+      return toAnthropicThinkingEffort(level, provider) !== null;
+    }
+    const effort = toReasoningEffort(level, provider);
+    return effort !== null && effort !== "none";
+  });
+}
+function clampThinkingLevel(provider, level) {
+  const supported = getSupportedThinkingLevels(provider);
+  let effective = "off";
+  for (const candidate of THINKING_LEVELS) {
+    if (supported.includes(candidate)) {
+      effective = candidate;
+    }
+    if (candidate === level) {
+      break;
+    }
+  }
+  return effective;
+}
+function withProviderDefaults(provider) {
+  return {
+    ...provider,
+    thinking: getThinkingLevel(provider),
+    context_window: getContextWindow(provider),
+    max_output_tokens: getMaxOutputTokens(provider)
+  };
+}
+function getContextWindow(provider) {
+  return Number.isSafeInteger(provider.context_window) && (provider.context_window ?? 0) > 0 ? provider.context_window ?? DEFAULT_CONTEXT_WINDOW : DEFAULT_CONTEXT_WINDOW;
+}
+function getMaxOutputTokens(provider) {
+  const configured = provider.max_output_tokens;
+  const maxOutput = Number.isSafeInteger(configured) && (configured ?? 0) > 0 ? configured ?? DEFAULT_MAX_OUTPUT_TOKENS : DEFAULT_MAX_OUTPUT_TOKENS;
+  return Math.min(maxOutput, getContextWindow(provider));
+}
+function resolveAPIKey(p) {
+  if (p.api_key) {
+    return p.api_key;
+  }
+  const envVar = isKeyofTypeofEnvKeyMap(p.protocol) ? ENV_KEY_MAP[p.protocol] : "";
+  if (!envVar) {
+    return "";
+  }
+  return process.env[envVar] ?? "";
+}
+var MCPServerConfigSchema = z.object({
+  name: z.string(),
+  command: z.string().optional(),
+  args: z.array(z.string()).optional(),
+  url: z.string().optional(),
+  transport: z.string().optional(),
+  headers: z.record(z.string(), z.string()).optional(),
+  env: z.record(z.string(), z.string()).optional()
+});
+var HookConfigSchema = z.object({
+  id: z.string().optional(),
+  event: z.string(),
+  condition: z.string().optional(),
+  action: z.object({
+    type: z.string(),
+    command: z.string().optional(),
+    url: z.string().optional(),
+    method: z.string().optional(),
+    prompt: z.string().optional()
+  }),
+  reject: z.boolean().optional(),
+  once: z.boolean().optional(),
+  async: z.boolean().optional(),
+  on_error: z.string().optional()
+});
+var SandboxYamlConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  backend: z.enum(["native", "sandbox-runtime"]).optional(),
+  auto_allow: z.boolean().optional(),
+  network_enabled: z.boolean().optional()
+});
+var AppConfigSchema = z.looseObject({
+  providers: z.array(ProviderConfigSchema),
+  permission_mode: z.string().optional(),
+  mcp_servers: z.array(MCPServerConfigSchema).default([]),
+  hooks: z.array(HookConfigSchema).default([]),
+  sandbox: SandboxYamlConfigSchema.optional(),
+  enable_coordinator_mode: z.boolean().optional(),
+  /**
+   * Whether to fork when subagent_type is omitted. Enabled by default, so this
+   * field is left as undefined to represent "not specified in config". Using a
+   * concrete boolean would make it impossible to distinguish "not set" from
+   * "explicitly false", and the latter could never be turned back off.
+   */
+  enable_fork: z.boolean().optional()
+});
+function forkEnabled(cfg) {
+  return cfg.enable_fork !== false;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function loadSingleFile(path) {
+  const data = readFileSync(path, "utf-8");
+  const raw = yaml.load(data);
+  if (!isRecord(raw)) {
+    log.error({ path }, "invalid yaml");
+    return { providers: [], mcp_servers: [], hooks: [] };
+  }
+  const parsed = safeParse(AppConfigSchema, raw);
+  if (parsed.success) {
+    const data2 = parsed.data;
+    return {
+      ...data2,
+      providers: data2.providers.map(withProviderDefaults)
+    };
+  }
+  log.error({ error: parsed.error }, "config error");
+  let providers = [];
+  let permissionMode;
+  let mcpServers = [];
+  let hooks = [];
+  let sandbox = void 0;
+  let enableCoordinatorMode = false;
+  let enableFork = true;
+  if ("providers" in raw) {
+    const parsed2 = safeParse(z.array(ProviderConfigSchema), raw.providers);
+    if (parsed2.success) {
+      providers = parsed2.data.map(withProviderDefaults);
+    } else {
+      throw new ConfigError(
+        `Invalid provider configuration in ${path}: ${getParseErrorMessage(parsed2.error)}`
+      );
+    }
+  }
+  if ("permission_mode" in raw && typeof raw.permission_mode === "string") {
+    permissionMode = raw.permission_mode;
+  }
+  if ("mcp_servers" in raw) {
+    const parsed2 = safeParse(z.array(MCPServerConfigSchema), raw.mcp_servers);
+    if (parsed2.success) {
+      mcpServers = parsed2.data;
+    } else {
+      throw new ConfigError(
+        `Invalid MCP server configuration in ${path}: ${getParseErrorMessage(parsed2.error)}`
+      );
+    }
+  }
+  if ("hooks" in raw) {
+    const parsed2 = safeParse(z.array(HookConfigSchema), raw.hooks);
+    if (parsed2.success) {
+      hooks = parsed2.data;
+    }
+  }
+  if ("sandbox" in raw) {
+    const parsed2 = safeParse(SandboxYamlConfigSchema, raw.sandbox);
+    if (parsed2.success) {
+      sandbox = parsed2.data;
+    } else {
+      throw new ConfigError(
+        `Invalid sandbox configuration in ${path}: ${getParseErrorMessage(parsed2.error)}`
+      );
+    }
+  }
+  if ("enable_coordinator_mode" in raw) {
+    enableCoordinatorMode = Boolean(raw.enable_coordinator_mode);
+  }
+  if ("enable_fork" in raw) {
+    enableFork = Boolean(raw.enable_fork);
+  }
+  return {
+    providers,
+    permission_mode: permissionMode,
+    mcp_servers: mcpServers,
+    hooks,
+    sandbox,
+    enable_coordinator_mode: enableCoordinatorMode,
+    enable_fork: enableFork
+  };
+}
+function validateProviders(config) {
+  if (config.providers.length === 0) {
+    throw new ConfigError("At least one provider MUST be configured.");
+  }
+  const requiredFields = ["name", "protocol", "base_url", "model"];
+  const baseUrls = /* @__PURE__ */ new Map();
+  for (let i = 0; i < config.providers.length; i++) {
+    const p = config.providers[i];
+    const values = {
+      name: p.name,
+      protocol: p.protocol,
+      base_url: p.base_url,
+      model: p.model
+    };
+    const missing = requiredFields.filter((field) => !values[field].trim());
+    if (missing.length > 0) {
+      throw new ConfigError(
+        `Provider #${String(i + 1)}: missing fields: ${missing.join(", ")}`
+      );
+    }
+    if (!VALID_PROTOCOLS.has(p.protocol)) {
+      throw new ConfigError(
+        `Provider #${String(i + 1)}: invalid protocol '${p.protocol}', MUST be one of: ${Array.from(VALID_PROTOCOLS).join(", ")}`
+      );
+    }
+    const previous = baseUrls.get(p.base_url);
+    if (previous !== void 0) {
+      throw new ConfigError(
+        `Provider #${String(i + 1)}: duplicate base_url '${p.base_url}' (already used by provider #${String(previous + 1)}).`
+      );
+    }
+    baseUrls.set(p.base_url, i);
+  }
+}
+function validateMcpServers(config) {
+  const names = /* @__PURE__ */ new Map();
+  for (let i = 0; i < config.mcp_servers.length; i++) {
+    const server = config.mcp_servers[i];
+    const position = `MCP server #${String(i + 1)}`;
+    if (!server.name.trim()) {
+      throw new ConfigError(`${position}: name must not be empty.`);
+    }
+    const previous = names.get(server.name);
+    if (previous !== void 0) {
+      throw new ConfigError(
+        `${position}: duplicate name '${server.name}' (already used by MCP server #${String(previous + 1)}).`
+      );
+    }
+    names.set(server.name, i);
+    const hasCommand = Boolean(server.command?.trim());
+    const hasUrl = Boolean(server.url?.trim());
+    if (hasCommand === hasUrl) {
+      throw new ConfigError(
+        `${position} '${server.name}': configure exactly one of command or url.`
+      );
+    }
+    if (hasCommand && server.transport && server.transport !== "stdio") {
+      throw new ConfigError(
+        `${position} '${server.name}': command servers must use stdio.`
+      );
+    }
+    if (hasUrl && server.transport && !["http", "sse"].includes(server.transport)) {
+      throw new ConfigError(
+        `${position} '${server.name}': URL transport must be http or sse.`
+      );
+    }
+  }
+}
+var PROJECT_MCP_FILENAME = ".mcp.json";
+var McpJsonEntrySchema = z.looseObject({
+  command: z.string().optional(),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  type: z.enum(["stdio", "sse", "http"]).optional(),
+  url: z.string().optional(),
+  headers: z.record(z.string(), z.string()).optional()
+});
+var McpJsonFileSchema = z.looseObject({
+  // Parse entries independently below so one bad server does not disable every
+  // valid server in the project file.
+  mcpServers: z.record(z.string(), z.unknown()).default({})
+});
+function mcpServerFromJsonEntry(name, entry) {
+  const transport = entry.type ?? (entry.command !== void 0 ? "stdio" : "http");
+  if (transport === "stdio") {
+    if (!entry.command || entry.url !== void 0) {
+      return null;
+    }
+    return { name, command: entry.command, args: entry.args, env: entry.env };
+  }
+  if (!entry.url || entry.command !== void 0) {
+    return null;
+  }
+  return { name, url: entry.url, transport, headers: entry.headers };
+}
+function loadProjectMcpServers(workDir) {
+  const path = join(workDir, PROJECT_MCP_FILENAME);
+  if (!existsSync(path)) {
+    return [];
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf-8"));
+  } catch (err) {
+    log.error({ err, path }, "invalid .mcp.json");
+    return [];
+  }
+  const parsed = safeParse(McpJsonFileSchema, raw);
+  if (!parsed.success) {
+    log.error({ error: parsed.error, path }, "invalid .mcp.json");
+    return [];
+  }
+  const servers = [];
+  for (const [name, rawEntry] of Object.entries(parsed.data.mcpServers)) {
+    const parsedEntry = safeParse(McpJsonEntrySchema, rawEntry);
+    if (!name.trim() || !parsedEntry.success) {
+      log.warn(
+        {
+          name,
+          path,
+          error: parsedEntry.success ? void 0 : parsedEntry.error
+        },
+        "skipping invalid .mcp.json server entry"
+      );
+      continue;
+    }
+    const server = mcpServerFromJsonEntry(name, parsedEntry.data);
+    if (server) {
+      servers.push(server);
+    } else {
+      log.warn({ name, path }, "skipping invalid .mcp.json server entry");
+    }
+  }
+  return servers;
+}
+function withProjectMcpServers(config, workDir) {
+  const projectServers = loadProjectMcpServers(workDir);
+  if (projectServers.length === 0) {
+    return config;
+  }
+  const known = new Set(config.mcp_servers.map((s) => s.name));
+  return {
+    ...config,
+    mcp_servers: [
+      ...config.mcp_servers,
+      ...projectServers.filter((s) => !known.has(s.name))
+    ]
+  };
+}
+function loadConfig(path, options = {}) {
+  if (path) {
+    const config2 = loadSingleFile(path);
+    validateMcpServers(config2);
+    if (!options.allowEmptyProviders || config2.providers.length > 0) {
+      validateProviders(config2);
+    }
+    return config2;
+  }
+  const candidate = globalConfigPath();
+  if (!existsSync(candidate)) {
+    if (options.allowEmptyProviders) {
+      return { providers: [], mcp_servers: [], hooks: [] };
+    }
+    throw new ConfigError(`No config file found, expected ${candidate}.`);
+  }
+  const config = loadSingleFile(candidate);
+  validateMcpServers(config);
+  if (!options.allowEmptyProviders || config.providers.length > 0) {
+    validateProviders(config);
+  }
+  return config;
+}
+
+// src/conversation/pairing.ts
+var pairing_exports = {};
+__export(pairing_exports, {
+  INTERRUPTED_TOOL_RESULT: () => INTERRUPTED_TOOL_RESULT,
+  REJECTED_TOOL_RESULT: () => REJECTED_TOOL_RESULT,
+  ensureToolPairing: () => ensureToolPairing
+});
+var INTERRUPTED_TOOL_RESULT = "Tool execution was interrupted. The tool may or may not have completed; verify before relying on its effects.";
+var REJECTED_TOOL_RESULT = "The user rejected this tool use. Nothing was changed (for file edits, the new content was NOT written).";
+function ensureToolPairing(messages) {
+  const out = [];
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i];
+    if (m.role === "assistant" && m.toolUses?.length) {
+      out.push(m);
+      const pending = new Set(m.toolUses.map((tu) => tu.toolUseId));
+      const results = [];
+      const resultMessages = [];
+      while (i + 1 < messages.length) {
+        const next = messages[i + 1];
+        if (next.role !== "user" || !next.toolResults?.length || next.toolUses?.length) {
+          break;
+        }
+        i++;
+        resultMessages.push(next);
+        for (const tr of next.toolResults) {
+          if (pending.delete(tr.toolUseId)) {
+            results.push(tr);
+          }
+        }
+      }
+      for (const toolUseId of pending) {
+        results.push({ toolUseId, content: INTERRUPTED_TOOL_RESULT, isError: true });
+      }
+      out.push({
+        ...resultMessages[0] ?? { role: "user", content: "" },
+        toolResults: results
+      });
+      for (const remaining of resultMessages.slice(1)) {
+        if (remaining.content.length > 0 || remaining.thinkingBlocks?.length) {
+          out.push({ ...remaining, toolResults: [] });
+        }
+      }
+      continue;
+    }
+    if ((m.toolResults?.length ?? 0) > 0) {
+      if (m.content.length === 0 && !m.toolUses?.length && !m.thinkingBlocks?.length) {
+        continue;
+      }
+      out.push({ ...m, toolResults: [] });
+    } else {
+      out.push(m);
+    }
+  }
+  return out;
+}
+
+// src/llm/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  AuthenticationError: () => AuthenticationError,
+  ContextTooLongError: () => ContextTooLongError,
+  LLMError: () => LLMError,
+  NetworkError: () => NetworkError,
+  RateLimitError: () => RateLimitError
+});
+var LLMError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LLMError";
+  }
+};
+var AuthenticationError = class extends LLMError {
+  constructor(message) {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends LLMError {
+  retryAfter;
+  constructor(message, retryAfter) {
+    super(message);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var NetworkError = class extends LLMError {
+  constructor(message) {
+    super(message);
+    this.name = "NetworkError";
+  }
+};
+var ContextTooLongError = class extends LLMError {
+  constructor(message) {
+    super(message);
+    this.name = "ContextTooLongError";
+  }
+};
+
+export {
+  globalConfigPath,
+  THINKING_LEVELS,
+  ProviderConfigSchema,
+  DEFAULT_THINKING_LEVEL,
+  DEFAULT_CONTEXT_WINDOW,
+  DEFAULT_MAX_OUTPUT_TOKENS,
+  MIN_THINKING_ANSWER_TOKENS,
+  isValidThinkingLevel,
+  getThinkingLevel,
+  thinkingBudgetForLevel,
+  toReasoningEffort,
+  toAnthropicThinkingEffort,
+  getSupportedThinkingLevels,
+  clampThinkingLevel,
+  getContextWindow,
+  getMaxOutputTokens,
+  resolveAPIKey,
+  forkEnabled,
+  withProjectMcpServers,
+  loadConfig,
+  config_exports,
+  REJECTED_TOOL_RESULT,
+  ensureToolPairing,
+  pairing_exports,
+  LLMError,
+  AuthenticationError,
+  RateLimitError,
+  NetworkError,
+  ContextTooLongError,
+  errors_exports
+};

package/dist/lib/chunk-YIWNQ7OA.js

@@ -0,0 +1,47 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/sandbox/bwrap.ts
+var bwrap_exports = {};
+__export(bwrap_exports, {
+  BwrapSandbox: () => BwrapSandbox
+});
+import { execFileSync } from "child_process";
+var BwrapSandbox = class {
+  implementation = "bwrap";
+  detected;
+  available() {
+    if (this.detected !== void 0) {
+      return this.detected;
+    }
+    try {
+      execFileSync("which", ["bwrap"], { stdio: "ignore" });
+      this.detected = true;
+    } catch {
+      this.detected = false;
+    }
+    return this.detected;
+  }
+  prepare(command, config) {
+    const args = ["--unshare-user", "--unshare-pid"];
+    args.push("--ro-bind", "/", "/");
+    for (const path of config.allowWrite) {
+      args.push("--bind", path, path);
+    }
+    for (const path of config.denyWrite) {
+      args.push("--ro-bind", path, path);
+    }
+    if (!config.networkEnabled) {
+      args.push("--unshare-net");
+    }
+    args.push("--proc", "/proc");
+    args.push("--", "bash", "-c", command);
+    return { executable: "bwrap", args };
+  }
+};
+
+export {
+  BwrapSandbox,
+  bwrap_exports
+};