opencode-gitlab-duo-agentic 0.2.12 → 0.2.15

package/dist/index.js

@@ -547,24 +547,26 @@ var WORKFLOW_STATUS = {
 function isCheckpointAction(action) {
   return "newCheckpoint" in action && action.newCheckpoint != null;
 }
-var TURN_COMPLETE_STATUSES = /* @__PURE__ */ new Set([
-  WORKFLOW_STATUS.INPUT_REQUIRED,
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
   WORKFLOW_STATUS.FINISHED,
   WORKFLOW_STATUS.FAILED,
-  WORKFLOW_STATUS.STOPPED,
-  WORKFLOW_STATUS.PLAN_APPROVAL_REQUIRED,
-  WORKFLOW_STATUS.TOOL_CALL_APPROVAL_REQUIRED
+  WORKFLOW_STATUS.STOPPED
 ]);
-function isTurnComplete(status) {
-  return TURN_COMPLETE_STATUSES.has(status);
+function isTerminal(status) {
+  return TERMINAL_STATUSES.has(status);
 }
-var AWAITING_RESPONSE_STATUSES = /* @__PURE__ */ new Set([
-  WORKFLOW_STATUS.TOOL_CALL_APPROVAL_REQUIRED,
+var TURN_BOUNDARY_STATUSES = /* @__PURE__ */ new Set([
   WORKFLOW_STATUS.INPUT_REQUIRED,
   WORKFLOW_STATUS.PLAN_APPROVAL_REQUIRED
 ]);
-function isAwaitingResponse(status) {
-  return AWAITING_RESPONSE_STATUSES.has(status);
+function isTurnBoundary(status) {
+  return TURN_BOUNDARY_STATUSES.has(status);
+}
+function isToolApproval(status) {
+  return status === WORKFLOW_STATUS.TOOL_CALL_APPROVAL_REQUIRED;
+}
+function isTurnComplete(status) {
+  return isTerminal(status) || isTurnBoundary(status);
 }
 
 // src/workflow/websocket-client.ts
@@ -786,13 +788,11 @@ function mapActionToToolRequest(action) {
 
 // src/utils/debug-log.ts
 import { appendFileSync } from "fs";
-var LOG = "/tmp/duo-workflow-debug.log";
+var LOG_FILE = "/tmp/duo-workflow-debug.log";
 function dlog(msg) {
-  try {
-    appendFileSync(LOG, `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  appendFileSync(LOG_FILE, `[${ts}] ${msg}
 `);
-  } catch {
-  }
 }
 
 // src/workflow/session.ts
@@ -809,6 +809,7 @@ var WorkflowSession = class {
   #socket;
   #queue;
   #startRequestSent = false;
+  #pendingApproval = false;
   constructor(client, modelId, cwd) {
     this.#client = client;
     this.#tokenService = new WorkflowTokenService(client);
@@ -832,6 +833,7 @@ var WorkflowSession = class {
     this.#checkpoint = createCheckpointState();
     this.#tokenService.clear();
     this.#closeConnection();
+    this.#pendingApproval = false;
     this.#startRequestSent = false;
   }
   // ---------------------------------------------------------------------------
@@ -842,13 +844,30 @@ var WorkflowSession = class {
     if (!this.#workflowId) {
       this.#workflowId = await this.#createWorkflow(goal);
     }
+    const queue = new AsyncQueue();
+    this.#queue = queue;
+    await this.#connectSocket(queue);
+  }
+  /**
+   * Open a WebSocket and wire its callbacks to the given queue.
+   * Replaces any existing socket but does NOT create a new queue.
+   */
+  async #connectSocket(queue) {
     await this.#tokenService.get(this.#rootNamespaceId);
-    this.#queue = new AsyncQueue();
-    const queue = this.#queue;
     const socket = new WorkflowWebSocketClient({
       action: (action) => this.#handleAction(action, queue),
       error: (error) => queue.push({ type: "error", message: error.message }),
-      close: (_code, _reason) => queue.close()
+      close: (code, reason) => {
+        dlog(`ws-close: code=${code} reason=${reason} pendingApproval=${this.#pendingApproval}`);
+        this.#socket = void 0;
+        if (this.#pendingApproval) {
+          this.#pendingApproval = false;
+          this.#reconnectWithApproval(queue);
+        } else {
+          this.#queue = void 0;
+          queue.close();
+        }
+      }
     });
     const url = buildWebSocketUrl(this.#client.instanceUrl, this.#modelId);
     await socket.connect(url, {
@@ -891,7 +910,7 @@ var WorkflowSession = class {
    * Send a tool result back to DWS on the existing connection.
    */
   sendToolResult(requestId, output, error) {
-    dlog(`sendToolResult: reqId=${requestId} output=${output.length}b socket=${!!this.#socket}`);
+    dlog(`sendToolResult: reqId=${requestId} output=${output.length}b error=${error ?? "none"} socket=${!!this.#socket}`);
     if (!this.#socket) throw new Error("Not connected");
     this.#socket.send({
       actionResponse: {
@@ -924,12 +943,23 @@ var WorkflowSession = class {
   #handleAction(action, queue) {
     if (isCheckpointAction(action)) {
       const ckpt = action.newCheckpoint.checkpoint;
+      const status = action.newCheckpoint.status;
+      dlog(`checkpoint: status=${status} ckptLen=${ckpt.length}`);
       const deltas = extractAgentTextDeltas(ckpt, this.#checkpoint);
       for (const delta of deltas) {
         queue.push({ type: "text-delta", value: delta });
       }
+      if (deltas.length > 0) {
+        dlog(`checkpoint: ${deltas.length} text deltas`);
+      }
+      if (isToolApproval(status)) {
+        dlog(`checkpoint: TOOL_APPROVAL \u2192 pendingApproval=true (waiting for DWS close)`);
+        this.#pendingApproval = true;
+        return;
+      }
       const toolRequests = extractToolRequests(ckpt, this.#checkpoint);
       for (const req of toolRequests) {
+        dlog(`checkpoint: tool-request name=${req.toolName} reqId=${req.requestId}`);
         queue.push({
           type: "tool-request",
           requestId: req.requestId,
@@ -937,32 +967,74 @@ var WorkflowSession = class {
           args: req.args
         });
       }
-      const status = action.newCheckpoint.status;
-      if (isTurnComplete(status) && !isAwaitingResponse(status)) {
-        dlog(`action: checkpoint status=${status} CLOSE`);
+      if (isTurnComplete(status)) {
+        dlog(`checkpoint: turnComplete \u2192 close queue+connection`);
         queue.close();
         this.#closeConnection();
-      } else {
-        dlog(`action: checkpoint status=${status} KEEP-ALIVE`);
       }
       return;
     }
     const toolAction = action;
     const mapped = mapActionToToolRequest(toolAction);
     if (mapped) {
-      dlog(`action: standalone ${mapped.toolName} reqId=${mapped.requestId}`);
+      dlog(`standalone: ${mapped.toolName} reqId=${mapped.requestId} args=${JSON.stringify(mapped.args).slice(0, 200)}`);
       queue.push({
         type: "tool-request",
         requestId: mapped.requestId,
         toolName: mapped.toolName,
         args: mapped.args
       });
+    } else {
+      dlog(`standalone: UNMAPPED action keys=${Object.keys(action).join(",")}`);
     }
   }
   // ---------------------------------------------------------------------------
   // Private: connection management
   // ---------------------------------------------------------------------------
+  /**
+   * Auto-approve at DWS protocol level and reconnect.
+   *
+   * DWS closed the stream after TOOL_CALL_APPROVAL_REQUIRED. We open a new
+   * WebSocket, send startRequest with approval, and wire it to the SAME queue
+   * so Phase 3 in the model continues consuming events seamlessly.
+   *
+   * The actual tool execution still goes through OpenCode's permission system
+   * when the standalone action arrives on the new stream.
+   */
+  #reconnectWithApproval(queue) {
+    dlog(`reconnectWithApproval: starting (workflowId=${this.#workflowId})`);
+    this.#connectSocket(queue).then(() => {
+      if (!this.#socket || !this.#workflowId) {
+        dlog(`reconnectWithApproval: FAILED no socket/workflowId`);
+        queue.close();
+        return;
+      }
+      const mcpTools = this.#toolsConfig?.mcpTools ?? [];
+      dlog(`reconnectWithApproval: sending startRequest with approval (mcpTools=${mcpTools.length})`);
+      this.#socket.send({
+        startRequest: {
+          workflowID: this.#workflowId,
+          clientVersion: WORKFLOW_CLIENT_VERSION,
+          workflowDefinition: WORKFLOW_DEFINITION,
+          goal: "",
+          workflowMetadata: JSON.stringify({ extended_logging: false }),
+          clientCapabilities: ["shell_command"],
+          mcpTools,
+          additional_context: [],
+          preapproved_tools: mcpTools.map((t) => t.name),
+          approval: { approval: {} }
+        }
+      });
+      this.#startRequestSent = true;
+      dlog(`reconnectWithApproval: approval sent, waiting for standalone actions`);
+    }).catch((err) => {
+      dlog(`reconnectWithApproval: ERROR ${err instanceof Error ? err.message : String(err)}`);
+      this.#queue = void 0;
+      queue.close();
+    });
+  }
   #closeConnection() {
+    this.#pendingApproval = false;
     this.#socket?.close();
     this.#socket = void 0;
     this.#queue = void 0;
@@ -1451,10 +1523,7 @@ var DuoWorkflowModel = class {
             const freshResults = toolResults.filter(
               (r) => !model.#sentToolCallIds.has(r.toolCallId)
             );
-            dlog(`phase1: ${toolResults.length} total, ${freshResults.length} fresh, sentIds=${[...model.#sentToolCallIds].join(",")}`);
-            for (const r of toolResults) {
-              dlog(`  tr: id=${r.toolCallId} inSent=${model.#sentToolCallIds.has(r.toolCallId)} inPending=${model.#pendingToolRequests.has(r.toolCallId)} out=${r.output.length}b`);
-            }
+            dlog(`phase1: ${toolResults.length} total, ${freshResults.length} fresh`);
             let sentToolResults = false;
             for (const result of freshResults) {
               const hashIdx = result.toolCallId.indexOf("#");

package/package.json

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