@ai-setting/roy-agent-core 1.4.11 → 1.4.12

package/dist/env/tool/built-in/index.js

@@ -0,0 +1,1151 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// packages/core/src/env/log-trace/opentelemetry/propagation.ts
+function padLeft(str, length) {
+  return str.padStart(length, "0");
+}
+function isValidHex(str) {
+  return /^[0-9a-f]+$/i.test(str);
+}
+function serialize(context) {
+  const traceId = padLeft(context.traceId.toLowerCase(), TRACE_ID_LENGTH);
+  const spanId = padLeft(context.spanId.toLowerCase(), PARENT_SPAN_ID_LENGTH);
+  const parts = [
+    TRACE_CONTEXT_VERSION,
+    traceId,
+    spanId,
+    TRACE_FLAGS_SAMPLED
+  ];
+  return parts.join("-");
+}
+function parse(traceparent) {
+  if (!traceparent || typeof traceparent !== "string") {
+    return;
+  }
+  const trimmed = traceparent.trim();
+  const parts = trimmed.split("-");
+  if (parts.length !== 4) {
+    return;
+  }
+  const [version, traceId, senderSpanId, flags] = parts;
+  if (version !== TRACE_CONTEXT_VERSION) {
+    if (version > TRACE_CONTEXT_VERSION) {
+      return;
+    }
+  }
+  if (traceId.length !== TRACE_ID_LENGTH || !isValidHex(traceId)) {
+    return;
+  }
+  if (senderSpanId.length !== PARENT_SPAN_ID_LENGTH || !isValidHex(senderSpanId)) {
+    return;
+  }
+  if (flags.length !== FLAGS_LENGTH || !isValidHex(flags)) {
+    return;
+  }
+  return {
+    traceId: traceId.toLowerCase(),
+    spanId: senderSpanId.toLowerCase()
+  };
+}
+var TRACE_CONTEXT_VERSION = "00", TRACE_FLAGS_SAMPLED = "01", TRACEPARENT_HEADER = "TRACEPARENT", TRACE_ID_LENGTH = 32, PARENT_SPAN_ID_LENGTH = 16, FLAGS_LENGTH = 2, propagation;
+var init_propagation = __esm(() => {
+  propagation = {
+    inject(carrier, context) {
+      carrier[TRACEPARENT_HEADER] = serialize(context);
+    },
+    extract(carrier) {
+      const traceparent = carrier[TRACEPARENT_HEADER];
+      if (!traceparent) {
+        return;
+      }
+      return parse(traceparent);
+    },
+    getTraceparentHeader() {
+      return TRACEPARENT_HEADER;
+    }
+  };
+});
+
+// packages/core/src/env/log-trace/span-storage.ts
+var exports_span_storage = {};
+__export(exports_span_storage, {
+  SQLiteSpanStorage: () => SQLiteSpanStorage
+});
+
+class SQLiteSpanStorage {
+  db = null;
+  dbPath;
+  initialized = false;
+  constructor(dbPath) {
+    if (!dbPath) {
+      throw new Error("SQLiteSpanStorage requires a valid dbPath parameter");
+    }
+    if (dbPath === ":memory:") {
+      throw new Error("SQLiteSpanStorage does not support :memory: mode. Use a file path instead.");
+    }
+    this.dbPath = dbPath;
+  }
+  async initialize() {
+    if (this.initialized)
+      return;
+    const { Database } = __require("bun:sqlite");
+    const fs = __require("fs");
+    const path = __require("path");
+    const dir = path.dirname(this.dbPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    this.db = new Database(this.dbPath);
+    this.db.run("PRAGMA journal_mode=WAL");
+    this.db.run("PRAGMA busy_timeout=5000");
+    this.db.run("PRAGMA synchronous=NORMAL");
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS span (
+        span_id TEXT PRIMARY KEY,
+        trace_id TEXT NOT NULL,
+        parent_span_id TEXT,
+        name TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        status TEXT NOT NULL,
+        start_time INTEGER NOT NULL,
+        end_time INTEGER,
+        attributes TEXT,
+        result TEXT,
+        error TEXT,
+        time_created INTEGER NOT NULL
+      )
+    `);
+    this.db.run("CREATE INDEX IF NOT EXISTS idx_span_trace ON span(trace_id)");
+    this.db.run("CREATE INDEX IF NOT EXISTS idx_span_parent ON span(parent_span_id)");
+    this.initialized = true;
+  }
+  save(span) {
+    if (!this.db)
+      return;
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO span 
+      (span_id, trace_id, parent_span_id, name, kind, status, start_time, end_time, attributes, result, error, time_created)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const resultValue = span.result !== undefined && span.result !== null ? typeof span.result === "string" ? span.result : JSON.stringify(span.result) : null;
+    stmt.run(span.spanId, span.traceId, span.parentSpanId || null, span.name, span.kind, span.status, span.startTime, span.endTime || null, JSON.stringify(span.attributes), resultValue, span.error || null, Date.now());
+  }
+  saveBatch(spans) {
+    for (const span of spans) {
+      this.save(span);
+    }
+  }
+  findByTraceId(traceId) {
+    if (!this.db)
+      return [];
+    const rows = this.db.prepare("SELECT * FROM span WHERE trace_id = ?").all(traceId);
+    return this.buildTree(rows.map(this.rowToSpan));
+  }
+  findBySpanId(spanId) {
+    if (!this.db)
+      return;
+    const row = this.db.prepare("SELECT * FROM span WHERE span_id = ?").get(spanId);
+    return row ? this.rowToSpan(row) : undefined;
+  }
+  listTraces(limit = 10) {
+    if (!this.db)
+      return [];
+    const rows = this.db.prepare(`
+      SELECT trace_id, 
+             MIN(start_time) as start_time,
+             MAX(end_time) as end_time,
+             COUNT(*) as span_count
+      FROM span 
+      GROUP BY trace_id 
+      ORDER BY start_time DESC 
+      LIMIT ?
+    `).all(limit);
+    return rows.map((row) => ({
+      traceId: row.trace_id,
+      rootSpanName: "unknown",
+      startTime: row.start_time,
+      endTime: row.end_time,
+      duration: row.end_time - row.start_time,
+      spanCount: row.span_count,
+      status: "ok"
+    }));
+  }
+  deleteByTraceId(traceId) {
+    if (this.db) {
+      this.db.prepare("DELETE FROM span WHERE trace_id = ?").run(traceId);
+    }
+  }
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  rowToSpan(row) {
+    return {
+      traceId: row.trace_id,
+      spanId: row.span_id,
+      parentSpanId: row.parent_span_id,
+      name: row.name,
+      kind: row.kind,
+      status: row.status,
+      startTime: row.start_time,
+      endTime: row.end_time,
+      attributes: row.attributes ? JSON.parse(row.attributes) : {},
+      result: row.result || undefined,
+      error: row.error || undefined
+    };
+  }
+  buildTree(spans) {
+    const spanMap = new Map;
+    const roots = [];
+    for (const span of spans) {
+      spanMap.set(span.spanId, { ...span, children: [] });
+    }
+    for (const span of spanMap.values()) {
+      if (span.parentSpanId) {
+        const parent = spanMap.get(span.parentSpanId);
+        if (parent) {
+          parent.children.push(span);
+        } else {
+          roots.push(span);
+        }
+      } else {
+        roots.push(span);
+      }
+    }
+    return roots;
+  }
+}
+
+// packages/core/src/env/log-trace/types.ts
+var SpanKind, SpanStatus;
+var init_types = __esm(() => {
+  ((SpanKind2) => {
+    SpanKind2["CLIENT"] = "client";
+    SpanKind2["SERVER"] = "server";
+    SpanKind2["INTERNAL"] = "internal";
+  })(SpanKind ||= {});
+  ((SpanStatus2) => {
+    SpanStatus2["OK"] = "ok";
+    SpanStatus2["ERROR"] = "error";
+  })(SpanStatus ||= {});
+});
+
+// packages/core/src/env/log-trace/opentelemetry/tracer-provider.ts
+var exports_tracer_provider = {};
+__export(exports_tracer_provider, {
+  resetTracerProvider: () => resetTracerProvider,
+  getTracerProvider: () => getTracerProvider,
+  OTelTracerProvider: () => OTelTracerProvider
+});
+
+class OTelSpanImpl {
+  name;
+  kind;
+  spanContext;
+  attributes = {};
+  startTime;
+  endTime;
+  error;
+  storage;
+  parentSpanContext;
+  onEnd;
+  constructor(name, spanContext, storage, parentSpanContext, onEnd) {
+    this.name = name;
+    this.kind = "internal";
+    this.spanContext = spanContext;
+    this.parentSpanContext = parentSpanContext;
+    this.startTime = Date.now();
+    this.storage = storage;
+    this.onEnd = onEnd;
+  }
+  setAttribute(key, value) {
+    this.attributes[key] = value;
+  }
+  addEvent(name, attributes) {
+    const events = this.attributes._events || [];
+    events.push({ name, attributes });
+    this.attributes._events = events;
+  }
+  end(result, error) {
+    this.endTime = Date.now();
+    if (error) {
+      this.error = error.message;
+    }
+    this.storage.save({
+      traceId: this.spanContext.traceId,
+      spanId: this.spanContext.spanId,
+      parentSpanId: this.spanContext.parentSpanId,
+      name: this.name,
+      kind: this.kind,
+      status: error ? "error" /* ERROR */ : "ok" /* OK */,
+      startTime: this.startTime,
+      endTime: this.endTime,
+      attributes: this.attributes,
+      result,
+      error: this.error
+    });
+    this.onEnd?.();
+  }
+}
+
+class OTelTracerImpl {
+  name;
+  version;
+  storage;
+  currentContext;
+  activeSpans = new Map;
+  onSpanEndCallback;
+  provider;
+  constructor(name, version, storage, provider) {
+    this.name = name;
+    this.version = version;
+    this.storage = storage;
+    this.provider = provider;
+  }
+  setOnSpanEndCallback(callback) {
+    this.onSpanEndCallback = callback;
+  }
+  getActiveSpanCount() {
+    return this.activeSpans.size;
+  }
+  startSpan(name, options) {
+    const parentFromOptions = options?.parent;
+    const hasExplicitParent = options && "parent" in options;
+    const globalContext = this.provider.getGlobalContext();
+    let effectiveParentContext;
+    if (hasExplicitParent) {
+      effectiveParentContext = parentFromOptions;
+    } else if (this.currentContext) {
+      effectiveParentContext = this.currentContext;
+    } else if (globalContext) {
+      effectiveParentContext = globalContext;
+    }
+    const traceId = effectiveParentContext?.traceId || this.generateTraceId();
+    const spanId = this.generateSpanId();
+    let parentSpanId;
+    if (hasExplicitParent && parentFromOptions) {
+      parentSpanId = parentFromOptions.parentSpanId || parentFromOptions.spanId;
+    } else if (this.currentContext) {
+      parentSpanId = this.currentContext.spanId;
+    } else if (globalContext) {
+      parentSpanId = globalContext.spanId;
+    }
+    const spanContext = {
+      traceId,
+      spanId,
+      parentSpanId
+    };
+    this.currentContext = {
+      traceId,
+      spanId,
+      parentSpanId
+    };
+    const span = new OTelSpanImpl(name, spanContext, this.storage, effectiveParentContext, () => this.handleSpanEnd(spanContext.spanId, effectiveParentContext?.spanId));
+    if (options?.attributes) {
+      for (const [key, value] of Object.entries(options.attributes)) {
+        span.setAttribute(key, value);
+      }
+    }
+    this.activeSpans.set(spanId, span);
+    return span;
+  }
+  injectToEnv(env) {
+    if (this.currentContext) {
+      propagation.inject(env, this.currentContext);
+    }
+  }
+  getCurrentContext() {
+    return this.currentContext;
+  }
+  setCurrentContext(context) {
+    this.currentContext = context;
+  }
+  endSpan(span) {
+    const spanContext = span.spanContext;
+    this.activeSpans.delete(spanContext.spanId);
+    const currentTraceId = this.currentContext?.traceId;
+    if (spanContext.parentSpanId) {
+      const parentSpan = this.activeSpans.get(spanContext.parentSpanId);
+      if (parentSpan) {
+        const parentContext = {
+          traceId: spanContext.traceId,
+          spanId: parentSpan.spanContext.spanId,
+          parentSpanId: parentSpan.spanContext.parentSpanId
+        };
+        this.currentContext = parentContext;
+        return parentContext;
+      }
+      if (currentTraceId) {
+        const parentContext = {
+          traceId: currentTraceId,
+          spanId: spanContext.parentSpanId,
+          parentSpanId: undefined
+        };
+        this.currentContext = parentContext;
+        return parentContext;
+      }
+    }
+    this.currentContext = undefined;
+    return;
+  }
+  generateTraceId() {
+    const timestamp = Date.now().toString(16).padStart(12, "0");
+    const random = Array.from({ length: 5 }, () => Math.floor(Math.random() * 4294967295).toString(16).padStart(8, "0")).join("");
+    return (timestamp + random).slice(0, 32).padStart(32, "0");
+  }
+  generateSpanId() {
+    return Math.floor(Math.random() * 18446744073709552000).toString(16).padStart(16, "0");
+  }
+  handleSpanEnd(spanId, parentSpanId) {
+    this.activeSpans.delete(spanId);
+    const currentTraceId = this.currentContext?.traceId;
+    if (parentSpanId) {
+      const parentSpan = this.activeSpans.get(parentSpanId);
+      if (parentSpan) {
+        this.currentContext = {
+          traceId: parentSpan.spanContext.traceId,
+          spanId: parentSpan.spanContext.spanId,
+          parentSpanId: parentSpan.spanContext.parentSpanId
+        };
+        return;
+      }
+      if (currentTraceId) {
+        this.currentContext = {
+          traceId: currentTraceId,
+          spanId: parentSpanId,
+          parentSpanId: undefined
+        };
+        return;
+      }
+    }
+    this.currentContext = undefined;
+  }
+}
+
+class OTelTracerProvider {
+  tracers = new Map;
+  storage;
+  initialized = false;
+  globalContext;
+  constructor(storage, dbPath) {
+    this.storage = storage || new SQLiteSpanStorage(dbPath || getDefaultDbPath());
+  }
+  async initialize() {
+    if (this.initialized)
+      return;
+    await this.storage.initialize();
+    this.initialized = true;
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  getGlobalContext() {
+    return this.globalContext;
+  }
+  setGlobalContext(context) {
+    this.globalContext = context;
+  }
+  getTracer(name, version) {
+    const key = `${name}@${version || "0.0.0"}`;
+    let tracer = this.tracers.get(key);
+    if (!tracer) {
+      tracer = new OTelTracerImpl(name, version, this.storage, this);
+      this.tracers.set(key, tracer);
+      if (this.initialized) {
+        this.restoreFromEnv(tracer);
+      }
+    }
+    return tracer;
+  }
+  restoreFromEnv(tracer) {
+    const extracted = propagation.extract(process.env);
+    if (extracted) {
+      tracer.setCurrentContext({
+        traceId: extracted.traceId,
+        spanId: extracted.spanId,
+        parentSpanId: undefined
+      });
+    }
+  }
+  shutdown() {
+    for (const tracer of this.tracers.values()) {}
+    this.tracers.clear();
+    this.storage.close();
+    this.initialized = false;
+    this.globalContext = undefined;
+    delete process.env["TRACEPARENT"];
+    delete process.env["TRACE_ID"];
+    delete process.env["LOG_TRACE_REQUEST_ID"];
+  }
+  getStorage() {
+    return this.storage;
+  }
+}
+function getTracerProvider() {
+  if (!providerInstance) {
+    providerInstance = new OTelTracerProvider;
+  }
+  return providerInstance;
+}
+function resetTracerProvider() {
+  if (providerInstance) {
+    providerInstance.shutdown();
+    providerInstance = null;
+  }
+}
+function getDefaultDbPath() {
+  const os = __require("os");
+  const path = __require("path");
+  const home = os.homedir();
+  const dataHome = process.env.XDG_DATA_HOME || path.join(home, ".local", "share");
+  return path.join(dataHome, "roy-agent", "traces.db");
+}
+var providerInstance = null;
+var init_tracer_provider = __esm(() => {
+  init_propagation();
+  init_types();
+});
+
+// packages/core/src/env/tool/built-in/bash.ts
+import { z } from "zod";
+import { exec } from "child_process";
+import { promisify } from "util";
+function getCurrentSpanContext() {
+  try {
+    const { getTracerProvider: getTracerProvider2 } = (init_tracer_provider(), __toCommonJS(exports_tracer_provider));
+    const provider = getTracerProvider2();
+    if (!provider.isInitialized()) {
+      throw new Error("Provider not initialized");
+    }
+    const tracer = provider.getTracer("roy-tracer");
+    const ctx = tracer.getCurrentContext();
+    if (ctx && ctx.traceId && ctx.spanId) {
+      return ctx;
+    }
+  } catch {}
+  return;
+}
+function getCurrentTraceId() {
+  const ctx = getCurrentSpanContext();
+  if (ctx) {
+    return ctx.traceId;
+  }
+  return process.env.TRACE_ID;
+}
+var execAsync, bashTool;
+var init_bash = __esm(() => {
+  init_propagation();
+  execAsync = promisify(exec);
+  bashTool = {
+    name: "bash",
+    description: "Execute shell commands in the terminal. Use this to run system commands, scripts, or interact with the file system.",
+    parameters: z.object({
+      command: z.string().describe("The shell command to execute"),
+      workdir: z.string().optional().describe("Working directory for the command"),
+      timeout: z.number().int().positive().optional().describe("Timeout in milliseconds"),
+      env: z.record(z.string()).optional().describe("Additional environment variables")
+    }),
+    sandbox: {
+      enabled: true,
+      config: {
+        filesystem: {
+          denyRead: ["/etc/shadow", "/etc/sudoers", "/etc/sudoers.d/*"],
+          denyWrite: ["/etc", "/usr/bin", "/usr/sbin", "/bin", "/sbin"]
+        }
+      }
+    },
+    permission: {
+      requireConfirmation: true,
+      level: "dangerous"
+    },
+    metadata: {
+      category: "system",
+      tags: ["shell", "command", "terminal", "exec"],
+      version: "1.2.0"
+    },
+    execute: async (args, ctx) => {
+      const startTime = Date.now();
+      const { command, workdir, timeout = 60000, env } = args;
+      const currentSpanCtx = getCurrentSpanContext();
+      const traceId = currentSpanCtx?.traceId || getCurrentTraceId();
+      const options = {
+        timeout
+      };
+      if (workdir || ctx.workdir) {
+        options.cwd = workdir || ctx.workdir;
+      }
+      const childEnv = {};
+      for (const [key, value] of Object.entries(process.env)) {
+        if (value !== undefined) {
+          childEnv[key] = value;
+        }
+      }
+      if (currentSpanCtx) {
+        const carrier = {};
+        propagation.inject(carrier, currentSpanCtx);
+        if (carrier["TRACEPARENT"]) {
+          childEnv["TRACEPARENT"] = carrier["TRACEPARENT"];
+        }
+        childEnv["TRACE_ID"] = currentSpanCtx.traceId;
+        childEnv["PARENT_SPAN_ID"] = currentSpanCtx.spanId;
+      } else if (traceId) {
+        const spanId2 = Math.floor(Math.random() * 18446744073709552000).toString(16).padStart(16, "0");
+        childEnv["TRACEPARENT"] = `00-${traceId}-${spanId2}-01`;
+        childEnv["TRACE_ID"] = traceId;
+      }
+      if (env) {
+        Object.assign(childEnv, env);
+      }
+      options.env = childEnv;
+      let otelSpan = undefined;
+      try {
+        const { getTracerProvider: getTracerProvider2 } = (init_tracer_provider(), __toCommonJS(exports_tracer_provider));
+        const provider = getTracerProvider2();
+        const tracer = provider.getTracer("roy-tracer");
+        otelSpan = tracer.startSpan(`bash: ${command.slice(0, 50)}${command.length > 50 ? "..." : ""}`, {
+          attributes: {
+            "bash.command": command.slice(0, 200),
+            "bash.workdir": workdir || ctx.workdir || "",
+            "bash.timeout": timeout
+          }
+        });
+      } catch {}
+      const spanId = otelSpan?.spanContext?.spanId;
+      try {
+        const { stdout, stderr } = await execAsync(command, options);
+        if (otelSpan) {
+          otelSpan.end({ stdout, stderr });
+        }
+        return {
+          success: true,
+          output: stdout || "(no output)",
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            stdout,
+            stderr,
+            exit_code: 0,
+            trace_id: traceId,
+            parent_span_id: currentSpanCtx?.spanId,
+            span_id: spanId
+          }
+        };
+      } catch (error) {
+        const exitCode = error.code || 1;
+        const stdout = error.stdout || "";
+        const stderr = error.stderr || error.message;
+        const execError = new Error(stderr);
+        execError.name = "BashExecutionError";
+        if (otelSpan) {
+          otelSpan.end(undefined, execError);
+        }
+        return {
+          success: exitCode === 0,
+          output: stdout || "(no output)",
+          error: stderr,
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            stdout,
+            stderr,
+            exit_code: exitCode,
+            trace_id: traceId,
+            parent_span_id: currentSpanCtx?.spanId,
+            span_id: spanId
+          }
+        };
+      }
+    }
+  };
+});
+
+// packages/core/src/env/tool/built-in/echo.ts
+var echoTool;
+var init_echo = __esm(() => {
+  echoTool = {
+    name: "echo",
+    description: "Echo a message to the console. Useful for logging in workflows.",
+    parameters: {
+      name: "message",
+      schema: {
+        type: "string",
+        description: "The message to echo"
+      }
+    },
+    execute: async (args, _ctx) => {
+      const message = args?.message || "(no message)";
+      return {
+        success: true,
+        output: message,
+        metadata: {
+          execution_time_ms: 0
+        }
+      };
+    }
+  };
+});
+
+// packages/core/src/env/tool/built-in/glob.ts
+import { z as z2 } from "zod";
+import { glob as globAsync } from "glob";
+var globTool;
+var init_glob = __esm(() => {
+  globTool = {
+    name: "glob",
+    description: "Search for files matching a glob pattern. Use this to find files by name patterns like **/*.ts or **/*.md.",
+    parameters: z2.object({
+      pattern: z2.string().describe("Glob pattern to match (e.g., **/*.ts, **/*.md)"),
+      cwd: z2.string().optional().describe("Working directory to search in"),
+      maxResults: z2.number().int().positive().optional().describe("Maximum number of results to return"),
+      ignore: z2.array(z2.string()).optional().describe("Patterns to ignore")
+    }),
+    sandbox: {
+      enabled: true
+    },
+    metadata: {
+      category: "file",
+      tags: ["search", "file", "glob", "pattern"],
+      version: "1.0.0"
+    },
+    execute: async (args, ctx) => {
+      const startTime = Date.now();
+      const { pattern, cwd, maxResults = 100, ignore } = args;
+      const searchDir = cwd || ctx.workdir || process.cwd();
+      try {
+        const files = await globAsync(pattern, {
+          cwd: searchDir,
+          ignore: ignore || ["**/node_modules/**", "**/.git/**"],
+          maxDepth: 20
+        });
+        const limitedFiles = files.slice(0, maxResults);
+        const output = limitedFiles.join(`
+`);
+        return {
+          success: true,
+          output,
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            output_size: output.length,
+            total_matches: files.length,
+            returned_matches: limitedFiles.length
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: {
+            execution_time_ms: Date.now() - startTime
+          }
+        };
+      }
+    }
+  };
+});
+
+// packages/core/src/env/tool/built-in/read-file.ts
+import { z as z3 } from "zod";
+import { readFile } from "fs/promises";
+var readFileTool;
+var init_read_file = __esm(() => {
+  readFileTool = {
+    name: "read_file",
+    description: "Read the contents of a file. Use this to read source code, configuration files, or any text files.",
+    parameters: z3.object({
+      path: z3.string().describe("The file path to read"),
+      offset: z3.number().int().nonnegative().optional().describe("Line offset to start reading from"),
+      limit: z3.number().int().positive().optional().describe("Number of lines to read"),
+      encoding: z3.enum(["utf-8", "base64"]).default("utf-8").optional().describe("File encoding")
+    }),
+    sandbox: {
+      enabled: true,
+      config: {
+        filesystem: {
+          denyRead: ["/etc/shadow", "/etc/sudoers", "/root/.ssh"]
+        }
+      }
+    },
+    permission: {
+      level: "safe"
+    },
+    metadata: {
+      category: "file",
+      tags: ["read", "file", "io"],
+      version: "1.0.0"
+    },
+    execute: async (args, ctx) => {
+      const startTime = Date.now();
+      const { path: filePath, offset, limit, encoding = "utf-8" } = args;
+      try {
+        const content = await readFile(filePath, encoding);
+        let output;
+        const contentBuffer = content;
+        const contentStr = typeof contentBuffer === "string" ? contentBuffer : contentBuffer.toString(encoding);
+        if (offset !== undefined || limit !== undefined) {
+          const lines = contentStr.split(`
+`);
+          const startLine = offset || 0;
+          const endLine = limit ? startLine + limit : lines.length;
+          output = lines.slice(startLine, endLine).join(`
+`);
+        } else {
+          output = contentStr;
+        }
+        return {
+          success: true,
+          output,
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            output_size: output.length,
+            file_path: filePath
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: {
+            execution_time_ms: Date.now() - startTime
+          }
+        };
+      }
+    }
+  };
+});
+
+// packages/core/src/env/tool/built-in/write-file.ts
+import { z as z4 } from "zod";
+import { writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+var writeFileTool;
+var init_write_file = __esm(() => {
+  writeFileTool = {
+    name: "write_file",
+    description: "Write content to a file. Use this to create new files or overwrite existing ones.",
+    parameters: z4.object({
+      path: z4.string().describe("The file path to write to"),
+      content: z4.string().describe("The content to write"),
+      createDirs: z4.boolean().default(false).optional().describe("Create parent directories if they don't exist"),
+      append: z4.boolean().default(false).optional().describe("Append to file instead of overwrite")
+    }),
+    sandbox: {
+      enabled: true,
+      config: {
+        filesystem: {
+          denyWrite: ["/etc", "/usr", "/bin", "/sbin", "/boot", "/sys"]
+        }
+      }
+    },
+    permission: {
+      requireConfirmation: true,
+      level: "dangerous"
+    },
+    metadata: {
+      category: "file",
+      tags: ["write", "file", "io", "create"],
+      version: "1.0.0"
+    },
+    execute: async (args, ctx) => {
+      const startTime = Date.now();
+      const { path: filePath, content, createDirs = false, append = false } = args;
+      try {
+        if (createDirs) {
+          await mkdir(dirname(filePath), { recursive: true });
+        }
+        const flags = append ? "a" : "w";
+        await writeFile(filePath, content, { flag: flags });
+        return {
+          success: true,
+          output: append ? `Content appended to: ${filePath}` : `File written: ${filePath}`,
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            output_size: content.length,
+            file_path: filePath
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: {
+            execution_time_ms: Date.now() - startTime
+          }
+        };
+      }
+    }
+  };
+});
+
+// packages/core/src/env/tool/built-in/edit-file.ts
+import { z as z5 } from "zod";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var editFileTool;
+var init_edit_file = __esm(() => {
+  editFileTool = {
+    name: "edit_file",
+    description: "Edit a file by replacing specific text. Use this to make targeted changes to files by specifying what to find and what to replace.",
+    parameters: z5.object({
+      path: z5.string().describe("The file path to edit"),
+      oldString: z5.string().describe("The text to find and replace"),
+      newString: z5.string().describe("The replacement text"),
+      replaceAll: z5.boolean().default(false).optional().describe("Replace all occurrences instead of just the first")
+    }),
+    sandbox: {
+      enabled: true,
+      config: {
+        filesystem: {
+          denyWrite: ["/etc", "/usr/bin", "/usr/sbin", "/bin", "/sbin"]
+        }
+      }
+    },
+    permission: {
+      requireConfirmation: true,
+      level: "dangerous"
+    },
+    metadata: {
+      category: "file",
+      tags: ["edit", "file", "replace", "modify"],
+      version: "1.0.0"
+    },
+    execute: async (args, ctx) => {
+      const startTime = Date.now();
+      const { path: filePath, oldString, newString, replaceAll = false } = args;
+      try {
+        const content = await readFile2(filePath, "utf-8");
+        const searchPattern = replaceAll ? new RegExp(escapeRegExp(oldString), "g") : new RegExp(escapeRegExp(oldString));
+        if (!searchPattern.test(content)) {
+          return {
+            success: false,
+            output: "",
+            error: `Could not find "${oldString}" in file ${filePath}`,
+            metadata: {
+              execution_time_ms: Date.now() - startTime
+            }
+          };
+        }
+        const newContent = replaceAll ? content.replace(new RegExp(escapeRegExp(oldString), "g"), newString) : content.replace(oldString, newString);
+        await writeFile2(filePath, newContent, "utf-8");
+        return {
+          success: true,
+          output: replaceAll ? `Replaced all occurrences in: ${filePath}` : `Replaced text in: ${filePath}`,
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            file_path: filePath
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: {
+            execution_time_ms: Date.now() - startTime
+          }
+        };
+      }
+    }
+  };
+});
+
+// packages/core/src/env/tool/built-in/grep.ts
+import { z as z6 } from "zod";
+import { readFile as readFile3 } from "fs/promises";
+import { glob as globAsync2 } from "glob";
+var grepTool;
+var init_grep = __esm(() => {
+  grepTool = {
+    name: "grep",
+    description: "Search for text patterns in files. Use this to find specific strings, code patterns, or content across multiple files.",
+    parameters: z6.object({
+      pattern: z6.string().describe("The pattern to search for"),
+      path: z6.string().optional().describe("File or directory path to search in"),
+      include: z6.string().optional().describe("Glob pattern for files to include (e.g., *.ts, *.js)"),
+      caseSensitive: z6.boolean().default(true).optional().describe("Whether the search should be case sensitive"),
+      maxResults: z6.number().int().positive().default(50).optional().describe("Maximum number of results"),
+      showLineNumbers: z6.boolean().default(true).optional().describe("Show line numbers in results")
+    }),
+    sandbox: {
+      enabled: true
+    },
+    metadata: {
+      category: "file",
+      tags: ["search", "grep", "find", "pattern"],
+      version: "1.0.0"
+    },
+    execute: async (args, ctx) => {
+      const startTime = Date.now();
+      const {
+        pattern,
+        path: searchPath,
+        include,
+        caseSensitive = true,
+        maxResults = 50,
+        showLineNumbers = true
+      } = args;
+      const basePath = searchPath || ctx.workdir || process.cwd();
+      try {
+        let files = [];
+        if (include) {
+          files = await globAsync2(include, {
+            cwd: basePath,
+            ignore: ["**/node_modules/**", "**/.git/**"],
+            maxDepth: 10
+          });
+        } else {
+          files = await globAsync2("**/*", {
+            cwd: basePath,
+            ignore: ["**/node_modules/**", "**/.git/**"],
+            maxDepth: 10
+          });
+        }
+        const results = [];
+        const regexFlags = caseSensitive ? "" : "i";
+        const regex = new RegExp(pattern, regexFlags);
+        for (const file of files) {
+          if (results.length >= maxResults)
+            break;
+          try {
+            const content = await readFile3(`${basePath}/${file}`, "utf-8");
+            const lines = content.split(`
+`);
+            for (let i = 0;i < lines.length; i++) {
+              if (regex.test(lines[i])) {
+                const lineNum = showLineNumbers ? `${i + 1}:` : "";
+                results.push(`${file}:${lineNum}${lines[i]}`);
+                if (results.length >= maxResults)
+                  break;
+              }
+            }
+          } catch {}
+        }
+        const output = results.join(`
+`) || "(no matches found)";
+        return {
+          success: true,
+          output,
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            output_size: output.length,
+            matches_count: results.length,
+            files_searched: files.length
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: {
+            execution_time_ms: Date.now() - startTime
+          }
+        };
+      }
+    }
+  };
+});
+
+// packages/core/src/env/tool/built-in/index.ts
+var exports_built_in = {};
+__export(exports_built_in, {
+  writeFileTool: () => writeFileTool,
+  readFileTool: () => readFileTool,
+  grepTool: () => grepTool,
+  globTool: () => globTool,
+  getBuiltInTool: () => getBuiltInTool,
+  getAllBuiltInTools: () => getAllBuiltInTools,
+  editFileTool: () => editFileTool,
+  echoTool: () => echoTool,
+  bashTool: () => bashTool
+});
+function getAllBuiltInTools() {
+  return [
+    bashTool,
+    echoTool,
+    globTool,
+    readFileTool,
+    writeFileTool,
+    editFileTool,
+    grepTool
+  ];
+}
+function getBuiltInTool(name) {
+  const tools = getAllBuiltInTools();
+  return tools.find((t) => t.name === name);
+}
+var init_built_in = __esm(() => {
+  init_bash();
+  init_echo();
+  init_glob();
+  init_read_file();
+  init_write_file();
+  init_edit_file();
+  init_grep();
+});
+init_built_in();
+
+export {
+  writeFileTool,
+  readFileTool,
+  grepTool,
+  globTool,
+  getBuiltInTool,
+  getAllBuiltInTools,
+  editFileTool,
+  echoTool,
+  bashTool
+};