@elizaos/plugin-code 2.0.0-alpha.2 → 2.0.0-alpha.3

package/dist/index.js

@@ -157,6 +157,16 @@ function requireActionSpec(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) {
@@ -512,8 +522,9 @@ import {
 } from "@elizaos/core";
 var MAX_OUTPUT_LENGTH = 8000;
 var TRUNCATE_SEGMENT_LENGTH = 4000;
+var spec9 = requireProviderSpec("coderStatusProvider");
 var coderStatusProvider = {
-  name: "CODER_STATUS",
+  name: spec9.name,
   description: "Provides current working directory, allowed directory, and recent shell/file operations",
   position: 99,
   get: async (runtime, message, _state) => {
@@ -951,6 +962,37 @@ class CoderService extends Service {
         executedIn: this.getCurrentDirectory(conversationId)
       };
     }
+    const cwd = this.getCurrentDirectory(conversationId);
+    const shellService = typeof this.runtime?.getService === "function" ? this.runtime.getService("shell") : null;
+    if (shellService) {
+      const execResult = await shellService.exec(trimmed, {
+        workdir: cwd,
+        timeout: Math.floor(this.coderConfig.timeoutMs / 1000),
+        conversationId
+      });
+      if (execResult.status === "running") {
+        const result2 = {
+          success: true,
+          stdout: `Command running in background (session: ${execResult.sessionId})`,
+          stderr: "",
+          exitCode: 0,
+          executedIn: cwd
+        };
+        this.addToHistory(conversationId, trimmed, result2);
+        return result2;
+      }
+      const success = execResult.status === "completed" && execResult.exitCode === 0;
+      const result = {
+        success,
+        stdout: execResult.aggregated ?? "",
+        stderr: execResult.reason ?? "",
+        exitCode: execResult.exitCode ?? (success ? 0 : 1),
+        error: success ? undefined : "Command failed",
+        executedIn: cwd
+      };
+      this.addToHistory(conversationId, trimmed, result);
+      return result;
+    }
     if (!isSafeCommand(trimmed)) {
       return {
         success: false,
@@ -958,7 +1000,7 @@ class CoderService extends Service {
         stderr: "Command contains forbidden patterns",
         exitCode: 1,
         error: "Security policy violation",
-        executedIn: this.getCurrentDirectory(conversationId)
+        executedIn: cwd
       };
     }
     if (isForbiddenCommand(trimmed, this.coderConfig.forbiddenCommands)) {
@@ -968,10 +1010,9 @@ class CoderService extends Service {
         stderr: "Command is forbidden by security policy",
         exitCode: 1,
         error: "Forbidden command",
-        executedIn: this.getCurrentDirectory(conversationId)
+        executedIn: cwd
       };
     }
-    const cwd = this.getCurrentDirectory(conversationId);
     try {
       const stdout = execSync(trimmed, {
         cwd,
@@ -1010,6 +1051,413 @@ class CoderService extends Service {
     return this.executeShell(`git ${args}`, conversationId);
   }
 }
+// configureCodingTools.ts
+function configureCodingTools(runtime, options) {
+  const shellService = runtime.getService("shell");
+  const coderService = runtime.getService("coder");
+  const defaultCwd = options?.cwd ?? process.cwd();
+  const scopeKey = options?.scopeKey;
+  const sessionKey = options?.sessionKey;
+  const notifyOnExit = options?.notifyOnExit ?? false;
+  const defaultBackgroundMs = options?.backgroundMs ?? 1e4;
+  const defaultTimeoutSec = options?.timeoutSec ?? 1800;
+  const conversationId = options?.conversationId ?? "default";
+  const actions = [];
+  if (shellService) {
+    const execAction = {
+      name: "exec",
+      label: "exec",
+      description: "Execute a shell command. Returns output when complete or session info if backgrounded.",
+      parameters: {
+        type: "object",
+        properties: {
+          command: { type: "string", description: "Shell command to execute" },
+          workdir: {
+            type: "string",
+            description: "Working directory (optional)"
+          },
+          env: {
+            type: "object",
+            additionalProperties: { type: "string" },
+            description: "Environment variables (optional)"
+          },
+          yieldMs: {
+            type: "number",
+            description: "Milliseconds to wait before backgrounding (default 10000)"
+          },
+          background: {
+            type: "boolean",
+            description: "Run in background immediately"
+          },
+          timeout: { type: "number", description: "Timeout in seconds" },
+          pty: {
+            type: "boolean",
+            description: "Use PTY for interactive commands"
+          }
+        },
+        required: ["command"]
+      },
+      execute: async (context) => {
+        const params = context.args;
+        if (!params.command) {
+          throw new Error("Provide a command to execute.");
+        }
+        const result = await shellService.exec(params.command, {
+          workdir: params.workdir?.trim() || defaultCwd,
+          env: params.env,
+          yieldMs: params.yieldMs ?? defaultBackgroundMs,
+          background: params.background,
+          timeout: params.timeout ?? defaultTimeoutSec,
+          pty: params.pty,
+          scopeKey,
+          sessionKey,
+          notifyOnExit,
+          conversationId: context.conversationId ?? conversationId,
+          onUpdate: context.onUpdate ? (session) => {
+            context.onUpdate?.({
+              content: [
+                {
+                  type: "text",
+                  text: session.tail || session.aggregated || ""
+                }
+              ],
+              details: {
+                status: "running",
+                sessionId: session.id,
+                pid: session.pid ?? undefined,
+                startedAt: session.startedAt,
+                cwd: session.cwd,
+                tail: session.tail
+              }
+            });
+          } : undefined
+        });
+        if (result.status === "running") {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Command still running (session ${result.sessionId}, pid ${result.pid ?? "n/a"}). Use process action (list/poll/log/write/kill) for follow-up.`
+              }
+            ],
+            details: {
+              status: "running",
+              sessionId: result.sessionId,
+              pid: result.pid ?? undefined,
+              startedAt: result.startedAt,
+              cwd: result.cwd,
+              tail: result.tail
+            }
+          };
+        }
+        if (result.status === "failed") {
+          return {
+            content: [
+              {
+                type: "text",
+                text: result.aggregated || result.reason || "Command failed."
+              }
+            ],
+            details: {
+              status: "failed",
+              exitCode: result.exitCode ?? 1,
+              durationMs: result.durationMs,
+              reason: result.reason
+            }
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.aggregated || "(no output)"
+            }
+          ],
+          details: {
+            status: "completed",
+            exitCode: result.exitCode ?? 0,
+            durationMs: result.durationMs,
+            aggregated: result.aggregated,
+            cwd: result.cwd
+          }
+        };
+      }
+    };
+    actions.push(execAction);
+    const processAction = {
+      name: "process",
+      label: "process",
+      description: "Manage running exec sessions: list, poll, log, write, send-keys, submit, paste, kill.",
+      parameters: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            description: "Process action (list, poll, log, write, send-keys, submit, paste, kill, clear, remove)"
+          },
+          sessionId: {
+            type: "string",
+            description: "Session id for actions other than list"
+          },
+          data: {
+            type: "string",
+            description: "Data to write for write action"
+          },
+          keys: {
+            type: "array",
+            items: { type: "string" },
+            description: "Key tokens to send for send-keys"
+          },
+          hex: {
+            type: "array",
+            items: { type: "string" },
+            description: "Hex bytes to send for send-keys"
+          },
+          literal: {
+            type: "string",
+            description: "Literal string for send-keys"
+          },
+          text: {
+            type: "string",
+            description: "Text to paste for paste action"
+          },
+          bracketed: {
+            type: "boolean",
+            description: "Wrap paste in bracketed mode"
+          },
+          eof: { type: "boolean", description: "Close stdin after write" },
+          offset: { type: "number", description: "Log offset" },
+          limit: { type: "number", description: "Log length" }
+        },
+        required: ["action"]
+      },
+      execute: async (context) => {
+        const params = context.args;
+        const result = await shellService.processAction({
+          action: params.action,
+          sessionId: params.sessionId,
+          data: params.data,
+          keys: params.keys,
+          hex: params.hex,
+          literal: params.literal,
+          text: params.text,
+          bracketed: params.bracketed,
+          eof: params.eof,
+          offset: params.offset,
+          limit: params.limit
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.message
+            }
+          ],
+          details: result.data
+        };
+      }
+    };
+    actions.push(processAction);
+  }
+  if (coderService) {
+    const readFileAction = {
+      name: "read_file",
+      label: "read_file",
+      description: "Read the contents of a file.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Path to the file to read" }
+        },
+        required: ["path"]
+      },
+      execute: async (context) => {
+        const params = context.args;
+        const convId = context.conversationId ?? conversationId;
+        const result = await coderService.readFile(convId, params.path);
+        if (!result.ok) {
+          return {
+            content: [{ type: "text", text: `Error: ${result.error}` }],
+            details: { success: false, error: result.error }
+          };
+        }
+        return {
+          content: [{ type: "text", text: result.content }],
+          details: { success: true }
+        };
+      }
+    };
+    actions.push(readFileAction);
+    const writeFileAction = {
+      name: "write_file",
+      label: "write_file",
+      description: "Write content to a file. Creates the file if it doesn't exist.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Path to the file to write" },
+          content: {
+            type: "string",
+            description: "Content to write to the file"
+          }
+        },
+        required: ["path", "content"]
+      },
+      execute: async (context) => {
+        const params = context.args;
+        const convId = context.conversationId ?? conversationId;
+        const result = await coderService.writeFile(convId, params.path, params.content);
+        if (!result.ok) {
+          return {
+            content: [{ type: "text", text: `Error: ${result.error}` }],
+            details: { success: false, error: result.error }
+          };
+        }
+        return {
+          content: [{ type: "text", text: `File written: ${params.path}` }],
+          details: { success: true }
+        };
+      }
+    };
+    actions.push(writeFileAction);
+    const editFileAction = {
+      name: "edit_file",
+      label: "edit_file",
+      description: "Edit a file by replacing text. Finds old_str and replaces with new_str.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Path to the file to edit" },
+          old_str: { type: "string", description: "Text to find and replace" },
+          new_str: { type: "string", description: "Text to replace with" }
+        },
+        required: ["path", "old_str", "new_str"]
+      },
+      execute: async (context) => {
+        const params = context.args;
+        const convId = context.conversationId ?? conversationId;
+        const result = await coderService.editFile(convId, params.path, params.old_str, params.new_str);
+        if (!result.ok) {
+          return {
+            content: [{ type: "text", text: `Error: ${result.error}` }],
+            details: { success: false, error: result.error }
+          };
+        }
+        return {
+          content: [{ type: "text", text: `File edited: ${params.path}` }],
+          details: { success: true }
+        };
+      }
+    };
+    actions.push(editFileAction);
+    const listFilesAction = {
+      name: "list_files",
+      label: "list_files",
+      description: "List files and directories in a path.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Directory path to list (defaults to current directory)"
+          }
+        },
+        required: []
+      },
+      execute: async (context) => {
+        const params = context.args;
+        const convId = context.conversationId ?? conversationId;
+        const result = await coderService.listFiles(convId, params.path ?? ".");
+        if (!result.ok) {
+          return {
+            content: [{ type: "text", text: `Error: ${result.error}` }],
+            details: { success: false, error: result.error }
+          };
+        }
+        return {
+          content: [{ type: "text", text: result.items.join(`
+`) }],
+          details: { success: true, items: result.items }
+        };
+      }
+    };
+    actions.push(listFilesAction);
+    const searchFilesAction = {
+      name: "search_files",
+      label: "search_files",
+      description: "Search for a pattern in files within a directory.",
+      parameters: {
+        type: "object",
+        properties: {
+          pattern: { type: "string", description: "Pattern to search for" },
+          path: {
+            type: "string",
+            description: "Directory path to search in (defaults to current directory)"
+          },
+          max_matches: {
+            type: "number",
+            description: "Maximum matches to return (default 50)"
+          }
+        },
+        required: ["pattern"]
+      },
+      execute: async (context) => {
+        const params = context.args;
+        const convId = context.conversationId ?? conversationId;
+        const result = await coderService.searchFiles(convId, params.pattern, params.path ?? ".", params.max_matches ?? 50);
+        if (!result.ok) {
+          return {
+            content: [{ type: "text", text: `Error: ${result.error}` }],
+            details: { success: false, error: result.error }
+          };
+        }
+        const formatted = result.matches.map((m) => `${m.file}:${m.line}: ${m.content}`).join(`
+`);
+        return {
+          content: [{ type: "text", text: formatted || "No matches found" }],
+          details: { success: true, matches: result.matches }
+        };
+      }
+    };
+    actions.push(searchFilesAction);
+    const gitAction = {
+      name: "git",
+      label: "git",
+      description: "Execute a git command.",
+      parameters: {
+        type: "object",
+        properties: {
+          args: {
+            type: "string",
+            description: "Git command arguments (e.g., 'status', 'diff', 'log --oneline -5')"
+          }
+        },
+        required: ["args"]
+      },
+      execute: async (context) => {
+        const params = context.args;
+        const convId = context.conversationId ?? conversationId;
+        const result = await coderService.git(params.args, convId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.success ? result.stdout : result.stderr
+            }
+          ],
+          details: {
+            success: result.success,
+            exitCode: result.exitCode,
+            stdout: result.stdout,
+            stderr: result.stderr
+          }
+        };
+      }
+    };
+    actions.push(gitAction);
+  }
+  return actions;
+}
 
 // index.ts
 var coderPlugin = {
@@ -1043,6 +1491,7 @@ export {
   executeShell,
   editFile,
   typescript_default as default,
+  configureCodingTools,
   coderStatusProvider,
   coderPlugin,
   changeDirectory,
@@ -1050,4 +1499,4 @@ export {
   CoderService
 };
 
-//# debugId=D9BDD780999C33D664756E2164756E21
+//# debugId=30DB4D8CA69EB24D64756E2164756E21