opencode-gitlab-duo-agentic 0.2.18 → 0.2.21

package/dist/index.js

@@ -793,11 +793,16 @@ var WorkflowSession = class {
   #queue;
   #startRequestSent = false;
   #pendingApproval = false;
-  constructor(client, modelId, cwd) {
+  #onWorkflowCreated;
+  constructor(client, modelId, cwd, options) {
     this.#client = client;
     this.#tokenService = new WorkflowTokenService(client);
     this.#modelId = modelId;
     this.#cwd = cwd;
+    if (options?.existingWorkflowId) {
+      this.#workflowId = options.existingWorkflowId;
+    }
+    this.#onWorkflowCreated = options?.onWorkflowCreated;
   }
   /**
    * Opt-in: override the server-side system prompt and/or register MCP tools.
@@ -905,6 +910,25 @@ var WorkflowSession = class {
       }
     });
   }
+  /**
+   * Send an HTTP response back to DWS on the existing connection.
+   * Used for gitlab_api_request which requires httpResponse (not plainTextResponse).
+   */
+  sendHttpResult(requestId, statusCode, headers, body, error) {
+    dlog(`sendHttpResult: reqId=${requestId} status=${statusCode} body=${body.length}b error=${error ?? "none"} socket=${!!this.#socket}`);
+    if (!this.#socket) throw new Error("Not connected");
+    this.#socket.send({
+      actionResponse: {
+        requestID: requestId,
+        httpResponse: {
+          statusCode,
+          headers,
+          body,
+          error: error ?? ""
+        }
+      }
+    });
+  }
   /**
    * Wait for the next event from the session.
    * Returns null when the stream is closed (turn complete or connection lost).
@@ -948,6 +972,12 @@ var WorkflowSession = class {
       return;
     }
     const toolAction = action;
+    if (toolAction.runHTTPRequest && toolAction.requestID) {
+      dlog(`standalone: httpRequest ${toolAction.runHTTPRequest.method} ${toolAction.runHTTPRequest.path} reqId=${toolAction.requestID}`);
+      this.#executeHttpRequest(toolAction.requestID, toolAction.runHTTPRequest).catch(() => {
+      });
+      return;
+    }
     const mapped = mapActionToToolRequest(toolAction);
     if (mapped) {
       dlog(`standalone: ${mapped.toolName} reqId=${mapped.requestId} args=${JSON.stringify(mapped.args).slice(0, 200)}`);
@@ -962,6 +992,42 @@ var WorkflowSession = class {
     }
   }
   // ---------------------------------------------------------------------------
+  // Private: HTTP request handling (gitlab_api_request)
+  // ---------------------------------------------------------------------------
+  /**
+   * Execute a GitLab API request directly and send the response as httpResponse.
+   * DWS is the only action that expects httpResponse instead of plainTextResponse.
+   * Runs async in the background (fire-and-forget from #handleAction).
+   */
+  async #executeHttpRequest(requestId, request2) {
+    try {
+      const url = `${this.#client.instanceUrl}/api/v4/${request2.path}`;
+      dlog(`httpRequest: ${request2.method} ${request2.path} reqId=${requestId}`);
+      const init = {
+        method: request2.method,
+        headers: {
+          "authorization": `Bearer ${this.#client.token}`,
+          "content-type": "application/json"
+        }
+      };
+      if (request2.body) {
+        init.body = request2.body;
+      }
+      const response = await fetch(url, init);
+      const body = await response.text();
+      const headers = {};
+      response.headers.forEach((value, key) => {
+        headers[key] = value;
+      });
+      dlog(`httpRequest: ${request2.method} ${request2.path} \u2192 ${response.status} body=${body.length}b`);
+      this.sendHttpResult(requestId, response.status, headers, body);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      dlog(`httpRequest: ERROR ${request2.method} ${request2.path} \u2192 ${message}`);
+      this.sendHttpResult(requestId, 0, {}, "", message);
+    }
+  }
+  // ---------------------------------------------------------------------------
   // Private: connection management
   // ---------------------------------------------------------------------------
   /**
@@ -1027,7 +1093,9 @@ var WorkflowSession = class {
       const details = [created.message, created.error].filter(Boolean).join("; ");
       throw new Error(`failed to create workflow${details ? `: ${details}` : ""}`);
     }
-    return String(created.id);
+    const workflowId = String(created.id);
+    this.#onWorkflowCreated?.(workflowId);
+    return workflowId;
   }
   async #loadProjectContext() {
     if (this.#projectPath !== void 0) return;
@@ -1193,10 +1261,7 @@ function mapDuoToolRequest(toolName, args) {
   switch (toolName) {
     case "list_dir": {
       const directory = asString2(args.directory) ?? ".";
-      return {
-        toolName: "bash",
-        args: { command: `ls -la ${shellQuote(directory)}`, description: "List directory contents", workdir: "." }
-      };
+      return { toolName: "read", args: { filePath: directory } };
     }
     case "read_file": {
       const filePath = asString2(args.file_path) ?? asString2(args.filepath) ?? asString2(args.filePath) ?? asString2(args.path);
@@ -1408,6 +1473,39 @@ CODE QUALITY:
 </communication>
 </system-reminder>`;
 
+// src/workflow/session-store.ts
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function getStorePath() {
+  const dir = process.env.XDG_CACHE_HOME?.trim() ? join(process.env.XDG_CACHE_HOME, "opencode") : join(homedir(), ".cache", "opencode");
+  return join(dir, "duo-workflow-sessions.json");
+}
+function readStore() {
+  try {
+    return JSON.parse(readFileSync(getStorePath(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeStore(store) {
+  try {
+    const storePath = getStorePath();
+    mkdirSync(join(storePath, ".."), { recursive: true });
+    writeFileSync(storePath, JSON.stringify(store, null, 2), "utf8");
+  } catch {
+  }
+}
+function saveWorkflowId(key, workflowId) {
+  const store = readStore();
+  store[key] = workflowId;
+  writeStore(store);
+}
+function loadWorkflowId(key) {
+  const store = readStore();
+  return store[key];
+}
+
 // src/provider/duo-workflow-model.ts
 var sessions = /* @__PURE__ */ new Map();
 var UNKNOWN_USAGE = {
@@ -1685,7 +1783,17 @@ var DuoWorkflowModel = class {
     const key = sessionKey(this.#client.instanceUrl, this.modelId, sessionID);
     const existing = sessions.get(key);
     if (existing) return existing;
-    const created = new WorkflowSession(this.#client, this.modelId, this.#cwd);
+    const existingWorkflowId = loadWorkflowId(key);
+    if (existingWorkflowId) {
+      dlog(`resolveSession: restored workflowId=${existingWorkflowId} from disk for ${sessionID}`);
+    }
+    const created = new WorkflowSession(this.#client, this.modelId, this.#cwd, {
+      existingWorkflowId,
+      onWorkflowCreated: (workflowId) => {
+        dlog(`resolveSession: saving workflowId=${workflowId} for ${sessionID}`);
+        saveWorkflowId(key, workflowId);
+      }
+    });
     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.2.18",
+  "version": "0.2.21",
   "description": "OpenCode plugin and provider for GitLab Duo Agentic workflows",
   "license": "MIT",
   "type": "module",