@swifty.js/swifty 0.0.32 → 0.0.35

package/dist/lib/chunk-OJTISIYU.js

@@ -0,0 +1,462 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/telemetry/providers.ts
+var providers_exports = {};
+__export(providers_exports, {
+  createTelemetryRuntime: () => createTelemetryRuntime,
+  parseExporterTypes: () => parseExporterTypes
+});
+import { LangfuseSpanProcessor } from "@langfuse/otel";
+import {
+  setLangfuseTracerProvider,
+  startObservation
+} from "@langfuse/tracing";
+import { SpanStatusCode } from "@opentelemetry/api";
+import { SeverityNumber } from "@opentelemetry/api-logs";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import {
+  BatchLogRecordProcessor,
+  ConsoleLogRecordExporter,
+  LoggerProvider
+} from "@opentelemetry/sdk-logs";
+import {
+  ConsoleMetricExporter,
+  MeterProvider,
+  PeriodicExportingMetricReader
+} from "@opentelemetry/sdk-metrics";
+import {
+  BasicTracerProvider,
+  BatchSpanProcessor,
+  ConsoleSpanExporter
+} from "@opentelemetry/sdk-trace-base";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+
+// src/version.ts
+var version_exports = {};
+__export(version_exports, {
+  version: () => version
+});
+import { readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { z } from "zod";
+var PackageJsonSchema = z.object({
+  version: z.string()
+});
+function resolveVersion() {
+  if (true) {
+    return "0.0.35";
+  }
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  for (const levels of ["..", "../.."]) {
+    const candidate = path.resolve(here, levels, "package.json");
+    try {
+      const raw = JSON.parse(readFileSync(candidate, "utf-8"));
+      const parsed = PackageJsonSchema.safeParse(raw);
+      if (parsed.success) {
+        return parsed.data.version;
+      }
+    } catch {
+    }
+  }
+  throw new Error("Could not resolve package version");
+}
+var version = resolveVersion();
+
+// src/telemetry/providers.ts
+var DEFAULT_EXPORT_INTERVAL_MS = 6e4;
+var SHUTDOWN_TIMEOUT_MS = 2e3;
+function parseExporterTypes(value) {
+  return (value ?? "").split(",").map((item) => item.trim()).filter((item) => item.length > 0 && item !== "none");
+}
+function parsePositiveInteger(value, fallback) {
+  const parsed = Number.parseInt(value ?? "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function getProtocol(signal) {
+  const signalKey = `OTEL_EXPORTER_OTLP_${signal.toUpperCase()}_PROTOCOL`;
+  const configured = process.env[signalKey]?.trim() || process.env.OTEL_EXPORTER_OTLP_PROTOCOL?.trim();
+  const protocol = configured || "http/protobuf";
+  if (protocol === "grpc" || protocol === "http/json" || protocol === "http/protobuf") {
+    return protocol;
+  }
+  throw new Error(`Unsupported OpenTelemetry protocol: ${protocol}`);
+}
+function parseResourceAttributes(value) {
+  const attributes = {};
+  for (const entry of value?.split(",") ?? []) {
+    const separator = entry.indexOf("=");
+    if (separator <= 0) {
+      continue;
+    }
+    const key = entry.slice(0, separator).trim();
+    const rawValue = entry.slice(separator + 1).trim();
+    if (key && rawValue) {
+      try {
+        attributes[decodeURIComponent(key)] = decodeURIComponent(rawValue);
+      } catch {
+        attributes[key] = rawValue;
+      }
+    }
+  }
+  return attributes;
+}
+function createResource() {
+  return resourceFromAttributes({
+    [ATTR_SERVICE_NAME]: "swifty",
+    [ATTR_SERVICE_VERSION]: version,
+    ...parseResourceAttributes(process.env.OTEL_RESOURCE_ATTRIBUTES),
+    ...process.env.OTEL_SERVICE_NAME ? { [ATTR_SERVICE_NAME]: process.env.OTEL_SERVICE_NAME } : {}
+  });
+}
+async function createTraceExporter(protocol) {
+  switch (protocol) {
+    case "grpc": {
+      const { OTLPTraceExporter } = await import("@opentelemetry/exporter-trace-otlp-grpc");
+      return new OTLPTraceExporter();
+    }
+    case "http/json": {
+      const { OTLPTraceExporter } = await import("@opentelemetry/exporter-trace-otlp-http");
+      return new OTLPTraceExporter();
+    }
+    case "http/protobuf": {
+      const { OTLPTraceExporter } = await import("@opentelemetry/exporter-trace-otlp-proto");
+      return new OTLPTraceExporter();
+    }
+  }
+}
+async function createLogExporter(protocol) {
+  switch (protocol) {
+    case "grpc": {
+      const { OTLPLogExporter } = await import("@opentelemetry/exporter-logs-otlp-grpc");
+      return new OTLPLogExporter();
+    }
+    case "http/json": {
+      const { OTLPLogExporter } = await import("@opentelemetry/exporter-logs-otlp-http");
+      return new OTLPLogExporter();
+    }
+    case "http/protobuf": {
+      const { OTLPLogExporter } = await import("@opentelemetry/exporter-logs-otlp-proto");
+      return new OTLPLogExporter();
+    }
+  }
+}
+async function createMetricExporter(protocol) {
+  switch (protocol) {
+    case "grpc": {
+      const { OTLPMetricExporter } = await import("@opentelemetry/exporter-metrics-otlp-grpc");
+      return new OTLPMetricExporter();
+    }
+    case "http/json": {
+      const { OTLPMetricExporter } = await import("@opentelemetry/exporter-metrics-otlp-http");
+      return new OTLPMetricExporter();
+    }
+    case "http/protobuf": {
+      const { OTLPMetricExporter } = await import("@opentelemetry/exporter-metrics-otlp-proto");
+      return new OTLPMetricExporter();
+    }
+  }
+}
+async function createTracerProvider(resource) {
+  const processors = [];
+  const exporterTypes = parseExporterTypes(process.env.OTEL_TRACES_EXPORTER);
+  for (const exporterType of exporterTypes) {
+    if (exporterType === "console") {
+      processors.push(new BatchSpanProcessor(new ConsoleSpanExporter()));
+    } else if (exporterType === "otlp") {
+      processors.push(new BatchSpanProcessor(await createTraceExporter(getProtocol("traces"))));
+    } else {
+      throw new Error(`Unsupported trace exporter: ${exporterType}`);
+    }
+  }
+  if (process.env.LANGFUSE_PUBLIC_KEY && process.env.LANGFUSE_SECRET_KEY) {
+    processors.push(
+      new LangfuseSpanProcessor({
+        mediaUploadEnabled: false,
+        release: process.env.LANGFUSE_RELEASE ?? version
+      })
+    );
+  }
+  if (processors.length === 0) {
+    return null;
+  }
+  const provider = new BasicTracerProvider({ resource, spanProcessors: processors });
+  setLangfuseTracerProvider(provider);
+  return provider;
+}
+async function createLoggerProvider(resource) {
+  const processors = [];
+  for (const exporterType of parseExporterTypes(process.env.OTEL_LOGS_EXPORTER)) {
+    let exporter;
+    if (exporterType === "console") {
+      exporter = new ConsoleLogRecordExporter();
+    } else if (exporterType === "otlp") {
+      exporter = await createLogExporter(getProtocol("logs"));
+    } else {
+      throw new Error(`Unsupported log exporter: ${exporterType}`);
+    }
+    processors.push(new BatchLogRecordProcessor({ exporter }));
+  }
+  return processors.length > 0 ? new LoggerProvider({ resource, processors }) : null;
+}
+async function createMetricReaders() {
+  const readers = [];
+  const exportIntervalMillis = parsePositiveInteger(
+    process.env.OTEL_METRIC_EXPORT_INTERVAL,
+    DEFAULT_EXPORT_INTERVAL_MS
+  );
+  for (const exporterType of parseExporterTypes(process.env.OTEL_METRICS_EXPORTER)) {
+    if (exporterType === "prometheus") {
+      const { PrometheusExporter } = await import("@opentelemetry/exporter-prometheus");
+      readers.push(new PrometheusExporter());
+      continue;
+    }
+    let exporter;
+    if (exporterType === "console") {
+      exporter = new ConsoleMetricExporter();
+    } else if (exporterType === "otlp") {
+      exporter = await createMetricExporter(getProtocol("metrics"));
+    } else {
+      throw new Error(`Unsupported metric exporter: ${exporterType}`);
+    }
+    readers.push(new PeriodicExportingMetricReader({ exporter, exportIntervalMillis }));
+  }
+  return readers;
+}
+async function initializeSentry() {
+  if (!process.env.SENTRY_DSN) {
+    return null;
+  }
+  const sentry = await import("@sentry/node");
+  sentry.init({
+    debug: process.env.SENTRY_DEBUG?.toLowerCase() === "true",
+    dsn: process.env.SENTRY_DSN,
+    environment: process.env.SENTRY_ENVIRONMENT,
+    includeLocalVariables: false,
+    integrations: (defaultIntegrations) => defaultIntegrations.filter(
+      (integration) => integration.name !== "OnUncaughtException" && integration.name !== "OnUnhandledRejection"
+    ),
+    registerEsmLoaderHooks: false,
+    release: process.env.SENTRY_RELEASE ?? version,
+    sendDefaultPii: false,
+    skipOpenTelemetrySetup: true,
+    tracesSampleRate: 0
+  });
+  return sentry;
+}
+async function safely(operation) {
+  try {
+    return await operation();
+  } catch {
+    return null;
+  }
+}
+function withTimeout(operation) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, SHUTDOWN_TIMEOUT_MS);
+    timer.unref();
+    void operation.then(
+      () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      () => {
+        clearTimeout(timer);
+        resolve();
+      }
+    );
+  });
+}
+function severityNumber(severity) {
+  switch (severity) {
+    case "error":
+      return SeverityNumber.ERROR;
+    case "info":
+      return SeverityNumber.INFO;
+    case "warn":
+      return SeverityNumber.WARN;
+  }
+}
+function createRootObservation(kind, name, attributes) {
+  switch (kind) {
+    case "agent":
+      return startObservation(name, { metadata: attributes }, { asType: "agent" });
+    case "generation": {
+      const model = typeof attributes.model === "string" ? attributes.model : void 0;
+      return startObservation(name, { metadata: attributes, model }, { asType: "generation" });
+    }
+    case "tool":
+      return startObservation(name, { metadata: attributes }, { asType: "tool" });
+  }
+}
+function createChildObservation(parent, kind, name, attributes) {
+  switch (kind) {
+    case "agent":
+      return parent.startObservation(name, { metadata: attributes }, { asType: "agent" });
+    case "generation": {
+      const model = typeof attributes.model === "string" ? attributes.model : void 0;
+      return parent.startObservation(
+        name,
+        { metadata: attributes, model },
+        { asType: "generation" }
+      );
+    }
+    case "tool":
+      return parent.startObservation(name, { metadata: attributes }, { asType: "tool" });
+  }
+}
+var ProviderObservation = class _ProviderObservation {
+  constructor(observation) {
+    this.observation = observation;
+  }
+  observation;
+  end() {
+    this.observation.end();
+  }
+  recordException(error) {
+    const errorType = error instanceof Error ? error.name : typeof error;
+    this.observation.otelSpan.setAttribute("error.type", errorType);
+    this.observation.otelSpan.setStatus({ code: SpanStatusCode.ERROR });
+    this.observation.updateOtelSpanAttributes({
+      level: "ERROR",
+      statusMessage: errorType
+    });
+  }
+  startChild(kind, name, attributes = {}) {
+    return new _ProviderObservation(
+      createChildObservation(this.observation, kind, name, attributes)
+    );
+  }
+  update(update) {
+    this.observation.updateOtelSpanAttributes(update);
+  }
+};
+var ProviderRuntime = class {
+  constructor(tracerProvider, loggerProvider, meterProvider, meter, logger, sentry) {
+    this.tracerProvider = tracerProvider;
+    this.loggerProvider = loggerProvider;
+    this.meterProvider = meterProvider;
+    this.meter = meter;
+    this.logger = logger;
+    this.sentry = sentry;
+  }
+  tracerProvider;
+  loggerProvider;
+  meterProvider;
+  meter;
+  logger;
+  sentry;
+  counters = /* @__PURE__ */ new Map();
+  histograms = /* @__PURE__ */ new Map();
+  mode = "unknown";
+  captureError(error, context) {
+    this.sentry?.captureException(error, { tags: { context, mode: this.mode } });
+    this.emitLog("swifty.error", "error", {
+      context,
+      "error.type": error instanceof Error ? error.name : typeof error
+    });
+  }
+  emitLog(name, severity, attributes = {}) {
+    this.logger?.emit({
+      attributes: { ...attributes, "swifty.mode": this.mode },
+      body: name,
+      severityNumber: severityNumber(severity),
+      severityText: severity.toUpperCase()
+    });
+  }
+  async flush() {
+    const operations = [];
+    if (this.tracerProvider) {
+      operations.push(this.tracerProvider.forceFlush());
+    }
+    if (this.loggerProvider) {
+      operations.push(this.loggerProvider.forceFlush());
+    }
+    if (this.meterProvider) {
+      operations.push(this.meterProvider.forceFlush());
+    }
+    if (this.sentry) {
+      operations.push(this.sentry.flush(SHUTDOWN_TIMEOUT_MS));
+    }
+    await withTimeout(Promise.allSettled(operations).then(() => void 0));
+  }
+  recordMetric(name, kind, value, attributes = {}) {
+    if (!this.meter) {
+      return;
+    }
+    const mergedAttributes = { ...attributes, "swifty.mode": this.mode };
+    if (kind === "counter") {
+      let counter = this.counters.get(name);
+      if (!counter) {
+        counter = this.meter.createCounter(name);
+        this.counters.set(name, counter);
+      }
+      counter.add(value, mergedAttributes);
+      return;
+    }
+    let histogram = this.histograms.get(name);
+    if (!histogram) {
+      histogram = this.meter.createHistogram(name, { unit: "ms" });
+      this.histograms.set(name, histogram);
+    }
+    histogram.record(value, mergedAttributes);
+  }
+  setMode(mode) {
+    this.mode = mode;
+    this.sentry?.setTag("swifty.mode", mode);
+  }
+  async shutdown() {
+    const operations = [];
+    if (this.tracerProvider) {
+      operations.push(this.tracerProvider.shutdown());
+    }
+    if (this.loggerProvider) {
+      operations.push(this.loggerProvider.shutdown());
+    }
+    if (this.meterProvider) {
+      operations.push(this.meterProvider.shutdown());
+    }
+    if (this.sentry) {
+      operations.push(this.sentry.close(SHUTDOWN_TIMEOUT_MS));
+    }
+    await withTimeout(Promise.allSettled(operations).then(() => void 0));
+    setLangfuseTracerProvider(null);
+  }
+  startObservation(kind, name, attributes = {}) {
+    if (!this.tracerProvider) {
+      return {
+        end: () => void 0,
+        recordException: () => void 0,
+        startChild: (childKind, childName, childAttributes) => this.startObservation(childKind, childName, childAttributes),
+        update: () => void 0
+      };
+    }
+    return new ProviderObservation(
+      createRootObservation(kind, name, { ...attributes, "swifty.mode": this.mode })
+    );
+  }
+};
+async function createTelemetryRuntime() {
+  const resource = createResource();
+  const otelEnabled = process.env.OTEL_SDK_DISABLED?.toLowerCase() !== "true";
+  const [tracerProvider, loggerProvider, metricReaders, sentry] = await Promise.all([
+    otelEnabled ? safely(() => createTracerProvider(resource)) : Promise.resolve(null),
+    otelEnabled ? safely(() => createLoggerProvider(resource)) : Promise.resolve(null),
+    otelEnabled ? safely(createMetricReaders) : Promise.resolve(null),
+    safely(initializeSentry)
+  ]);
+  const meterProvider = metricReaders && metricReaders.length > 0 ? new MeterProvider({ readers: metricReaders, resource }) : null;
+  const meter = meterProvider?.getMeter("@swifty.js/swifty", version) ?? null;
+  const logger = loggerProvider?.getLogger("@swifty.js/swifty", version) ?? null;
+  return new ProviderRuntime(tracerProvider, loggerProvider, meterProvider, meter, logger, sentry);
+}
+
+export {
+  version,
+  version_exports,
+  parseExporterTypes,
+  createTelemetryRuntime,
+  providers_exports
+};

package/dist/lib/{chunk-BCBD34D2.js → chunk-OLFXCZVH.js}

@@ -3,9 +3,30 @@ import {
   asRecord,
   createChildLogger,
   strArg
-} from "./chunk-3XCGUKGJ.js";
+} from "./chunk-ZPIF7IJN.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 = "__";
@@ -225,13 +246,10 @@ var McpCallTool = class {
 
 export {
   MCP_TOOL_PREFIX,
-  MCP_NAME_SEP,
-  sanitizeSegment,
-  mcpToolNamePrefix,
-  buildMcpToolName,
   MCPToolWrapper,
-  coerceBySchema,
+  tool_wrapper_exports,
   mcpCallPermissionContent,
   isMcpToolLike,
-  McpCallTool
+  McpCallTool,
+  mcp_call_exports
 };

package/dist/lib/{chunk-SOOSTGHI.js → chunk-RUDYC7OS.js}

@@ -1,47 +1,32 @@
 import {
   mcpCallPermissionContent
-} from "./chunk-BCBD34D2.js";
+} from "./chunk-OLFXCZVH.js";
 import {
+  canonicalPath,
   createChildLogger,
+  isPathWithin,
   isRecord,
   strArg
-} from "./chunk-3XCGUKGJ.js";
+} from "./chunk-ZPIF7IJN.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
 
-// src/permissions/checker.ts
+// src/permissions/index.ts
+var permissions_exports = {};
+__export(permissions_exports, {
+  PathSandbox: () => PathSandbox,
+  PermissionChecker: () => PermissionChecker,
+  RuleEngine: () => RuleEngine,
+  evaluateRules: () => evaluateRules,
+  extractContent: () => extractContent,
+  isSafeCommand: () => isSafeCommand
+});
 import { readFileSync, writeFileSync, mkdirSync, statSync } from "fs";
 import { homedir, tmpdir } from "os";
-import { join as join2, resolve as resolve2, dirname as dirname2 } from "path";
+import { join, resolve, dirname } from "path";
 import yaml from "js-yaml";
 import z, { parse } from "zod";
-
-// src/utils/paths.ts
-import { realpathSync } from "fs";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "path";
-function canonicalPath(path) {
-  let current = resolve(path);
-  const missing = [];
-  for (; ; ) {
-    try {
-      return join(realpathSync(current), ...missing);
-    } catch (error) {
-      if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT" && error.code !== "ENOTDIR") {
-        throw error;
-      }
-      const parent = dirname(current);
-      if (parent === current) {
-        return resolve(path);
-      }
-      missing.unshift(basename(current));
-      current = parent;
-    }
-  }
-}
-function isPathWithin(root, path) {
-  const child = relative(root, path);
-  return child === "" || child !== ".." && !child.startsWith(`..${sep}`) && !isAbsolute(child);
-}
-
-// src/permissions/checker.ts
 var log = createChildLogger({ module: "permissions" });
 var DANGEROUS_PATTERNS = [];
 var SAFE_PREFIXES = [
@@ -262,23 +247,23 @@ var PathSandbox = class {
   denyWritePaths;
   projectDir;
   constructor(projectDir) {
-    this.projectDir = resolve2(projectDir);
+    this.projectDir = resolve(projectDir);
     this.allowedRoots = [this.projectDir, tmpdir()];
-    this.denyWritePaths = DEFAULT_DENY_WRITE.map((p) => join2(this.projectDir, p));
+    this.denyWritePaths = DEFAULT_DENY_WRITE.map((p) => join(this.projectDir, p));
   }
   addRoot(root) {
-    this.allowedRoots.push(resolve2(root));
+    this.allowedRoots.push(resolve(root));
   }
   // Add custom deny-write paths
   addDenyWrite(path) {
-    this.denyWritePaths.push(resolve2(path));
+    this.denyWritePaths.push(resolve(path));
   }
   /**
    * Check whether a path is in the deny-write list.
    * denyWrite has the highest priority — even if the path is within an allowed root, writes are still denied.
    */
   checkDenyWrite(filePath) {
-    const absolute = resolve2(this.projectDir, filePath);
+    const absolute = resolve(this.projectDir, filePath);
     const canonical = canonicalPath(absolute);
     for (const denied of this.denyWritePaths) {
       if (isPathWithin(denied, absolute) || isPathWithin(canonicalPath(denied), canonical)) {
@@ -291,7 +276,7 @@ var PathSandbox = class {
     return null;
   }
   check(filePath) {
-    const absolute = canonicalPath(resolve2(this.projectDir, filePath));
+    const absolute = canonicalPath(resolve(this.projectDir, filePath));
     for (const root of this.allowedRoots) {
       if (isPathWithin(canonicalPath(root), absolute)) {
         return null;
@@ -373,8 +358,8 @@ var RuleEngine = class {
   projectPath;
   cache = /* @__PURE__ */ new Map();
   constructor(workDir) {
-    this.userPath = join2(homedir(), ".swifty", "permissions.yaml");
-    this.projectPath = join2(workDir, ".swifty", "permissions.yaml");
+    this.userPath = join(homedir(), ".swifty", "permissions.yaml");
+    this.projectPath = join(workDir, ".swifty", "permissions.yaml");
   }
   // Read a single rules file; skips disk I/O and parsing on cache hit.
   rulesFor(path) {
@@ -411,7 +396,7 @@ var RuleEngine = class {
   // Persists a rule to the project-level YAML file in the `Tool(pattern)`
   // format so "allow always" survives a restart.
   appendProjectRule(rule) {
-    mkdirSync(dirname2(this.projectPath), { recursive: true });
+    mkdirSync(dirname(this.projectPath), { recursive: true });
     const rules = loadRulesFile(this.projectPath);
     const exists = rules.some(
       (r) => r.tool === rule.tool && r.pattern === rule.pattern && r.effect === rule.effect
@@ -496,7 +481,7 @@ var PermissionChecker = class _PermissionChecker {
     }
     if (this.mode === "plan" && (toolName === "WriteFile" || toolName === "EditFile")) {
       const path = strArg(args, "file_path", "");
-      if (this.planFilePath && canonicalPath(resolve2(this.workDir, path)) === canonicalPath(resolve2(this.workDir, this.planFilePath)) && !this.sandbox.checkDenyWrite(path)) {
+      if (this.planFilePath && canonicalPath(resolve(this.workDir, path)) === canonicalPath(resolve(this.workDir, this.planFilePath)) && !this.sandbox.checkDenyWrite(path)) {
         return {
           effect: "allow",
           reason: "Plan file write allowed in plan mode"
@@ -579,13 +564,13 @@ var PermissionChecker = class _PermissionChecker {
     const isFilePath = toolName === "ReadFile" || toolName === "WriteFile" || toolName === "EditFile";
     let pattern;
     if (isFilePath && content) {
-      const abs = resolve2(this.workDir, content);
+      const abs = resolve(this.workDir, content);
       let isDir = false;
       try {
         isDir = statSync(abs).isDirectory();
       } catch {
       }
-      pattern = join2(isDir ? abs : dirname2(abs), "*");
+      pattern = join(isDir ? abs : dirname(abs), "*");
     } else {
       const words = content.trim().split(/\s+/).slice(0, 2);
       pattern = words.join(" ") + "*";
@@ -619,12 +604,11 @@ var PermissionChecker = class _PermissionChecker {
 };
 
 export {
-  canonicalPath,
-  isPathWithin,
   extractContent,
   PathSandbox,
   evaluateRules,
   RuleEngine,
   isSafeCommand,
-  PermissionChecker
+  PermissionChecker,
+  permissions_exports
 };