opencode-gitlab-duo-agentic 0.1.24 → 0.2.2

package/dist/index.js

@@ -10,7 +10,6 @@ var WORKFLOW_CONNECT_TIMEOUT_MS = 15e3;
 var WORKFLOW_HEARTBEAT_INTERVAL_MS = 6e4;
 var WORKFLOW_KEEPALIVE_INTERVAL_MS = 45e3;
 var WORKFLOW_TOKEN_EXPIRY_BUFFER_MS = 3e4;
-var WORKFLOW_TOOL_ERROR_MESSAGE = "Tool execution is not implemented in this client yet";
 
 // src/gitlab/models.ts
 import crypto from "crypto";
@@ -136,8 +135,8 @@ async function resolveRootNamespaceId(client, namespaceId) {
 }
 async function readGitConfig(cwd) {
   const gitPath = path.join(cwd, ".git");
-  const stat = await fs.stat(gitPath);
-  if (stat.isDirectory()) {
+  const stat2 = await fs.stat(gitPath);
+  if (stat2.isDirectory()) {
     return fs.readFile(path.join(gitPath, "config"), "utf8");
   }
   const content = await fs.readFile(gitPath, "utf8");
@@ -412,7 +411,7 @@ var AsyncQueue = class {
   shift() {
     const value = this.#values.shift();
     if (value !== void 0) return Promise.resolve(value);
-    return new Promise((resolve) => this.#waiters.push(resolve));
+    return new Promise((resolve2) => this.#waiters.push(resolve2));
   }
 };
 
@@ -543,7 +542,7 @@ var WorkflowWebSocketClient = class {
   async connect(url, headers) {
     const socket = new WebSocket(url, { headers });
     this.#socket = socket;
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const timeout = setTimeout(() => {
         cleanup();
         socket.close(1e3);
@@ -556,7 +555,7 @@ var WorkflowWebSocketClient = class {
       };
       const onOpen = () => {
         cleanup();
-        resolve();
+        resolve2();
       };
       const onError = (error) => {
         cleanup();
@@ -621,6 +620,268 @@ function decodeSocketMessage(data) {
   return void 0;
 }
 
+// src/workflow/tool-executor.ts
+import { readFile, readdir, writeFile, mkdir as fsMkdir, stat } from "fs/promises";
+import { exec } from "child_process";
+import { resolve, dirname } from "path";
+var ToolExecutor = class {
+  #cwd;
+  #client;
+  constructor(cwd, client) {
+    this.#cwd = cwd;
+    this.#client = client;
+  }
+  /**
+   * Route a Duo WorkflowToolAction to the appropriate local handler.
+   * This is the main bridge entry point.
+   */
+  async executeAction(action) {
+    try {
+      if (action.runReadFile) {
+        return this.#read({
+          filePath: action.runReadFile.filepath,
+          offset: action.runReadFile.offset,
+          limit: action.runReadFile.limit
+        });
+      }
+      if (action.runReadFiles) {
+        return this.#readMultiple(action.runReadFiles.filepaths);
+      }
+      if (action.runWriteFile) {
+        return this.#write({
+          filePath: action.runWriteFile.filepath,
+          content: action.runWriteFile.contents
+        });
+      }
+      if (action.runEditFile) {
+        return this.#edit({
+          filePath: action.runEditFile.filepath,
+          oldString: action.runEditFile.oldString,
+          newString: action.runEditFile.newString
+        });
+      }
+      if (action.runShellCommand) {
+        return this.#bash({ command: action.runShellCommand.command });
+      }
+      if (action.runCommand) {
+        const parts = [action.runCommand.program];
+        if (action.runCommand.flags) parts.push(...action.runCommand.flags);
+        if (action.runCommand.arguments) parts.push(...action.runCommand.arguments);
+        return this.#bash({ command: parts.join(" ") });
+      }
+      if (action.runGitCommand) {
+        const cmd = action.runGitCommand.arguments ? `git ${action.runGitCommand.command} ${action.runGitCommand.arguments}` : `git ${action.runGitCommand.command}`;
+        return this.#bash({ command: cmd });
+      }
+      if (action.listDirectory) {
+        return this.#read({ filePath: action.listDirectory.directory });
+      }
+      if (action.grep) {
+        return this.#grep({
+          pattern: action.grep.pattern,
+          path: action.grep.search_directory,
+          caseInsensitive: action.grep.case_insensitive
+        });
+      }
+      if (action.findFiles) {
+        return this.#glob({ pattern: action.findFiles.name_pattern });
+      }
+      if (action.mkdir) {
+        return this.#mkdir(action.mkdir.directory_path);
+      }
+      if (action.runMCPTool) {
+        return this.#executeMcpTool(action.runMCPTool.name, action.runMCPTool.args);
+      }
+      if (action.runHTTPRequest) {
+        return this.#httpRequest(action.runHTTPRequest);
+      }
+      return { response: "", error: "Unknown tool action" };
+    } catch (err) {
+      return { response: "", error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  /**
+   * Execute an MCP tool by name (for runMCPTool actions).
+   * Routes to the appropriate handler based on tool name.
+   */
+  async #executeMcpTool(name, argsJson) {
+    const args = argsJson ? JSON.parse(argsJson) : {};
+    switch (name) {
+      case "bash":
+        return this.#bash(args);
+      case "read":
+        return this.#read(args);
+      case "edit":
+        return this.#edit(args);
+      case "write":
+        return this.#write(args);
+      case "glob":
+        return this.#glob(args);
+      case "grep":
+        return this.#grep(args);
+      default:
+        return { response: "", error: `Unknown MCP tool: ${name}` };
+    }
+  }
+  // ── Handlers ──────────────────────────────────────────────────────
+  async #bash(args) {
+    const cwd = args.workdir ? resolve(this.#cwd, args.workdir) : this.#cwd;
+    const timeout = args.timeout ?? 12e4;
+    return new Promise((res) => {
+      exec(args.command, { cwd, timeout, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+        const output = [stdout, stderr].filter(Boolean).join("\n");
+        if (error) {
+          res({ response: output, error: error.message });
+          return;
+        }
+        res({ response: output });
+      });
+    });
+  }
+  async #read(args) {
+    try {
+      const filepath = resolve(this.#cwd, args.filePath);
+      const info = await stat(filepath);
+      if (info.isDirectory()) {
+        const entries = await readdir(filepath, { withFileTypes: true });
+        const lines = entries.map((e) => e.isDirectory() ? `${e.name}/` : e.name);
+        return { response: lines.join("\n") };
+      }
+      const content = await readFile(filepath, "utf-8");
+      const allLines = content.split("\n");
+      const offset = Math.max((args.offset ?? 1) - 1, 0);
+      const limit = args.limit ?? 2e3;
+      const slice = allLines.slice(offset, offset + limit);
+      const numbered = slice.map((line, i) => `${offset + i + 1}: ${line}`);
+      return { response: numbered.join("\n") };
+    } catch (err) {
+      return { response: "", error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async #readMultiple(filepaths) {
+    const results = [];
+    for (const fp of filepaths) {
+      const result = await this.#read({ filePath: fp });
+      if (result.error) {
+        results.push(`--- ${fp} ---
+ERROR: ${result.error}`);
+      } else {
+        results.push(`--- ${fp} ---
+${result.response}`);
+      }
+    }
+    return { response: results.join("\n\n") };
+  }
+  async #edit(args) {
+    try {
+      const filepath = resolve(this.#cwd, args.filePath);
+      let content = await readFile(filepath, "utf-8");
+      if (args.replaceAll) {
+        if (!content.includes(args.oldString)) {
+          return { response: "", error: "oldString not found in content" };
+        }
+        content = content.replaceAll(args.oldString, args.newString);
+      } else {
+        const idx = content.indexOf(args.oldString);
+        if (idx === -1) {
+          return { response: "", error: "oldString not found in content" };
+        }
+        const secondIdx = content.indexOf(args.oldString, idx + 1);
+        if (secondIdx !== -1) {
+          return { response: "", error: "Found multiple matches for oldString. Provide more surrounding lines to identify the correct match." };
+        }
+        content = content.slice(0, idx) + args.newString + content.slice(idx + args.oldString.length);
+      }
+      await writeFile(filepath, content, "utf-8");
+      return { response: `Successfully edited ${args.filePath}` };
+    } catch (err) {
+      return { response: "", error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async #write(args) {
+    try {
+      const filepath = resolve(this.#cwd, args.filePath);
+      await fsMkdir(dirname(filepath), { recursive: true });
+      await writeFile(filepath, args.content, "utf-8");
+      return { response: `Successfully wrote ${args.filePath}` };
+    } catch (err) {
+      return { response: "", error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async #glob(args) {
+    const cwd = args.path ? resolve(this.#cwd, args.path) : this.#cwd;
+    return new Promise((res) => {
+      const command = process.platform === "win32" ? `dir /s /b "${args.pattern}"` : `find . -path "./${args.pattern}" -not -path "*/node_modules/*" -not -path "*/.git/*" 2>/dev/null | head -200`;
+      exec(command, { cwd, timeout: 3e4 }, (error, stdout) => {
+        if (error && !stdout) {
+          exec(`ls -1 ${args.pattern} 2>/dev/null | head -200`, { cwd, timeout: 3e4 }, (_err, out) => {
+            res({ response: out.trim() || "No matches found" });
+          });
+          return;
+        }
+        const lines = stdout.trim().split("\n").filter(Boolean);
+        res({ response: lines.length > 0 ? lines.join("\n") : "No matches found" });
+      });
+    });
+  }
+  async #grep(args) {
+    const cwd = args.path ? resolve(this.#cwd, args.path) : this.#cwd;
+    const caseFlag = args.caseInsensitive ? "--ignore-case" : "";
+    return new Promise((res) => {
+      const includeFlag = args.include ? `--glob '${args.include}'` : "";
+      const escapedPattern = args.pattern.replace(/'/g, "'\\''");
+      const rgCommand = `rg --line-number --no-heading ${caseFlag} ${includeFlag} '${escapedPattern}' . 2>/dev/null | head -500`;
+      exec(rgCommand, { cwd, timeout: 3e4, maxBuffer: 5 * 1024 * 1024 }, (_error, stdout) => {
+        if (stdout.trim()) {
+          res({ response: stdout.trim() });
+          return;
+        }
+        const grepCaseFlag = args.caseInsensitive ? "-i" : "";
+        const grepInclude = args.include ? `--include='${args.include}'` : "";
+        const grepCommand = `grep -rn ${grepCaseFlag} ${grepInclude} '${escapedPattern}' . 2>/dev/null | head -500`;
+        exec(grepCommand, { cwd, timeout: 3e4, maxBuffer: 5 * 1024 * 1024 }, (_err, out) => {
+          res({ response: out.trim() || "No matches found" });
+        });
+      });
+    });
+  }
+  async #mkdir(directoryPath) {
+    try {
+      const filepath = resolve(this.#cwd, directoryPath);
+      await fsMkdir(filepath, { recursive: true });
+      return { response: `Created directory ${directoryPath}` };
+    } catch (err) {
+      return { response: "", error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async #httpRequest(args) {
+    if (!this.#client) {
+      return { response: "", error: "HTTP requests require GitLab client credentials" };
+    }
+    try {
+      const url = `${this.#client.instanceUrl}/api/v4/${args.path}`;
+      const headers = {
+        authorization: `Bearer ${this.#client.token}`
+      };
+      if (args.body) {
+        headers["content-type"] = "application/json";
+      }
+      const response = await fetch(url, {
+        method: args.method,
+        headers,
+        body: args.body ?? void 0
+      });
+      const text2 = await response.text();
+      if (!response.ok) {
+        return { response: text2, error: `HTTP ${response.status}: ${response.statusText}` };
+      }
+      return { response: text2 };
+    } catch (err) {
+      return { response: "", error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+};
+
 // src/workflow/session.ts
 var WorkflowSession = class {
   #client;
@@ -631,6 +892,8 @@ var WorkflowSession = class {
   #projectPath;
   #rootNamespaceId;
   #checkpoint = createCheckpointState();
+  #toolsConfig;
+  #toolExecutor;
   /** Mutex: serialises concurrent calls to runTurn so only one runs at a time. */
   #turnLock = Promise.resolve();
   constructor(client, modelId, cwd) {
@@ -638,6 +901,14 @@ var WorkflowSession = class {
     this.#tokenService = new WorkflowTokenService(client);
     this.#modelId = modelId;
     this.#cwd = cwd;
+    this.#toolExecutor = new ToolExecutor(cwd, client);
+  }
+  /**
+   * Opt-in: override the server-side system prompt and/or register MCP tools.
+   * When not called, the server uses its default prompt and built-in tools.
+   */
+  setToolsConfig(config) {
+    this.#toolsConfig = config;
   }
   get workflowId() {
     return this.#workflowId;
@@ -649,9 +920,9 @@ var WorkflowSession = class {
   }
   async *runTurn(goal, abortSignal) {
     await this.#turnLock;
-    let resolve;
+    let resolve2;
     this.#turnLock = new Promise((r) => {
-      resolve = r;
+      resolve2 = r;
     });
     const queue = new AsyncQueue();
     const socket = new WorkflowWebSocketClient({
@@ -679,6 +950,8 @@ var WorkflowSession = class {
         "x-gitlab-client-type": "node-websocket"
       });
       abortSignal?.addEventListener("abort", onAbort, { once: true });
+      const mcpTools = this.#toolsConfig?.mcpTools ?? [];
+      const preapprovedTools = mcpTools.map((t) => t.name);
       const sent = socket.send({
         startRequest: {
           workflowID: this.#workflowId,
@@ -689,9 +962,14 @@ var WorkflowSession = class {
             extended_logging: access?.workflow_metadata?.extended_logging ?? false
           }),
           clientCapabilities: [],
-          mcpTools: [],
+          mcpTools,
           additional_context: [],
-          preapproved_tools: []
+          preapproved_tools: preapprovedTools,
+          // Only include flowConfig when explicitly configured (opt-in prompt override)
+          ...this.#toolsConfig?.flowConfig ? {
+            flowConfig: this.#toolsConfig.flowConfig,
+            flowConfigSchemaVersion: this.#toolsConfig.flowConfigSchemaVersion ?? "v1"
+          } : {}
         }
       });
       if (!sent) throw new Error("failed to send workflow startRequest");
@@ -716,12 +994,13 @@ var WorkflowSession = class {
           continue;
         }
         if (!event.action.requestID) continue;
+        const result = await this.#toolExecutor.executeAction(event.action);
         socket.send({
           actionResponse: {
             requestID: event.action.requestID,
             plainTextResponse: {
-              response: "",
-              error: WORKFLOW_TOOL_ERROR_MESSAGE
+              response: result.response,
+              error: result.error ?? ""
             }
           }
         });
@@ -729,7 +1008,7 @@ var WorkflowSession = class {
     } finally {
       abortSignal?.removeEventListener("abort", onAbort);
       socket.close();
-      resolve();
+      resolve2();
     }
   }
   async #createWorkflow(goal) {
@@ -826,11 +1105,23 @@ var DuoWorkflowModel = class {
   supportedUrls = {};
   #client;
   #cwd;
+  #toolsConfig;
   constructor(modelId, client, cwd) {
     this.modelId = modelId;
     this.#client = client;
     this.#cwd = cwd ?? process.cwd();
   }
+  /**
+   * Opt-in: override the server-side system prompt and/or register MCP tools.
+   * When not called, the server uses its default prompt and built-in tools.
+   * Tool execution is always bridged locally regardless of this setting.
+   */
+  setToolsConfig(config) {
+    this.#toolsConfig = config;
+    for (const session of sessions.values()) {
+      session.setToolsConfig(config);
+    }
+  }
   async doGenerate(options) {
     const sessionID = readSessionID(options);
     if (!sessionID) throw new Error("missing workflow session ID");
@@ -928,6 +1219,7 @@ var DuoWorkflowModel = class {
     const existing = sessions.get(key);
     if (existing) return existing;
     const created = new WorkflowSession(this.#client, this.modelId, this.#cwd);
+    if (this.#toolsConfig) created.setToolsConfig(this.#toolsConfig);
     sessions.set(key, created);
     return created;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-gitlab-duo-agentic",
-  "version": "0.1.24",
+  "version": "0.2.2",
   "description": "OpenCode plugin and provider for GitLab Duo Agentic workflows",
   "license": "MIT",
   "type": "module",