@elizaos/plugin-code 2.0.0-alpha.1

package/dist/index.js

@@ -0,0 +1,1064 @@
+// generated/specs/specs.ts
+var coreActionsSpec = {
+  version: "1.0.0",
+  actions: [
+    {
+      name: "CHANGE_DIRECTORY",
+      description: "Change the working directory (restricted to allowed directory).",
+      similes: ["CD", "CWD"],
+      parameters: []
+    },
+    {
+      name: "EDIT_FILE",
+      description: "Replace a substring in a file (single replacement).",
+      similes: ["REPLACE_IN_FILE", "PATCH_FILE", "MODIFY_FILE"],
+      parameters: []
+    },
+    {
+      name: "EXECUTE_SHELL",
+      description: "Execute a shell command in the current working directory (restricted).",
+      similes: ["SHELL", "RUN_COMMAND", "EXEC", "TERMINAL"],
+      parameters: []
+    },
+    {
+      name: "GIT",
+      description: "Run a git command (restricted).",
+      similes: ["GIT_COMMAND", "GIT_RUN"],
+      parameters: []
+    },
+    {
+      name: "LIST_FILES",
+      description: "List files in a directory.",
+      similes: ["LS", "LIST_DIR", "LIST_DIRECTORY", "DIR"],
+      parameters: []
+    },
+    {
+      name: "READ_FILE",
+      description: "Read and return a file",
+      similes: ["VIEW_FILE", "OPEN_FILE", "CAT_FILE", "SHOW_FILE", "GET_FILE"],
+      parameters: []
+    },
+    {
+      name: "SEARCH_FILES",
+      description: "Search for text across files under a directory.",
+      similes: ["GREP", "RG", "FIND_IN_FILES", "SEARCH"],
+      parameters: []
+    },
+    {
+      name: "WRITE_FILE",
+      description: "Create or overwrite a file with given content.",
+      similes: ["CREATE_FILE", "SAVE_FILE", "OUTPUT_FILE"],
+      parameters: []
+    }
+  ]
+};
+var allActionsSpec = {
+  version: "1.0.0",
+  actions: [
+    {
+      name: "CHANGE_DIRECTORY",
+      description: "Change the working directory (restricted to allowed directory).",
+      similes: ["CD", "CWD"],
+      parameters: []
+    },
+    {
+      name: "EDIT_FILE",
+      description: "Replace a substring in a file (single replacement).",
+      similes: ["REPLACE_IN_FILE", "PATCH_FILE", "MODIFY_FILE"],
+      parameters: []
+    },
+    {
+      name: "EXECUTE_SHELL",
+      description: "Execute a shell command in the current working directory (restricted).",
+      similes: ["SHELL", "RUN_COMMAND", "EXEC", "TERMINAL"],
+      parameters: []
+    },
+    {
+      name: "GIT",
+      description: "Run a git command (restricted).",
+      similes: ["GIT_COMMAND", "GIT_RUN"],
+      parameters: []
+    },
+    {
+      name: "LIST_FILES",
+      description: "List files in a directory.",
+      similes: ["LS", "LIST_DIR", "LIST_DIRECTORY", "DIR"],
+      parameters: []
+    },
+    {
+      name: "READ_FILE",
+      description: "Read and return a file",
+      similes: ["VIEW_FILE", "OPEN_FILE", "CAT_FILE", "SHOW_FILE", "GET_FILE"],
+      parameters: []
+    },
+    {
+      name: "SEARCH_FILES",
+      description: "Search for text across files under a directory.",
+      similes: ["GREP", "RG", "FIND_IN_FILES", "SEARCH"],
+      parameters: []
+    },
+    {
+      name: "WRITE_FILE",
+      description: "Create or overwrite a file with given content.",
+      similes: ["CREATE_FILE", "SAVE_FILE", "OUTPUT_FILE"],
+      parameters: []
+    }
+  ]
+};
+var coreProvidersSpec = {
+  version: "1.0.0",
+  providers: [
+    {
+      name: "CODER_STATUS",
+      description: "Provides current working directory, allowed directory, and recent shell/file operations",
+      dynamic: true
+    }
+  ]
+};
+var allProvidersSpec = {
+  version: "1.0.0",
+  providers: [
+    {
+      name: "CODER_STATUS",
+      description: "Provides current working directory, allowed directory, and recent shell/file operations",
+      dynamic: true
+    }
+  ]
+};
+var coreEvaluatorsSpec = {
+  version: "1.0.0",
+  evaluators: []
+};
+var allEvaluatorsSpec = {
+  version: "1.0.0",
+  evaluators: []
+};
+var coreActionDocs = coreActionsSpec.actions;
+var allActionDocs = allActionsSpec.actions;
+var coreProviderDocs = coreProvidersSpec.providers;
+var allProviderDocs = allProvidersSpec.providers;
+var coreEvaluatorDocs = coreEvaluatorsSpec.evaluators;
+var allEvaluatorDocs = allEvaluatorsSpec.evaluators;
+
+// generated/specs/spec-helpers.ts
+var coreActionMap = new Map(coreActionDocs.map((doc) => [doc.name, doc]));
+var allActionMap = new Map(allActionDocs.map((doc) => [doc.name, doc]));
+var coreProviderMap = new Map(coreProviderDocs.map((doc) => [doc.name, doc]));
+var allProviderMap = new Map(allProviderDocs.map((doc) => [doc.name, doc]));
+var coreEvaluatorMap = new Map(coreEvaluatorDocs.map((doc) => [doc.name, doc]));
+var allEvaluatorMap = new Map(allEvaluatorDocs.map((doc) => [doc.name, doc]));
+function getActionSpec(name) {
+  return coreActionMap.get(name) ?? allActionMap.get(name);
+}
+function requireActionSpec(name) {
+  const spec = getActionSpec(name);
+  if (!spec) {
+    throw new Error(`Action spec not found: ${name}`);
+  }
+  return spec;
+}
+function getProviderSpec(name) {
+  return coreProviderMap.get(name) ?? allProviderMap.get(name);
+}
+function requireProviderSpec(name) {
+  const spec = getProviderSpec(name);
+  if (!spec) {
+    throw new Error(`Provider spec not found: ${name}`);
+  }
+  return spec;
+}
+
+// actions/changeDirectory.ts
+function getTarget(options) {
+  const opt = options;
+  return opt?.path?.trim() ?? "";
+}
+var spec = requireActionSpec("CHANGE_DIRECTORY");
+var changeDirectory = {
+  name: spec.name,
+  similes: spec.similes ? [...spec.similes] : [],
+  description: spec.description,
+  validate: async (runtime) => runtime.getService("coder") !== null,
+  handler: async (runtime, message, _state, options, callback) => {
+    const svc = runtime.getService("coder");
+    if (!svc) {
+      const msg = "Coder service is not available.";
+      if (callback)
+        await callback({ content: { text: msg } });
+      return { success: false, text: msg };
+    }
+    const target = getTarget(options);
+    if (!target) {
+      const msg = "Missing path.";
+      if (callback)
+        await callback({ content: { text: msg } });
+      return { success: false, text: msg };
+    }
+    const conv = message.roomId ?? message.agentId ?? runtime.agentId;
+    const result = await svc.changeDirectory(conv, target);
+    const out = result.success ? result.stdout : result.stderr;
+    if (callback)
+      await callback({ content: { text: out } });
+    return { success: result.success, text: out };
+  }
+};
+// actions/editFile.ts
+function getInputs(options, message) {
+  const opt = options;
+  const filepath = opt?.filepath?.trim() ?? "";
+  const oldStr = opt?.old_str ?? "";
+  const newStr = opt?.new_str ?? "";
+  if (filepath)
+    return { filepath, oldStr, newStr };
+  const text = message.content.text ?? "";
+  const m = text.match(/["'`]([^"'`]+)["'`]/);
+  const inferred = m?.[1]?.trim() ?? "";
+  return { filepath: inferred, oldStr, newStr };
+}
+var spec2 = requireActionSpec("EDIT_FILE");
+var editFile = {
+  name: spec2.name,
+  similes: spec2.similes ? [...spec2.similes] : [],
+  description: spec2.description,
+  validate: async (runtime) => runtime.getService("coder") !== null,
+  handler: async (runtime, message, _state, options, callback) => {
+    const svc = runtime.getService("coder");
+    if (!svc) {
+      const msg2 = "Coder service is not available.";
+      if (callback)
+        await callback({ content: { text: msg2 } });
+      return { success: false, text: msg2 };
+    }
+    const { filepath, oldStr, newStr } = getInputs(options, message);
+    if (!filepath || oldStr.length === 0) {
+      const msg2 = "Missing filepath or old_str.";
+      if (callback)
+        await callback({ content: { text: msg2 } });
+      return { success: false, text: msg2 };
+    }
+    const conv = message.roomId ?? message.agentId ?? runtime.agentId;
+    const result = await svc.editFile(conv, filepath, oldStr, newStr);
+    if (!result.ok) {
+      if (callback)
+        await callback({ content: { text: result.error } });
+      return { success: false, text: result.error };
+    }
+    const msg = `Edited ${filepath}`;
+    if (callback)
+      await callback({ content: { text: msg } });
+    return { success: true, text: msg };
+  }
+};
+// actions/executeShell.ts
+function getCommand(options) {
+  const opt = options;
+  return opt?.command?.trim() ?? "";
+}
+var spec3 = requireActionSpec("EXECUTE_SHELL");
+var executeShell = {
+  name: spec3.name,
+  similes: spec3.similes ? [...spec3.similes] : [],
+  description: spec3.description,
+  validate: async (runtime) => runtime.getService("coder") !== null,
+  handler: async (runtime, message, _state, options, callback) => {
+    const svc = runtime.getService("coder");
+    if (!svc) {
+      const msg = "Coder service is not available.";
+      if (callback)
+        await callback({ content: { text: msg } });
+      return { success: false, text: msg };
+    }
+    const cmd = getCommand(options);
+    if (!cmd) {
+      const msg = "Missing command.";
+      if (callback)
+        await callback({ content: { text: msg } });
+      return { success: false, text: msg };
+    }
+    const conv = message.roomId ?? message.agentId ?? runtime.agentId;
+    const result = await svc.executeShell(cmd, conv);
+    const out = result.success ? result.stdout : result.stderr;
+    if (callback)
+      await callback({ content: { text: out } });
+    return { success: result.success, text: out };
+  }
+};
+// actions/git.ts
+function getArgs(options) {
+  const opt = options;
+  return opt?.args?.trim() ?? "";
+}
+var spec4 = requireActionSpec("GIT");
+var git = {
+  name: spec4.name,
+  similes: spec4.similes ? [...spec4.similes] : [],
+  description: spec4.description,
+  validate: async (runtime) => runtime.getService("coder") !== null,
+  handler: async (runtime, message, _state, options, callback) => {
+    const svc = runtime.getService("coder");
+    if (!svc) {
+      const msg = "Coder service is not available.";
+      if (callback)
+        await callback({ content: { text: msg } });
+      return { success: false, text: msg };
+    }
+    const args = getArgs(options);
+    if (!args) {
+      const msg = 'Missing args (provide options.args, e.g. "status").';
+      if (callback)
+        await callback({ content: { text: msg } });
+      return { success: false, text: msg };
+    }
+    const conv = message.roomId ?? message.agentId ?? runtime.agentId;
+    const result = await svc.git(args, conv);
+    const out = result.success ? result.stdout : result.stderr;
+    if (callback)
+      await callback({ content: { text: out } });
+    return { success: result.success, text: out };
+  }
+};
+// actions/listFiles.ts
+function getDir(options) {
+  const opt = options;
+  return opt?.path?.trim() ?? ".";
+}
+var spec5 = requireActionSpec("LIST_FILES");
+var listFiles = {
+  name: spec5.name,
+  similes: spec5.similes ? [...spec5.similes] : [],
+  description: spec5.description,
+  validate: async (runtime) => runtime.getService("coder") !== null,
+  handler: async (runtime, message, _state, options, callback) => {
+    const svc = runtime.getService("coder");
+    if (!svc) {
+      const msg = "Coder service is not available.";
+      if (callback)
+        await callback({ content: { text: msg } });
+      return { success: false, text: msg };
+    }
+    const conv = message.roomId ?? message.agentId ?? runtime.agentId;
+    const dir = getDir(options);
+    const result = await svc.listFiles(conv, dir);
+    if (!result.ok) {
+      if (callback)
+        await callback({ content: { text: result.error } });
+      return { success: false, text: result.error };
+    }
+    const out = result.items.length > 0 ? result.items.join(`
+`) : "(empty)";
+    if (callback)
+      await callback({ content: { text: out } });
+    return { success: true, text: out };
+  }
+};
+// actions/readFile.ts
+import * as path from "node:path";
+function extToLang(ext) {
+  const e = ext.toLowerCase();
+  if (e === ".ts" || e === ".tsx")
+    return "ts";
+  if (e === ".js" || e === ".jsx")
+    return "js";
+  if (e === ".json")
+    return "json";
+  if (e === ".md")
+    return "md";
+  if (e === ".py")
+    return "py";
+  if (e === ".rs")
+    return "rs";
+  if (e === ".go")
+    return "go";
+  if (e === ".toml")
+    return "toml";
+  if (e === ".yml" || e === ".yaml")
+    return "yaml";
+  if (e === ".sh" || e === ".bash" || e === ".zsh")
+    return "bash";
+  return "";
+}
+function getFilepath(options, message) {
+  const opt = options;
+  if (opt?.filepath && opt.filepath.trim().length > 0)
+    return opt.filepath.trim();
+  const text = message.content.text ?? "";
+  const m = text.match(/["'`]([^"'`]+)["'`]/);
+  if (m?.[1])
+    return m[1].trim();
+  const loose = text.match(/(?:\.\/|\/)?[\w\-./]+\.[a-zA-Z0-9]+/);
+  return loose?.[0]?.trim() ?? "";
+}
+var spec6 = requireActionSpec("READ_FILE");
+var readFile = {
+  name: spec6.name,
+  similes: spec6.similes ? [...spec6.similes] : [],
+  description: `${spec6.description} Reads a file's contents.`,
+  validate: async (runtime, _message) => runtime.getService("coder") !== null,
+  handler: async (runtime, message, _state, options, callback) => {
+    const svc = runtime.getService("coder");
+    if (!svc) {
+      const msg = "Coder service is not available.";
+      if (callback)
+        await callback({ content: { text: msg } });
+      return { success: false, text: msg };
+    }
+    const filepath = getFilepath(options, message);
+    if (!filepath) {
+      const msg = "Missing filepath.";
+      if (callback)
+        await callback({ content: { text: msg } });
+      return { success: false, text: msg };
+    }
+    const conv = message.roomId ?? message.agentId ?? runtime.agentId;
+    const result = await svc.readFile(conv, filepath);
+    if (!result.ok) {
+      if (callback)
+        await callback({ content: { text: result.error } });
+      return { success: false, text: result.error };
+    }
+    const lang = extToLang(path.extname(filepath));
+    const fenced = `\`\`\`${lang}
+${result.content}
+\`\`\``;
+    if (callback)
+      await callback({ content: { text: fenced } });
+    return { success: true, text: fenced };
+  }
+};
+// actions/searchFiles.ts
+function getInputs2(options) {
+  const opt = options;
+  const pattern = (opt?.pattern ?? "").trim();
+  const p = (opt?.path ?? ".").trim() || ".";
+  const mm = typeof opt?.maxMatches === "number" ? opt.maxMatches : Number.parseInt((opt?.max_matches ?? "").trim(), 10);
+  const maxMatches = Number.isFinite(mm) && mm > 0 ? mm : 50;
+  return { pattern, path: p, maxMatches };
+}
+var spec7 = requireActionSpec("SEARCH_FILES");
+var searchFiles = {
+  name: spec7.name,
+  similes: spec7.similes ? [...spec7.similes] : [],
+  description: spec7.description,
+  validate: async (runtime) => runtime.getService("coder") !== null,
+  handler: async (runtime, message, _state, options, callback) => {
+    const svc = runtime.getService("coder");
+    if (!svc) {
+      const msg = "Coder service is not available.";
+      if (callback)
+        await callback({ content: { text: msg } });
+      return { success: false, text: msg };
+    }
+    const conv = message.roomId ?? message.agentId ?? runtime.agentId;
+    const { pattern, path: path2, maxMatches } = getInputs2(options);
+    if (!pattern) {
+      const msg = "Missing pattern.";
+      if (callback)
+        await callback({ content: { text: msg } });
+      return { success: false, text: msg };
+    }
+    const result = await svc.searchFiles(conv, pattern, path2, maxMatches);
+    if (!result.ok) {
+      if (callback)
+        await callback({ content: { text: result.error } });
+      return { success: false, text: result.error };
+    }
+    const out = result.matches.length === 0 ? `No matches for "${pattern}".` : result.matches.map((m) => `${m.file}:L${m.line}: ${m.content}`).join(`
+`);
+    if (callback)
+      await callback({ content: { text: out } });
+    return { success: true, text: out };
+  }
+};
+// actions/writeFile.ts
+function getInputs3(options, message) {
+  const opt = options;
+  const filepath = opt?.filepath?.trim() ?? "";
+  const content = opt?.content ?? "";
+  if (filepath)
+    return { filepath, content };
+  const text = message.content.text ?? "";
+  const m = text.match(/["'`]([^"'`]+)["'`]/);
+  const inferred = m?.[1]?.trim() ?? "";
+  return { filepath: inferred, content };
+}
+var spec8 = requireActionSpec("WRITE_FILE");
+var writeFile = {
+  name: spec8.name,
+  similes: spec8.similes ? [...spec8.similes] : [],
+  description: spec8.description,
+  validate: async (runtime) => runtime.getService("coder") !== null,
+  handler: async (runtime, message, _state, options, callback) => {
+    const svc = runtime.getService("coder");
+    if (!svc) {
+      const msg2 = "Coder service is not available.";
+      if (callback)
+        await callback({ content: { text: msg2 } });
+      return { success: false, text: msg2 };
+    }
+    const { filepath, content } = getInputs3(options, message);
+    if (!filepath) {
+      const msg2 = "Missing filepath.";
+      if (callback)
+        await callback({ content: { text: msg2 } });
+      return { success: false, text: msg2 };
+    }
+    const conv = message.roomId ?? message.agentId ?? runtime.agentId;
+    const result = await svc.writeFile(conv, filepath, content);
+    if (!result.ok) {
+      if (callback)
+        await callback({ content: { text: result.error } });
+      return { success: false, text: result.error };
+    }
+    const msg = `Wrote ${filepath} (${content.length} chars)`;
+    if (callback)
+      await callback({ content: { text: msg } });
+    return { success: true, text: msg };
+  }
+};
+// providers/coderStatusProvider.ts
+import {
+  addHeader,
+  logger
+} from "@elizaos/core";
+var MAX_OUTPUT_LENGTH = 8000;
+var TRUNCATE_SEGMENT_LENGTH = 4000;
+var spec9 = requireProviderSpec("coderStatusProvider");
+var coderStatusProvider = {
+  name: spec9.name,
+  description: "Provides current working directory, allowed directory, and recent shell/file operations",
+  position: 99,
+  get: async (runtime, message, _state) => {
+    const svc = runtime.getService("coder");
+    if (!svc) {
+      logger.warn("[coderStatusProvider] Coder service not found");
+      return {
+        values: {
+          coderStatus: "Coder service is not available",
+          currentWorkingDirectory: "N/A",
+          allowedDirectory: "N/A"
+        },
+        text: addHeader("# Coder Status", "Coder service is not available"),
+        data: { historyCount: 0, cwd: "N/A", allowedDir: "N/A" }
+      };
+    }
+    const conversationId = message.roomId ?? message.agentId ?? runtime.agentId;
+    const history = svc.getCommandHistory(conversationId, 10);
+    const cwd = svc.getCurrentDirectory(conversationId);
+    const allowedDir = svc.getAllowedDirectory();
+    let historyText = "No commands in history.";
+    if (history.length > 0) {
+      historyText = history.map((entry) => {
+        let entryStr = `[${new Date(entry.timestamp).toISOString()}] ${entry.workingDirectory}> ${entry.command}`;
+        if (entry.stdout) {
+          if (entry.stdout.length > MAX_OUTPUT_LENGTH) {
+            entryStr += `
+  Output: ${entry.stdout.substring(0, TRUNCATE_SEGMENT_LENGTH)}
+  ... [TRUNCATED] ...
+  ${entry.stdout.substring(entry.stdout.length - TRUNCATE_SEGMENT_LENGTH)}`;
+          } else {
+            entryStr += `
+  Output: ${entry.stdout}`;
+          }
+        }
+        if (entry.stderr) {
+          if (entry.stderr.length > MAX_OUTPUT_LENGTH) {
+            entryStr += `
+  Error: ${entry.stderr.substring(0, TRUNCATE_SEGMENT_LENGTH)}
+  ... [TRUNCATED] ...
+  ${entry.stderr.substring(entry.stderr.length - TRUNCATE_SEGMENT_LENGTH)}`;
+          } else {
+            entryStr += `
+  Error: ${entry.stderr}`;
+          }
+        }
+        entryStr += `
+  Exit Code: ${entry.exitCode}`;
+        if (entry.fileOperations && entry.fileOperations.length > 0) {
+          entryStr += `
+  File Operations:`;
+          entry.fileOperations.forEach((op) => {
+            entryStr += `
+    - ${op.type}: ${op.target}`;
+          });
+        }
+        return entryStr;
+      }).join(`
+
+`);
+    }
+    const recentFileOps = history.filter((h) => (h.fileOperations?.length ?? 0) > 0).flatMap((h) => h.fileOperations ?? []).slice(-8);
+    const fileOpsText = recentFileOps.length > 0 ? `
+
+${addHeader("# Recent File Operations", recentFileOps.map((op) => `- ${op.type}: ${op.target}`).join(`
+`))}` : "";
+    const text = `Current Directory: ${cwd}
+Allowed Directory: ${allowedDir}
+
+${addHeader("# Recent Commands (Last 10)", historyText)}${fileOpsText}`;
+    return {
+      values: {
+        coderStatus: historyText,
+        currentWorkingDirectory: cwd,
+        allowedDirectory: allowedDir
+      },
+      text,
+      data: {
+        historyCount: history.length,
+        cwd,
+        allowedDir
+      }
+    };
+  }
+};
+// services/coderService.ts
+import { execSync } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as path4 from "node:path";
+import { logger as logger2, Service } from "@elizaos/core";
+
+// utils/config.ts
+import * as path2 from "node:path";
+function parseBool(value) {
+  const v = (value ?? "").trim().toLowerCase();
+  return v === "1" || v === "true" || v === "yes" || v === "on";
+}
+function parseIntMs(value, fallback) {
+  const parsed = Number.parseInt((value ?? "").trim(), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0)
+    return fallback;
+  return parsed;
+}
+function loadCoderConfig() {
+  const enabled = parseBool(process.env.CODER_ENABLED);
+  const allowedDirectoryRaw = (process.env.CODER_ALLOWED_DIRECTORY ?? "").trim();
+  const allowedDirectory = allowedDirectoryRaw ? path2.resolve(allowedDirectoryRaw) : process.cwd();
+  const timeoutMs = parseIntMs(process.env.CODER_TIMEOUT, 30000);
+  const forbiddenCommands = (process.env.CODER_FORBIDDEN_COMMANDS ?? "").split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  return { enabled, allowedDirectory, timeoutMs, forbiddenCommands };
+}
+// utils/pathUtils.ts
+import * as path3 from "node:path";
+var DEFAULT_FORBIDDEN_COMMANDS = [
+  "rm -rf /",
+  "rm -rf ~",
+  "sudo rm",
+  "mkfs",
+  "dd if=/dev"
+];
+function extractBaseCommand(command) {
+  const trimmed = command.trim();
+  if (!trimmed)
+    return "";
+  const first = trimmed.split(/\s+/)[0];
+  return first ?? "";
+}
+function isSafeCommand(command) {
+  const c = command.trim();
+  if (!c)
+    return false;
+  if (c.includes("&&") || c.includes("||") || c.includes(";"))
+    return false;
+  if (c.includes("$(") || c.includes("`"))
+    return false;
+  return true;
+}
+function isForbiddenCommand(command, additionalForbidden) {
+  const c = command.toLowerCase();
+  for (const f of DEFAULT_FORBIDDEN_COMMANDS) {
+    if (c.includes(f.toLowerCase()))
+      return true;
+  }
+  for (const f of additionalForbidden) {
+    if (f.trim().length === 0)
+      continue;
+    if (c.includes(f.toLowerCase()))
+      return true;
+  }
+  return false;
+}
+function validatePath(targetPath, allowedDirectory, currentDirectory) {
+  const base = currentDirectory && currentDirectory.length > 0 ? currentDirectory : allowedDirectory;
+  const resolved = path3.resolve(base, targetPath);
+  const allowed = path3.resolve(allowedDirectory);
+  const rel = path3.relative(allowed, resolved);
+  if (rel === "")
+    return resolved;
+  if (rel.startsWith("..") || path3.isAbsolute(rel))
+    return null;
+  return resolved;
+}
+// services/coderService.ts
+class CoderService extends Service {
+  static serviceType = "coder";
+  coderConfig;
+  currentDirectoryByConversation = new Map;
+  commandHistoryByConversation = new Map;
+  maxHistoryPerConversation = 100;
+  constructor(runtime) {
+    super(runtime);
+    this.coderConfig = loadCoderConfig();
+  }
+  static async start(runtime) {
+    const instance = new CoderService(runtime);
+    logger2.info("Coder service initialized");
+    return instance;
+  }
+  async stop() {
+    logger2.info("Coder service stopped");
+  }
+  get capabilityDescription() {
+    return "Filesystem + shell + git tools within a restricted directory";
+  }
+  getAllowedDirectory() {
+    return this.coderConfig.allowedDirectory;
+  }
+  getCurrentDirectory(conversationId) {
+    return this.currentDirectoryByConversation.get(conversationId) ?? this.coderConfig.allowedDirectory;
+  }
+  setCurrentDirectory(conversationId, dir) {
+    this.currentDirectoryByConversation.set(conversationId, dir);
+  }
+  getCommandHistory(conversationId, limit) {
+    const all = this.commandHistoryByConversation.get(conversationId) ?? [];
+    if (limit <= 0)
+      return [];
+    return all.slice(-limit);
+  }
+  addToHistory(conversationId, command, result, fileOperations) {
+    if (!conversationId)
+      return;
+    const list = this.commandHistoryByConversation.get(conversationId) ?? [];
+    list.push({
+      timestamp: Date.now(),
+      workingDirectory: result.executedIn,
+      command,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      exitCode: result.exitCode,
+      fileOperations
+    });
+    const trimmed = list.length > this.maxHistoryPerConversation ? list.slice(-this.maxHistoryPerConversation) : list;
+    this.commandHistoryByConversation.set(conversationId, trimmed);
+  }
+  ensureEnabled() {
+    if (this.coderConfig.enabled)
+      return null;
+    return "Coder plugin is disabled. Set CODER_ENABLED=true to enable.";
+  }
+  resolveWithin(conversationId, targetPath) {
+    const cwd = this.getCurrentDirectory(conversationId);
+    const validated = validatePath(targetPath, this.coderConfig.allowedDirectory, cwd);
+    if (!validated)
+      return { error: "Cannot access path outside allowed directory" };
+    const rel = path4.relative(this.coderConfig.allowedDirectory, validated);
+    return { fullPath: validated, relPath: rel.length === 0 ? "." : rel };
+  }
+  async changeDirectory(conversationId, targetPath) {
+    const disabled = this.ensureEnabled();
+    if (disabled) {
+      return {
+        success: false,
+        stdout: "",
+        stderr: disabled,
+        exitCode: 1,
+        error: "Coder disabled",
+        executedIn: this.getCurrentDirectory(conversationId)
+      };
+    }
+    const resolved = this.resolveWithin(conversationId, targetPath);
+    if ("error" in resolved) {
+      return {
+        success: false,
+        stdout: "",
+        stderr: resolved.error,
+        exitCode: 1,
+        error: "Permission denied",
+        executedIn: this.getCurrentDirectory(conversationId)
+      };
+    }
+    try {
+      const stat2 = await fs.stat(resolved.fullPath);
+      if (!stat2.isDirectory()) {
+        return {
+          success: false,
+          stdout: "",
+          stderr: "Not a directory",
+          exitCode: 1,
+          error: "Not a directory",
+          executedIn: this.getCurrentDirectory(conversationId)
+        };
+      }
+      this.setCurrentDirectory(conversationId, resolved.fullPath);
+      return {
+        success: true,
+        stdout: `Changed directory to: ${resolved.fullPath}`,
+        stderr: "",
+        exitCode: 0,
+        executedIn: resolved.fullPath
+      };
+    } catch (err) {
+      const e = err;
+      return {
+        success: false,
+        stdout: "",
+        stderr: e.message,
+        exitCode: 1,
+        error: "Failed to change directory",
+        executedIn: this.getCurrentDirectory(conversationId)
+      };
+    }
+  }
+  async readFile(conversationId, filepath) {
+    const disabled = this.ensureEnabled();
+    if (disabled)
+      return { ok: false, error: disabled };
+    const resolved = this.resolveWithin(conversationId, filepath);
+    if ("error" in resolved)
+      return { ok: false, error: resolved.error };
+    try {
+      const stat2 = await fs.stat(resolved.fullPath);
+      if (stat2.isDirectory())
+        return { ok: false, error: "Path is a directory" };
+      const content = await fs.readFile(resolved.fullPath, "utf-8");
+      return { ok: true, content };
+    } catch (err) {
+      const e = err;
+      return {
+        ok: false,
+        error: e.code === "ENOENT" ? "File not found" : e.message
+      };
+    }
+  }
+  async writeFile(conversationId, filepath, content) {
+    const disabled = this.ensureEnabled();
+    if (disabled)
+      return { ok: false, error: disabled };
+    const resolved = this.resolveWithin(conversationId, filepath);
+    if ("error" in resolved)
+      return { ok: false, error: resolved.error };
+    try {
+      await fs.mkdir(path4.dirname(resolved.fullPath), { recursive: true });
+      await fs.writeFile(resolved.fullPath, content, "utf-8");
+      return { ok: true };
+    } catch (err) {
+      const e = err;
+      return { ok: false, error: e.message };
+    }
+  }
+  async editFile(conversationId, filepath, oldStr, newStr) {
+    const disabled = this.ensureEnabled();
+    if (disabled)
+      return { ok: false, error: disabled };
+    const resolved = this.resolveWithin(conversationId, filepath);
+    if ("error" in resolved)
+      return { ok: false, error: resolved.error };
+    try {
+      const content = await fs.readFile(resolved.fullPath, "utf-8");
+      if (!content.includes(oldStr))
+        return { ok: false, error: "Could not find old_str in file" };
+      const next = content.replace(oldStr, newStr);
+      await fs.writeFile(resolved.fullPath, next, "utf-8");
+      return { ok: true };
+    } catch (err) {
+      const e = err;
+      return {
+        ok: false,
+        error: e.code === "ENOENT" ? "File not found" : e.message
+      };
+    }
+  }
+  async listFiles(conversationId, dirPath) {
+    const disabled = this.ensureEnabled();
+    if (disabled)
+      return { ok: false, error: disabled };
+    const resolved = this.resolveWithin(conversationId, dirPath);
+    if ("error" in resolved)
+      return { ok: false, error: resolved.error };
+    try {
+      const entries = await fs.readdir(resolved.fullPath, {
+        withFileTypes: true
+      });
+      const items = entries.filter((e) => !e.name.startsWith(".")).map((e) => `${e.name}${e.isDirectory() ? "/" : ""}`).sort((a, b) => a.localeCompare(b));
+      return { ok: true, items };
+    } catch (err) {
+      const e = err;
+      return {
+        ok: false,
+        error: e.code === "ENOENT" ? "Directory not found" : e.message
+      };
+    }
+  }
+  async searchFiles(conversationId, pattern, dirPath, maxMatches) {
+    const disabled = this.ensureEnabled();
+    if (disabled)
+      return { ok: false, error: disabled };
+    const resolved = this.resolveWithin(conversationId, dirPath);
+    if ("error" in resolved)
+      return { ok: false, error: resolved.error };
+    const needle = pattern.trim();
+    if (!needle)
+      return { ok: false, error: "Missing pattern" };
+    const limit = Number.isFinite(maxMatches) && maxMatches > 0 ? Math.min(500, Math.floor(maxMatches)) : 50;
+    const matches = [];
+    await this.searchInDirectory(resolved.fullPath, needle.toLowerCase(), matches, limit);
+    return { ok: true, matches };
+  }
+  async searchInDirectory(dir, needleLower, matches, maxMatches) {
+    if (matches.length >= maxMatches)
+      return;
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (matches.length >= maxMatches)
+        break;
+      if (entry.name.startsWith("."))
+        continue;
+      const full = path4.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "coverage" || entry.name === ".git") {
+          continue;
+        }
+        await this.searchInDirectory(full, needleLower, matches, maxMatches);
+        continue;
+      }
+      if (!entry.isFile())
+        continue;
+      const content = await fs.readFile(full, "utf-8");
+      const lines = content.split(`
+`);
+      for (let i = 0;i < lines.length; i++) {
+        if (matches.length >= maxMatches)
+          break;
+        const line = lines[i] ?? "";
+        if (!line.toLowerCase().includes(needleLower))
+          continue;
+        matches.push({
+          file: path4.relative(this.coderConfig.allowedDirectory, full),
+          line: i + 1,
+          content: line.trim().slice(0, 240)
+        });
+      }
+    }
+  }
+  async executeShell(command, conversationId) {
+    const disabled = this.ensureEnabled();
+    if (disabled) {
+      return {
+        success: false,
+        stdout: "",
+        stderr: disabled,
+        exitCode: 1,
+        error: "Coder disabled",
+        executedIn: this.getCurrentDirectory(conversationId)
+      };
+    }
+    const trimmed = command.trim();
+    if (!trimmed) {
+      return {
+        success: false,
+        stdout: "",
+        stderr: "Invalid command",
+        exitCode: 1,
+        error: "Empty command",
+        executedIn: this.getCurrentDirectory(conversationId)
+      };
+    }
+    if (!isSafeCommand(trimmed)) {
+      return {
+        success: false,
+        stdout: "",
+        stderr: "Command contains forbidden patterns",
+        exitCode: 1,
+        error: "Security policy violation",
+        executedIn: this.getCurrentDirectory(conversationId)
+      };
+    }
+    if (isForbiddenCommand(trimmed, this.coderConfig.forbiddenCommands)) {
+      return {
+        success: false,
+        stdout: "",
+        stderr: "Command is forbidden by security policy",
+        exitCode: 1,
+        error: "Forbidden command",
+        executedIn: this.getCurrentDirectory(conversationId)
+      };
+    }
+    const cwd = this.getCurrentDirectory(conversationId);
+    try {
+      const stdout = execSync(trimmed, {
+        cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+        timeout: this.coderConfig.timeoutMs,
+        maxBuffer: 10 * 1024 * 1024
+      }).toString();
+      const result = {
+        success: true,
+        stdout,
+        stderr: "",
+        exitCode: 0,
+        executedIn: cwd
+      };
+      this.addToHistory(conversationId, trimmed, result);
+      return result;
+    } catch (err) {
+      const e = err;
+      const stderr = (e.stderr ?? e.message).toString();
+      const stdout = (e.stdout ?? "").toString();
+      const exitCode = typeof e.status === "number" ? e.status : 1;
+      const result = {
+        success: false,
+        stdout,
+        stderr,
+        exitCode,
+        error: "Command failed",
+        executedIn: cwd
+      };
+      this.addToHistory(conversationId, trimmed, result);
+      return result;
+    }
+  }
+  async git(args, conversationId) {
+    return this.executeShell(`git ${args}`, conversationId);
+  }
+}
+
+// index.ts
+var coderPlugin = {
+  name: "eliza-coder",
+  description: "Coder tools: filesystem, shell, and git (restricted)",
+  services: [CoderService],
+  actions: [
+    readFile,
+    listFiles,
+    searchFiles,
+    writeFile,
+    editFile,
+    changeDirectory,
+    executeShell,
+    git
+  ],
+  providers: [coderStatusProvider]
+};
+var typescript_default = coderPlugin;
+export {
+  writeFile,
+  validatePath,
+  searchFiles,
+  readFile,
+  loadCoderConfig,
+  listFiles,
+  isSafeCommand,
+  isForbiddenCommand,
+  git,
+  extractBaseCommand,
+  executeShell,
+  editFile,
+  typescript_default as default,
+  coderStatusProvider,
+  coderPlugin,
+  changeDirectory,
+  DEFAULT_FORBIDDEN_COMMANDS,
+  CoderService
+};
+
+//# debugId=11D69657230A26B464756E2164756E21