@yukino.js/yukino 0.0.1

package/dist/lib/chunk-FFM2LB4C.js

@@ -0,0 +1,132 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/sandbox/sandbox-runtime.ts
+var sandbox_runtime_exports = {};
+__export(sandbox_runtime_exports, {
+  SandboxRuntimeSandbox: () => SandboxRuntimeSandbox,
+  createSandboxRuntimeConfig: () => createSandboxRuntimeConfig
+});
+import { isAbsolute, resolve } from "path";
+async function loadSandboxRuntime() {
+  return await import("@anthropic-ai/sandbox-runtime");
+}
+function resolvePaths(paths, cwd) {
+  return paths.map((path) => isAbsolute(path) ? path : resolve(cwd, path));
+}
+function createSandboxRuntimeConfig(config, cwd) {
+  return {
+    network: {
+      allowedDomains: [],
+      deniedDomains: config.networkEnabled ? [] : ["*"],
+      strictAllowlist: !config.networkEnabled
+    },
+    filesystem: {
+      denyRead: [],
+      allowWrite: resolvePaths(config.allowWrite, cwd),
+      denyWrite: resolvePaths(config.denyWrite, cwd),
+      allowGitConfig: false
+    }
+  };
+}
+var SandboxRuntimeSandbox = class {
+  implementation = "sandbox-runtime";
+  availabilityError;
+  availabilityPromise;
+  configKey;
+  initializationPromise;
+  runtimePromise;
+  available() {
+    return this.availabilityPromise ??= this.checkAvailability();
+  }
+  async prepare(command, config, context) {
+    if (!await this.available()) {
+      throw new Error(this.availabilityError ?? "sandbox runtime is unavailable");
+    }
+    const runtime = await this.loadRuntime();
+    const runtimeConfig = runtime.SandboxRuntimeConfigSchema.parse(
+      createSandboxRuntimeConfig(config, context.cwd)
+    );
+    const configKey = JSON.stringify(runtimeConfig);
+    if (this.initializationPromise) {
+      await this.initializationPromise;
+    }
+    if (this.configKey !== configKey || !runtime.SandboxManager.isSandboxingEnabled()) {
+      this.initializationPromise = (async () => {
+        if (runtime.SandboxManager.isSandboxingEnabled()) {
+          await runtime.SandboxManager.reset();
+        }
+        await runtime.SandboxManager.initialize(
+          runtimeConfig,
+          config.networkEnabled ? () => Promise.resolve(true) : void 0
+        );
+        this.configKey = configKey;
+      })();
+      try {
+        await this.initializationPromise;
+      } finally {
+        this.initializationPromise = void 0;
+      }
+    }
+    const commandId = context.commandId ?? command;
+    const prepared = await runtime.SandboxManager.wrapWithSandboxArgv(
+      command,
+      "/bin/bash",
+      void 0,
+      context.abortSignal,
+      context.cwd,
+      { commandId, commandText: command }
+    );
+    const [executable, ...args] = prepared.argv;
+    if (!executable) {
+      throw new Error("sandbox runtime returned an empty command");
+    }
+    return {
+      executable,
+      args,
+      env: prepared.env,
+      annotateStderr: (stderr) => runtime.SandboxManager.annotateStderrWithSandboxFailures(commandId, stderr),
+      cleanup: () => {
+        runtime.SandboxManager.cleanupAfterCommand();
+      }
+    };
+  }
+  async dispose() {
+    if (!this.runtimePromise) {
+      return;
+    }
+    await this.initializationPromise;
+    const runtime = await this.runtimePromise;
+    await runtime.SandboxManager.reset();
+    this.configKey = void 0;
+  }
+  async checkAvailability() {
+    try {
+      const runtime = await this.loadRuntime();
+      if (!runtime.SandboxManager.isSupportedPlatform()) {
+        this.availabilityError = "sandbox runtime does not support this platform";
+        return false;
+      }
+      const dependencies = await runtime.SandboxManager.checkDependenciesAsync();
+      if (dependencies.errors.length > 0) {
+        this.availabilityError = dependencies.errors.join("; ");
+        return false;
+      }
+      this.availabilityError = void 0;
+      return true;
+    } catch (error) {
+      this.availabilityError = error instanceof Error ? error.message : String(error);
+      return false;
+    }
+  }
+  loadRuntime() {
+    return this.runtimePromise ??= loadSandboxRuntime();
+  }
+};
+
+export {
+  createSandboxRuntimeConfig,
+  SandboxRuntimeSandbox,
+  sandbox_runtime_exports
+};

package/dist/lib/chunk-FLKB4BK7.js

@@ -0,0 +1,50 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/sandbox/seatbelt.ts
+var seatbelt_exports = {};
+__export(seatbelt_exports, {
+  SeatbeltSandbox: () => SeatbeltSandbox
+});
+import { existsSync, statSync } from "fs";
+var SANDBOX_EXEC_PATH = "/usr/bin/sandbox-exec";
+var SeatbeltSandbox = class {
+  implementation = "seatbelt";
+  available() {
+    return existsSync(SANDBOX_EXEC_PATH);
+  }
+  prepare(command, config) {
+    return {
+      executable: SANDBOX_EXEC_PATH,
+      args: ["-p", buildProfile(config), "bash", "-c", command]
+    };
+  }
+};
+function buildProfile(config) {
+  const lines = [];
+  lines.push("(version 1)");
+  lines.push("(deny default)");
+  lines.push("(allow process-exec)");
+  lines.push("(allow process-fork)");
+  lines.push("(allow sysctl-read)");
+  lines.push('(allow file-read* (subpath "/"))');
+  for (const path of config.allowWrite) {
+    lines.push(`(allow file-write* (subpath "${path}"))`);
+  }
+  for (const path of config.denyWrite) {
+    const matcher = existsSync(path) && statSync(path).isDirectory() ? "subpath" : "literal";
+    lines.push(`(deny file-write* (${matcher} "${path}"))`);
+  }
+  if (config.networkEnabled) {
+    lines.push("(allow network*)");
+  } else {
+    lines.push("(deny network*)");
+  }
+  return lines.join("\n");
+}
+
+export {
+  SeatbeltSandbox,
+  seatbelt_exports
+};

package/dist/lib/chunk-I34MAQRE.js

@@ -0,0 +1,255 @@
+import {
+  asErrorString,
+  asRecord,
+  createChildLogger,
+  strArg
+} from "./chunk-6OMQD7MK.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/tools/mcp-call.ts
+var mcp_call_exports = {};
+__export(mcp_call_exports, {
+  McpCallTool: () => McpCallTool,
+  coerceBySchema: () => coerceBySchema,
+  isMcpToolLike: () => isMcpToolLike,
+  mcpCallPermissionContent: () => mcpCallPermissionContent
+});
+
+// src/mcp/tool-wrapper.ts
+var tool_wrapper_exports = {};
+__export(tool_wrapper_exports, {
+  MCPToolWrapper: () => MCPToolWrapper,
+  MCP_NAME_SEP: () => MCP_NAME_SEP,
+  MCP_TOOL_PREFIX: () => MCP_TOOL_PREFIX,
+  buildMcpToolName: () => buildMcpToolName,
+  mcpToolNamePrefix: () => mcpToolNamePrefix,
+  sanitizeSegment: () => sanitizeSegment
+});
+var log = createChildLogger({ module: "mcp" });
+var MCP_TOOL_PREFIX = "mcp__";
+var MCP_NAME_SEP = "__";
+function sanitizeSegment(s) {
+  return s.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+function mcpToolNamePrefix(serverName) {
+  return MCP_TOOL_PREFIX + sanitizeSegment(serverName) + MCP_NAME_SEP;
+}
+function buildMcpToolName(serverName, toolName) {
+  return mcpToolNamePrefix(serverName) + sanitizeSegment(toolName);
+}
+var MCPToolWrapper = class {
+  name;
+  description;
+  category = "command";
+  // MCP tools are lazily loaded by default to avoid cramming all schemas into the prompt
+  deferred = true;
+  mcpServerName;
+  client;
+  originalName;
+  inputSchema;
+  constructor(client, serverName, tool) {
+    this.name = buildMcpToolName(serverName, tool.name);
+    this.description = tool.description;
+    this.originalName = tool.name;
+    this.client = client;
+    this.inputSchema = tool.inputSchema;
+    this.mcpServerName = serverName;
+  }
+  /** Original JSON schema. McpCall's argument coercion walks it layer by layer. */
+  mcpInputSchema() {
+    return this.inputSchema ?? {};
+  }
+  /** In eager mode the defer flag is cleared so MCP tools go straight into tools[]. */
+  setDeferLoading(on) {
+    this.deferred = on;
+  }
+  schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      input_schema: this.inputSchema
+    };
+  }
+  async execute(ctx, args) {
+    try {
+      return await this.client.callTool(this.originalName, args, ctx.abortSignal);
+    } catch (err) {
+      log.error({ err }, "mcp operation failed");
+      return {
+        output: `MCP tool error: ${asErrorString(err)}`,
+        isError: true
+      };
+    }
+  }
+};
+
+// src/tools/mcp-call.ts
+function coerceScalar(value, want) {
+  if (want === "string" && typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  if ((want === "integer" || want === "number") && typeof value === "string") {
+    const text = value.trim();
+    if (text === "") {
+      return value;
+    }
+    const shape = want === "integer" ? /^[+-]?\d+$/ : /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/;
+    if (!shape.test(text)) {
+      return value;
+    }
+    const parsed = want === "integer" ? Number.parseInt(text, 10) : Number.parseFloat(text);
+    return Number.isFinite(parsed) ? parsed : value;
+  }
+  if (want === "boolean" && typeof value === "string") {
+    const low = value.trim().toLowerCase();
+    if (low === "true") {
+      return true;
+    }
+    if (low === "false") {
+      return false;
+    }
+  }
+  return value;
+}
+function coerceBySchema(value, schema) {
+  if (typeof schema !== "object" || schema === null) {
+    return value;
+  }
+  const schemaObj = asRecord(schema);
+  const want = strArg(schemaObj, "type", "");
+  if (want === "object" && typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const props = asRecord(schemaObj.properties ?? {});
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      out[key] = key in props ? coerceBySchema(item, props[key]) : item;
+    }
+    return out;
+  }
+  if (want === "array") {
+    const itemSchema = schemaObj.items ?? {};
+    let working = value;
+    if (typeof working === "object" && working !== null && !Array.isArray(working)) {
+      const entries = Object.values(working);
+      if (entries.length === 1 && Array.isArray(entries[0])) {
+        working = entries[0];
+      }
+    } else if (typeof working === "string") {
+      working = working.split(",").map((p) => p.trim()).filter((p) => p !== "");
+    }
+    if (Array.isArray(working)) {
+      return working.map((item) => coerceBySchema(item, itemSchema));
+    }
+    return working;
+  }
+  if (want !== "") {
+    return coerceScalar(value, want);
+  }
+  return value;
+}
+function mcpCallPermissionContent(server, tool) {
+  if (tool.startsWith(MCP_TOOL_PREFIX)) {
+    const rest = tool.slice(MCP_TOOL_PREFIX.length);
+    const idx = rest.indexOf(MCP_NAME_SEP);
+    if (idx >= 0) {
+      return sanitizeSegment(rest.slice(0, idx)) + MCP_NAME_SEP + sanitizeSegment(rest.slice(idx + MCP_NAME_SEP.length));
+    }
+  }
+  return sanitizeSegment(server) + MCP_NAME_SEP + sanitizeSegment(tool);
+}
+function isMcpToolLike(tool) {
+  return "mcpInputSchema" in tool && typeof tool.mcpInputSchema === "function";
+}
+var McpCallTool = class {
+  constructor(registry) {
+    this.registry = registry;
+  }
+  registry;
+  name = "McpCall";
+  description = "Invoke a tool on a connected MCP server. Call ToolSearch first to load the tool's schema, then pass its arguments here exactly as that schema requires, using the same JSON types.";
+  category = "command";
+  // This tool must stay in tools[] itself, otherwise the model has no entry point
+  deferred = false;
+  schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      input_schema: {
+        type: "object",
+        properties: {
+          server: {
+            type: "string",
+            description: "MCP server name, e.g. 'linear'."
+          },
+          tool: {
+            type: "string",
+            description: "Full tool name as returned by ToolSearch, e.g. 'mcp__linear__create_issue'."
+          },
+          arguments: {
+            type: "object",
+            description: "The target tool's arguments. Must match that tool's input_schema exactly, including JSON types: bare numbers for integer fields, bare true/false for boolean fields, quoted strings for string fields, and plain JSON arrays for array fields."
+          }
+        },
+        required: ["server", "tool", "arguments"]
+      }
+    };
+  }
+  resolveTarget(args) {
+    const server = strArg(args, "server");
+    const name = strArg(args, "tool");
+    if (!server || !name) {
+      return void 0;
+    }
+    const fullName = name.startsWith(MCP_TOOL_PREFIX) ? name : buildMcpToolName(server, name);
+    const target = this.registry.get(fullName);
+    return target && isMcpToolLike(target) && sanitizeSegment(target.mcpServerName) === sanitizeSegment(server) ? target : void 0;
+  }
+  availableNames() {
+    return this.registry.listTools().filter((t) => t.name.startsWith(MCP_TOOL_PREFIX)).map((t) => t.name).sort();
+  }
+  async execute(ctx, args) {
+    const server = strArg(args, "server", "");
+    const tool = strArg(args, "tool", "");
+    if (tool === "") {
+      return { output: "McpCall requires a 'tool' name", isError: true };
+    }
+    const target = this.resolveTarget(args);
+    if (!target) {
+      const names = this.availableNames();
+      const hint = names.length > 0 ? names.join(", ") : "(none connected)";
+      return {
+        output: `Unknown MCP tool '${tool}' on server '${server}'. Available tools: ${hint}`,
+        isError: true
+      };
+    }
+    if (typeof args.arguments !== "object" || args.arguments === null || Array.isArray(args.arguments)) {
+      return {
+        output: "McpCall requires an 'arguments' object matching the target schema",
+        isError: true
+      };
+    }
+    let inner = asRecord(args.arguments);
+    if (isMcpToolLike(target)) {
+      const schema = target.mcpInputSchema();
+      if (Object.keys(schema).length > 0) {
+        const fixed = coerceBySchema(inner, schema);
+        if (typeof fixed === "object" && fixed !== null && !Array.isArray(fixed)) {
+          inner = asRecord(fixed);
+        }
+      }
+    }
+    ctx.abortSignal?.throwIfAborted();
+    return target.execute(ctx, inner);
+  }
+};
+
+export {
+  MCP_TOOL_PREFIX,
+  MCPToolWrapper,
+  tool_wrapper_exports,
+  mcpCallPermissionContent,
+  isMcpToolLike,
+  McpCallTool,
+  mcp_call_exports
+};