@swifty.js/swifty 0.0.21 → 0.0.23

package/dist/lib/chunk-OO2CLOEE.js

@@ -0,0 +1,88 @@
+// src/llm/errors.ts
+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";
+  }
+};
+
+// src/conversation/pairing.ts
+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 resolved = /* @__PURE__ */ new Set();
+  const issued = /* @__PURE__ */ new Set();
+  for (const m of messages) {
+    for (const tr of m.toolResults ?? []) {
+      resolved.add(tr.toolUseId);
+    }
+    for (const tu of m.toolUses ?? []) {
+      issued.add(tu.toolUseId);
+    }
+  }
+  const out = [];
+  for (const m of messages) {
+    let current = m;
+    if ((m.toolResults?.length ?? 0) > 0) {
+      const kept = (m.toolResults ?? []).filter((tr) => issued.has(tr.toolUseId));
+      if (kept.length === 0 && !m.content && !(m.toolUses?.length ?? 0)) {
+        continue;
+      }
+      current = { ...m, toolResults: kept };
+    }
+    out.push(current);
+    const missing = [];
+    for (const tu of m.toolUses ?? []) {
+      if (resolved.has(tu.toolUseId)) {
+        continue;
+      }
+      missing.push({
+        toolUseId: tu.toolUseId,
+        content: INTERRUPTED_TOOL_RESULT,
+        isError: true
+      });
+      resolved.add(tu.toolUseId);
+    }
+    if (missing.length > 0) {
+      out.push({ role: "user", content: "", toolResults: missing });
+    }
+  }
+  return out;
+}
+
+export {
+  LLMError,
+  AuthenticationError,
+  RateLimitError,
+  NetworkError,
+  ContextTooLongError,
+  INTERRUPTED_TOOL_RESULT,
+  REJECTED_TOOL_RESULT,
+  ensureToolPairing
+};

package/dist/lib/chunk-ORSYNBMM.js

@@ -0,0 +1,38 @@
+// src/sandbox/bwrap.ts
+import { execSync } from "child_process";
+var BwrapSandbox = class {
+  available() {
+    try {
+      execSync("which bwrap", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  wrap(command, config) {
+    const args = [];
+    args.push("bwrap", "--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 args.map((arg) => {
+      if (/[ \t\n"'\\$`!]/.test(arg)) {
+        return `'${arg.replace(/'/g, "'\\''")}'`;
+      }
+      return arg;
+    }).join(" ");
+  }
+};
+
+export {
+  BwrapSandbox
+};

package/dist/lib/chunk-PZ42NAFA.js

@@ -0,0 +1,242 @@
+import {
+  asErrorString,
+  asRecord,
+  createChildLogger,
+  strArg
+} from "./chunk-EY7HE52Q.js";
+import {
+  MCP_CALL_TOOL_NAME
+} from "./chunk-GHF2PSEW.js";
+
+// src/mcp/tool-wrapper.ts
+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);
+    } 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.isNaN(parsed) ? value : parsed;
+  }
+  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 = MCP_CALL_TOOL_NAME;
+  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"]
+      }
+    };
+  }
+  /**
+   * Try in order: full name / server+short name / unique short-name suffix match.
+   *
+   * The model very often passes only the short name (roughly three in ten calls in
+   * practice), so this must be tolerant — otherwise it needlessly costs a retry
+   * round.
+   */
+  resolve(server, tool) {
+    const direct = this.registry.get(tool) ?? this.registry.get(buildMcpToolName(server, tool));
+    if (direct) {
+      return direct;
+    }
+    const suffix = MCP_NAME_SEP + sanitizeSegment(tool);
+    const matches = this.registry.listTools().filter((t) => t.name.startsWith(MCP_TOOL_PREFIX) && t.name.endsWith(suffix));
+    return matches.length === 1 ? matches[0] : 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.resolve(server, tool);
+    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
+      };
+    }
+    let inner = {};
+    if (typeof args.arguments === "object" && args.arguments !== null && !Array.isArray(args.arguments)) {
+      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);
+        }
+      }
+    }
+    return target.execute(ctx, inner);
+  }
+};
+
+export {
+  MCP_TOOL_PREFIX,
+  MCP_NAME_SEP,
+  sanitizeSegment,
+  mcpToolNamePrefix,
+  buildMcpToolName,
+  MCPToolWrapper,
+  coerceBySchema,
+  mcpCallPermissionContent,
+  isMcpToolLike,
+  McpCallTool
+};

package/dist/lib/chunk-VUD72RTY.js

@@ -0,0 +1,39 @@
+// src/sandbox/seatbelt.ts
+import { existsSync, statSync } from "fs";
+var SANDBOX_EXEC_PATH = "/usr/bin/sandbox-exec";
+var SeatbeltSandbox = class {
+  available() {
+    return existsSync(SANDBOX_EXEC_PATH);
+  }
+  wrap(command, config) {
+    const profile = buildProfile(config);
+    const escaped = command.replace(/'/g, "'\\''");
+    return `${SANDBOX_EXEC_PATH} -p '${profile}' bash -c '${escaped}'`;
+  }
+};
+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
+};