@wrongstack/tools 0.313.0 → 0.316.1

package/dist/chunk-Q5JPPCZC.js

@@ -0,0 +1,12 @@
+// src/_regex.ts
+import {
+  capSubject,
+  compileUserRegex,
+  MAX_SUBJECT_LEN
+} from "@wrongstack/primitives";
+
+export {
+  capSubject,
+  compileUserRegex
+};
+//# sourceMappingURL=chunk-Q5JPPCZC.js.map

package/dist/chunk-QBV725YG.js

@@ -0,0 +1,128 @@
+// src/tool-help.ts
+var toolHelpTool = {
+  name: "tool_help",
+  category: "Meta",
+  description: "Get detailed help for a specific tool, including its full input schema and usage guidance. If you do not know which tool to use, search with `tool_search` first, then call this with the tool name.",
+  usageHint: "USE WHEN YOU NEED PRECISE TOOL INFORMATION:\n\n- Call with a specific `tool` name when you want the full schema and current usageHint.\n- Omit `tool` to get an overview of all available tools.\n- Different `format` options give you different levels of detail.\n- Tip: use `tool_search` to find the right tool name, then `tool_help` for the full schema.\nThis tool is extremely valuable for self-correction when you are unsure about a tool's interface.",
+  permission: "auto",
+  mutating: false,
+  timeoutMs: 5e3,
+  capabilities: ["tool.meta"],
+  icon: "meta",
+  inputSchema: {
+    type: "object",
+    properties: {
+      tool: {
+        type: "string",
+        description: "Specific tool name to get detailed help for. Omit to get a list of all tools."
+      },
+      format: {
+        type: "string",
+        enum: ["short", "full", "markdown"],
+        description: 'Level of detail: "short" (summary), "full" (with full schema), "markdown" (human readable).'
+      },
+      include_examples: {
+        type: "boolean",
+        description: "Whether to include example usage in the response."
+      }
+    }
+  },
+  async execute(input, ctx) {
+    const format = input.format ?? "short";
+    const includeExamples = input.include_examples ?? false;
+    if (input.tool) {
+      const tool = (ctx.catalogTools ?? ctx.tools).find((t) => t.name === input.tool);
+      if (!tool) {
+        return {
+          tool: input.tool,
+          help: `No tool found with name "${input.tool}"`,
+          tools: [],
+          total: 0
+        };
+      }
+      return {
+        tool: tool.name,
+        help: formatToolHelp(tool, format, includeExamples),
+        tools: [
+          {
+            name: tool.name,
+            description: tool.description,
+            usageHint: tool.usageHint ?? "",
+            inputSchema: tool.inputSchema,
+            permission: tool.permission,
+            mutating: tool.mutating
+          }
+        ],
+        total: 1
+      };
+    }
+    const allTools = (ctx.catalogTools ?? ctx.tools).map((t) => ({
+      name: t.name,
+      description: t.description,
+      usageHint: t.usageHint ?? "",
+      inputSchema: format === "full" ? t.inputSchema : void 0,
+      permission: t.permission,
+      mutating: t.mutating
+    }));
+    return {
+      help: format === "markdown" ? formatAllToolsMarkdown(allTools) : formatAllToolsShort(allTools),
+      tools: allTools,
+      total: allTools.length
+    };
+  }
+};
+function formatToolHelp(tool, format, includeExamples) {
+  const lines = [];
+  if (format === "short") {
+    lines.push(`${tool.name}: ${tool.description}`);
+    if (tool.usageHint) lines.push(`Hint: ${tool.usageHint}`);
+    return lines.join("\n");
+  }
+  if (format === "markdown") {
+    lines.push(`## ${tool.name}`);
+    lines.push("");
+    lines.push(tool.description);
+    lines.push("");
+    lines.push("**Permission:** " + tool.permission);
+    lines.push("**Mutating:** " + (tool.mutating ? "yes" : "no"));
+    if (tool.usageHint) {
+      lines.push("");
+      lines.push("### Usage Hint");
+      lines.push(tool.usageHint);
+    }
+    if (includeExamples && tool.inputSchema) {
+      lines.push("");
+      lines.push("### Input Schema");
+      lines.push("```json");
+      lines.push(JSON.stringify(tool.inputSchema, null, 2));
+      lines.push("```");
+    }
+    return lines.join("\n");
+  }
+  lines.push(`Tool: ${tool.name}`);
+  lines.push(`Description: ${tool.description}`);
+  lines.push(`Permission: ${tool.permission}`);
+  lines.push(`Mutating: ${tool.mutating}`);
+  if (tool.usageHint) lines.push(`Usage: ${tool.usageHint}`);
+  if (format === "full" && tool.inputSchema) {
+    lines.push("Schema: " + JSON.stringify(tool.inputSchema, null, 2));
+  }
+  return lines.join("\n");
+}
+function formatAllToolsShort(tools) {
+  return tools.map((t) => `  ${t.name.padEnd(16)} ${t.description}`).join("\n");
+}
+function formatAllToolsMarkdown(tools) {
+  const lines = ["## Available Tools", ""];
+  lines.push("| Tool | Description |");
+  lines.push("|------|-------------|");
+  for (const t of tools) {
+    lines.push(`| \`${t.name}\` | ${t.description} |`);
+  }
+  return lines.join("\n");
+}
+
+export {
+  toolHelpTool
+};
+//# sourceMappingURL=chunk-QBV725YG.js.map

package/dist/chunk-QZQSPUBF.js

@@ -0,0 +1,315 @@
+import {
+  enqueueReindex
+} from "./chunk-HYX2TZ7O.js";
+import {
+  resolveRealInsideRoot,
+  safeResolveReal,
+  sha256hex
+} from "./chunk-D33S4RQG.js";
+
+// src/patch.ts
+import { spawn } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { buildChildEnv, toErrorMessage } from "@wrongstack/core/utils";
+var patchTool = {
+  name: "patch",
+  category: "Filesystem",
+  description: "Apply a unified diff (patch) to the project. This is the correct tool when you have a diff that needs to be applied precisely, including handling of rejects.",
+  usageHint: "Best used when you already have a diff (from generation, external source, or previous step).\n- Use `dry_run: true` to see what would happen without modifying files.\n- Applied with `--merge`: a conflicting hunk writes git-style conflict\n  markers (<<<<<<< / ======= / >>>>>>>) INTO the file and reports failure.\n  It does NOT create .rej/.orig files. `files` lists what changed on disk\n  even when the patch failed, so read those back before retrying.\nOften cleaner than many small `edit` operations for larger changes.",
+  selection: {
+    doNotUseWhen: "you do not already have a unified diff or only need one precise replacement.",
+    useInstead: ["edit"]
+  },
+  permission: "confirm",
+  // WS-046: gives permission decisions something to key on.
+  // The target directory. The patch body itself is unstable (every diff
+  // differs), so it could never re-match its own stored rule.
+  subjectKey: "directory",
+  mutating: true,
+  capabilities: ["fs.write"],
+  icon: "edit",
+  timeoutMs: 3e4,
+  inputSchema: {
+    type: "object",
+    properties: {
+      patch: { type: "string", description: "Unified diff patch content" },
+      directory: { type: "string", description: "Root directory for patch (default: cwd)" },
+      strip: { type: "integer", description: "Strip leading path components (default: 1)" },
+      dry_run: { type: "boolean", description: "Preview without applying" }
+    },
+    required: ["patch"]
+  },
+  async execute(input, ctx, opts) {
+    if (!input?.patch) throw new Error("patch: patch content is required");
+    const strip = Math.max(1, input.strip ?? 1);
+    const dryRun = input.dry_run ?? false;
+    const refuse = (message) => ({
+      applied: 0,
+      rejected: 1,
+      files: [],
+      dry_run: dryRun,
+      message
+    });
+    let dir;
+    try {
+      dir = input.directory ? await safeResolveReal(input.directory, ctx) : ctx.cwd;
+    } catch (err) {
+      return refuse(`patch refused: ${toErrorMessage(err)}`);
+    }
+    const realRoot = await fs.realpath(ctx.projectRoot).catch(() => path.resolve(ctx.projectRoot));
+    const targets = extractDiffTargets(input.patch);
+    const resolvedTargets = [];
+    for (const t of targets) {
+      const stripped = stripPathComponents(t.raw, strip);
+      if (!stripped) continue;
+      if (path.isAbsolute(stripped)) {
+        return refuse(`patch refused: target "${t.raw}" strips to absolute path`);
+      }
+      const candidate = path.resolve(dir, stripped);
+      let real;
+      try {
+        real = await resolveRealInsideRoot(candidate, ctx);
+      } catch (err) {
+        return refuse(`patch refused: target "${t.raw}" ${toErrorMessage(err)}`);
+      }
+      const rel = path.relative(realRoot, real);
+      if (rel.startsWith("..") || path.isAbsolute(rel)) {
+        return refuse(`patch refused: target "${t.raw}" resolves outside project root`);
+      }
+      resolvedTargets.push({ raw: t.raw, deleted: t.deleted, abs: real });
+    }
+    const beforeContents = /* @__PURE__ */ new Map();
+    const beforeExisted = /* @__PURE__ */ new Set();
+    if (!dryRun) {
+      for (const target of resolvedTargets) {
+        const existed = (await fs.stat(target.abs).catch(() => null))?.isFile() ?? false;
+        if (existed) beforeExisted.add(target.abs);
+        beforeContents.set(target.abs, await readTextForTracking(target.abs));
+      }
+    }
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), ".wstack_patch_"));
+    try {
+      await fs.chmod(tmpDir, 448).catch(() => {
+      });
+      const patchFile = path.join(tmpDir, "in.diff");
+      await fs.writeFile(patchFile, input.patch, { mode: 384 });
+      const args = [`-p${strip}`, "--merge", ...dryRun ? ["--dry-run"] : [], "-i", patchFile];
+      const result = await runPatch(args, dir, opts.signal, {
+        patchFile,
+        strip,
+        dryRun
+      });
+      const touched = [];
+      if (!dryRun) {
+        for (const target of resolvedTargets) {
+          const abs = target.abs;
+          const before = beforeContents.get(abs) ?? null;
+          const stat2 = await fs.stat(abs).catch(() => null);
+          if (!stat2?.isFile()) {
+            if (beforeExisted.has(abs)) {
+              touched.push(abs);
+              ctx.session?.recordFileChange?.({
+                path: abs,
+                action: "deleted",
+                before,
+                after: null
+              });
+            }
+            continue;
+          }
+          const after = await readTextForTracking(abs);
+          if (after === null || after === before) continue;
+          touched.push(abs);
+          ctx.recordRead?.(abs, stat2.mtimeMs, "write", sha256hex(after));
+          ctx.session?.recordFileChange?.({
+            path: abs,
+            action: before === null ? "created" : "modified",
+            before,
+            after
+          });
+        }
+        if (touched.length > 0) {
+          try {
+            enqueueReindex({ projectRoot: ctx.projectRoot, files: touched });
+          } catch {
+          }
+        }
+      }
+      if (result.exitCode !== 0) {
+        if (!dryRun) {
+          const partial = touched.length > 0 ? ` ${touched.length} file(s) were still modified on disk and have been recorded for rewind: ${touched.map((p) => path.relative(realRoot, p) || p).join(", ")}.` : "";
+          return {
+            applied: touched.length,
+            rejected: 1,
+            // Normalize to relative-to-realRoot for API consistency with the
+            // success path (which returns GNU patch's dir-relative names).
+            // `touched` entries are realpaths from resolveRealInsideRoot, and
+            // realRoot is also a realpath, so path.relative is like-for-like.
+            files: touched.map((p) => path.relative(realRoot, p) || p),
+            dry_run: dryRun,
+            message: `patch failed: ${result.stderr || result.stdout}${partial}`
+          };
+        }
+        const wouldPatch = extractPatchedFiles(result.stdout);
+        return {
+          applied: wouldPatch.length,
+          rejected: 1,
+          files: wouldPatch,
+          dry_run: dryRun,
+          message: `patch preview: would conflict \u2014 ${result.stderr || result.stdout}`
+        };
+      }
+      const patched = result.engine === "git" ? [
+        ...new Set(
+          resolvedTargets.map((target) => path.relative(dir, target.abs) || target.abs)
+        )
+      ] : extractPatchedFiles(result.stdout);
+      return {
+        applied: patched.length,
+        rejected: 0,
+        files: patched,
+        dry_run: dryRun,
+        message: result.stdout || "patch applied"
+      };
+    } finally {
+      await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+  }
+};
+var MAX_TRACKING_BYTES = 5 * 1024 * 1024;
+async function readTextForTracking(absPath) {
+  try {
+    const stat2 = await fs.stat(absPath);
+    if (!stat2.isFile() || stat2.size > MAX_TRACKING_BYTES) return null;
+    const buf = await fs.readFile(absPath);
+    if (buf.includes(0)) return null;
+    return buf.toString("utf8");
+  } catch {
+    return null;
+  }
+}
+function extractDiffTargets(patch) {
+  const out = [];
+  const clean = (raw) => {
+    if (!raw) return "";
+    return (raw.length > 4096 ? raw.slice(0, 4096) : raw).trim();
+  };
+  let lastOld;
+  let inHunk = false;
+  let oldLinesLeft = 0;
+  let newLinesLeft = 0;
+  for (const line of patch.split(/\r?\n/)) {
+    const hunkMatch = /^@@ -\d+(?:,(\d+))? \+\d+(?:,(\d+))? @@/.exec(line);
+    if (hunkMatch) {
+      inHunk = true;
+      oldLinesLeft = hunkMatch[1] ? Number(hunkMatch[1]) : 1;
+      newLinesLeft = hunkMatch[2] ? Number(hunkMatch[2]) : 1;
+      lastOld = void 0;
+      continue;
+    }
+    if (inHunk) {
+      const ch = line[0];
+      if (ch === "-") oldLinesLeft--;
+      else if (ch === "+") newLinesLeft--;
+      else if (ch === " " || ch === void 0) {
+        oldLinesLeft--;
+        newLinesLeft--;
+      }
+      if (oldLinesLeft <= 0 && newLinesLeft <= 0) inHunk = false;
+      continue;
+    }
+    const oldMatch = /^---\s+([^\t\r\n]+)/.exec(line);
+    if (oldMatch) {
+      lastOld = clean(oldMatch[1]);
+      continue;
+    }
+    const newMatch = /^\+\+\+\s+([^\t\r\n]+)/.exec(line);
+    if (!newMatch) continue;
+    const newTarget = clean(newMatch[1]);
+    if (newTarget && newTarget !== "/dev/null") {
+      out.push({ raw: newTarget, deleted: false });
+    } else if (lastOld && lastOld !== "/dev/null") {
+      out.push({ raw: lastOld, deleted: true });
+    }
+    lastOld = void 0;
+  }
+  return out;
+}
+function stripPathComponents(p, strip) {
+  const s = p.replace(/\\/g, "/");
+  let idx = 0;
+  for (let i = 0; i < strip; i++) {
+    while (idx < s.length && s[idx] !== "/") idx++;
+    let hadSlash = false;
+    while (idx < s.length && s[idx] === "/") {
+      idx++;
+      hadSlash = true;
+    }
+    if (!hadSlash) return void 0;
+  }
+  return s.slice(idx) || void 0;
+}
+function runPatch(args, cwd, signal, fallback) {
+  return runPatchProcess("patch", args, cwd, signal).then(async (result) => {
+    if (!result.unavailable) return { ...result, engine: "patch" };
+    const gitArgs = [
+      "apply",
+      "--unsafe-paths",
+      `-p${fallback.strip}`,
+      "--verbose",
+      ...fallback.dryRun ? ["--check"] : [],
+      fallback.patchFile
+    ];
+    const gitResult = await runPatchProcess("git", gitArgs, cwd, signal);
+    return { ...gitResult, engine: "git" };
+  });
+}
+function runPatchProcess(command, args, cwd, signal) {
+  return new Promise((resolve2) => {
+    let stdout = "";
+    let stderr = "";
+    const env = { ...buildChildEnv(), LANG: "C", LC_ALL: "C" };
+    const child = spawn(command, args, {
+      cwd,
+      signal,
+      env,
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true
+    });
+    child.stdout?.on("data", (c) => {
+      stdout += c.toString();
+    });
+    child.stderr?.on("data", (c) => {
+      stderr += c.toString();
+    });
+    child.on(
+      "close",
+      (code) => resolve2({ exitCode: code ?? 1, stdout, stderr, unavailable: false })
+    );
+    child.on(
+      "error",
+      (e) => resolve2({
+        exitCode: 1,
+        stdout: "",
+        stderr: e.message,
+        unavailable: e.code === "ENOENT"
+      })
+    );
+  });
+}
+function extractPatchedFiles(output) {
+  const files = [];
+  const re = /(?:patching|checking) file (.+)/gi;
+  for (const m of output.matchAll(re)) {
+    if (m[1]) files.push(m[1]);
+  }
+  return files;
+}
+
+export {
+  patchTool
+};
+//# sourceMappingURL=chunk-QZQSPUBF.js.map

package/dist/chunk-RGISBZBD.js

@@ -0,0 +1,231 @@
+import {
+  compileUserRegex
+} from "./chunk-Q5JPPCZC.js";
+import {
+  safeResolveReal
+} from "./chunk-D33S4RQG.js";
+
+// src/logs.ts
+import { spawn } from "node:child_process";
+import { buildChildEnv } from "@wrongstack/core/utils";
+var logsTool = {
+  name: "logs",
+  category: "Logs",
+  description: "Read logs from files or Docker containers. Useful for debugging running applications.",
+  usageHint: "DEBUGGING TOOL \u2014 USE CAREFULLY IN AUTONOMOUS MODE:\n\n- Prefer `path` for local files or `service` for Docker containers.\n- Always use `filter` (regex) when possible to reduce noise and token usage.\n- `since` narrows Docker logs to a recent window.",
+  permission: "confirm",
+  mutating: false,
+  timeoutMs: 3e4,
+  maxOutputBytes: 262144,
+  capabilities: ["shell.restricted"],
+  icon: "logs",
+  inputSchema: {
+    type: "object",
+    properties: {
+      service: {
+        type: "string",
+        description: "Docker container name (passed to `docker logs`)"
+      },
+      path: {
+        type: "string",
+        description: "Path to log file (alternative to service)"
+      },
+      lines: {
+        type: "integer",
+        description: "Number of log lines to fetch (default: 100, 0 for all)",
+        minimum: 0,
+        maximum: 1e4
+      },
+      filter: {
+        type: "string",
+        description: "Regex pattern to filter log lines"
+      },
+      since: {
+        type: "string",
+        enum: ["1h", "6h", "24h", "all"],
+        description: 'Only show Docker logs since duration (ignored for files; "all" = no limit)'
+      },
+      cwd: { type: "string", description: "Working directory (default: cwd)" }
+    }
+  },
+  async execute(input, ctx, opts) {
+    const cwd = input.cwd ? await safeResolveReal(input.cwd, ctx) : ctx.cwd;
+    const lines = input.lines ?? 100;
+    let filterRe = null;
+    if (input.filter) {
+      const compiled = compileUserRegex(input.filter, "i");
+      if (!compiled.ok) {
+        throw new Error(`logs: ${compiled.reason}`);
+      }
+      filterRe = compiled.regex;
+    }
+    if (input.service) {
+      return await dockerLogs(input.service, lines, filterRe, cwd, opts.signal, input.since);
+    }
+    if (input.path) {
+      return await fileLogs(await safeResolveReal(input.path, ctx), lines, filterRe);
+    }
+    return {
+      source: "none",
+      entries: [],
+      total: 0,
+      truncated: false,
+      stream_mode: false
+    };
+  }
+};
+async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
+  const args = ["logs"];
+  if (lines > 0) args.push("--tail", String(lines));
+  if (since && since !== "all") {
+    const sinceMap = { "1h": "1h", "6h": "6h", "24h": "24h" };
+    args.push("--since", sinceMap[since] ?? "1h");
+  }
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9._:-]+$/.test(service)) {
+    return {
+      source: `docker:${service}`,
+      entries: [],
+      total: 0,
+      truncated: false,
+      stream_mode: false
+    };
+  }
+  args.push("--timestamps", service);
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    const MAX = 2e5;
+    let settled = false;
+    const empty = () => ({
+      source: `docker:${service}`,
+      entries: [],
+      total: 0,
+      truncated: false,
+      stream_mode: false
+    });
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(result);
+    };
+    const child = spawn("docker", args, {
+      cwd,
+      signal,
+      env: buildChildEnv(),
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      finish(empty());
+    }, DOCKER_LOGS_TIMEOUT_MS);
+    child.stdout?.on("data", (c) => {
+      if (stdout.length < MAX) stdout += c.toString();
+    });
+    child.stderr?.on("data", (c) => {
+      if (stderr.length < MAX) stderr += c.toString();
+    });
+    child.stdout?.on("error", (e) => {
+      console.log(
+        JSON.stringify({ level: "debug", event: "pipe_error", stream: "stdout", error: e.message })
+      );
+    });
+    child.stderr?.on("error", (e) => {
+      console.log(
+        JSON.stringify({ level: "debug", event: "pipe_error", stream: "stderr", error: e.message })
+      );
+    });
+    child.on("close", () => {
+      const output = stdout + stderr;
+      const entries = parseLogLines(output, filterRe);
+      finish({
+        source: `docker:${service}`,
+        entries,
+        total: entries.length,
+        truncated: output.length >= MAX,
+        stream_mode: false
+      });
+    });
+    child.on("error", () => finish(empty()));
+  });
+}
+var DOCKER_LOGS_TIMEOUT_MS = 3e3;
+var MAX_TAIL_LINES = 1e5;
+async function fileLogs(path, lines, filterRe) {
+  const { createInterface } = await import("node:readline");
+  const { createReadStream } = await import("node:fs");
+  const entries = [];
+  const effLines = lines > 0 ? Math.min(lines, MAX_TAIL_LINES) : MAX_TAIL_LINES;
+  const window = new Array(effLines);
+  let writeIdx = 0;
+  let totalLines = 0;
+  const rl = createInterface({
+    input: createReadStream(path),
+    crlfDelay: Number.POSITIVE_INFINITY
+  });
+  for await (const line of rl) {
+    if (filterRe && !filterRe.test(line)) continue;
+    window[writeIdx] = line;
+    writeIdx = (writeIdx + 1) % effLines;
+    totalLines++;
+  }
+  const ordered = [];
+  const start = totalLines >= effLines ? writeIdx : 0;
+  const count = Math.min(totalLines, effLines);
+  for (let i = 0; i < count; i++) {
+    const v = window[(start + i) % effLines];
+    if (v !== void 0) ordered.push(v);
+  }
+  for (const line of ordered) {
+    const parsed = parseLine(line);
+    if (parsed) entries.push(parsed);
+  }
+  return {
+    source: path,
+    entries,
+    total: entries.length,
+    truncated: totalLines > effLines,
+    stream_mode: false
+  };
+}
+function parseLogLines(output, filterRe) {
+  const lines = output.split("\n").filter(Boolean);
+  const entries = [];
+  for (const line of lines) {
+    if (filterRe && !filterRe.test(line)) continue;
+    const parsed = parseLine(line);
+    if (parsed) entries.push(parsed);
+  }
+  return entries;
+}
+function parseLine(line) {
+  const tsRe = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?)\s+(?:\[?(\w+)\]?)\s*(.*)/;
+  const match = tsRe.exec(line);
+  if (match) {
+    return {
+      timestamp: match[1] ?? "",
+      level: match[2]?.toLowerCase() ?? "info",
+      message: match[3] ?? ""
+    };
+  }
+  const levelRe = /(ERROR|WARN|INFO|DEBUG|TRACE)\s+(.*)/i;
+  const levelMatch = levelRe.exec(line);
+  if (levelMatch) {
+    return {
+      timestamp: "",
+      level: levelMatch[1]?.toLowerCase() ?? "info",
+      message: levelMatch[2] ?? line
+    };
+  }
+  return {
+    timestamp: "",
+    level: "info",
+    message: line
+  };
+}
+
+export {
+  logsTool
+};
+//# sourceMappingURL=chunk-RGISBZBD.js.map