opencode-gitlab-duo-agentic 0.1.3 → 0.1.5

package/dist/index.js

@@ -1179,6 +1179,20 @@ var TokenUsageEstimator = class {
   }
 };
 
+// src/provider/core/debug_log.ts
+import { appendFileSync, writeFileSync } from "fs";
+var LOG_PATH = "/tmp/duo-debug.log";
+function duoLog(...args) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+  const line = ts + " " + args.map(
+    (a) => typeof a === "object" && a !== null ? JSON.stringify(a) : String(a)
+  ).join(" ");
+  try {
+    appendFileSync(LOG_PATH, line + "\n");
+  } catch {
+  }
+}
+
 // src/provider/application/model.ts
 var GitLabDuoAgenticLanguageModel = class {
   specificationVersion = "v2";
@@ -1225,14 +1239,7 @@ var GitLabDuoAgenticLanguageModel = class {
     const workflowType = "chat";
     const promptText = extractLastUserText(options.prompt);
     const toolResults = extractToolResults(options.prompt);
-    console.warn("[duo-debug] doStream called", {
-      promptText: promptText?.slice(0, 80),
-      toolResultCount: toolResults.length,
-      hasStarted: this.#runtime.hasStarted,
-      lastSentPrompt: this.#lastSentPrompt?.slice(0, 80) ?? null,
-      pendingToolRequests: this.#pendingToolRequests.size,
-      sentToolCallIds: this.#sentToolCallIds.size
-    });
+    duoLog("--- doStream", "hasStarted=" + this.#runtime.hasStarted, "prompt=" + (promptText?.slice(0, 60) ?? "null"), "toolResults=" + toolResults.length);
     this.#runtime.resetMapperState();
     if (!this.#runtime.hasStarted) {
       this.#sentToolCallIds.clear();
@@ -1242,18 +1249,15 @@ var GitLabDuoAgenticLanguageModel = class {
         }
       }
       this.#lastSentPrompt = null;
-      console.warn("[duo-debug] hasStarted=false => reset sentToolCallIds, lastSentPrompt=null");
     }
     const freshToolResults = toolResults.filter((r) => !this.#sentToolCallIds.has(r.toolCallId));
-    console.warn("[duo-debug] freshToolResults:", freshToolResults.length);
     const modelRef = this.modelId === GITLAB_DUO_DEFAULT_MODEL_ID ? void 0 : this.modelId;
     this.#runtime.setSelectedModelIdentifier(modelRef);
     await this.#runtime.ensureConnected(promptText || "", workflowType);
-    console.warn("[duo-debug] ensureConnected returned OK");
     const mcpTools = this.#options.enableMcp === false ? [] : buildMcpTools(options);
     const toolContext = buildToolContext(mcpTools);
     const isNewUserMessage = promptText != null && promptText !== this.#lastSentPrompt;
-    console.warn("[duo-debug] isNewUserMessage:", isNewUserMessage, "promptText != null:", promptText != null, "promptText !== lastSentPrompt:", promptText !== this.#lastSentPrompt);
+    duoLog("gate", "isNewUserMessage=" + isNewUserMessage, "freshTools=" + freshToolResults.length, "lastSent=" + (this.#lastSentPrompt?.slice(0, 40) ?? "null"));
     let sentToolResults = false;
     if (freshToolResults.length > 0) {
       for (const result of freshToolResults) {
@@ -1300,7 +1304,6 @@ var GitLabDuoAgenticLanguageModel = class {
         this.#pendingToolRequests.delete(result.toolCallId);
       }
     }
-    console.warn("[duo-debug] startRequest gate: !sentToolResults:", !sentToolResults, "isNewUserMessage:", isNewUserMessage, "=> will send:", !sentToolResults && isNewUserMessage);
     if (!sentToolResults && isNewUserMessage) {
       const extraContext = [];
       if (toolContext) extraContext.push(toolContext);
@@ -1362,7 +1365,7 @@ var GitLabDuoAgenticLanguageModel = class {
           }
         });
       }
-      console.warn("[duo-debug] >>> calling sendStartRequest", { goal: promptText?.slice(0, 80), hasStarted: this.#runtime.hasStarted, extraContextCount: extraContext.length });
+      duoLog("sendStartRequest", "hasStarted=" + this.#runtime.hasStarted);
       this.#runtime.sendStartRequest(
         promptText,
         workflowType,
@@ -1371,15 +1374,13 @@ var GitLabDuoAgenticLanguageModel = class {
         extraContext
       );
       this.#lastSentPrompt = promptText;
-      console.warn("[duo-debug] >>> sendStartRequest completed, lastSentPrompt set");
       this.#usageEstimator.addInputChars(promptText);
       for (const ctx of extraContext) {
         if (ctx.content) this.#usageEstimator.addInputChars(ctx.content);
       }
     } else {
-      console.warn("[duo-debug] SKIPPED sendStartRequest (sentToolResults:", sentToolResults, "isNewUserMessage:", isNewUserMessage, ")");
+      duoLog("SKIP startRequest", "sentToolResults=" + sentToolResults, "isNewUserMessage=" + isNewUserMessage);
     }
-    console.warn("[duo-debug] creating event stream iterator");
     const iterator = this.#mapEventsToStream(this.#runtime.getEventStream());
     const stream = asyncIteratorToReadableStream(iterator);
     return {
@@ -1393,12 +1394,11 @@ var GitLabDuoAgenticLanguageModel = class {
     const state = { textStarted: false };
     const estimator = this.#usageEstimator;
     let eventCount = 0;
-    console.warn("[duo-debug] #mapEventsToStream: starting iteration");
     yield { type: "stream-start", warnings: [] };
     try {
       for await (const event of events) {
         eventCount++;
-        console.warn("[duo-debug] #mapEventsToStream event #" + eventCount + ":", event.type, event.type === "TEXT_CHUNK" ? "(len=" + event.content.length + ")" : "");
+        duoLog("evt", event.type, eventCount);
         if (event.type === "TEXT_CHUNK") {
           if (event.content.length > 0) {
             estimator.addOutputChars(event.content);
@@ -1444,11 +1444,11 @@ var GitLabDuoAgenticLanguageModel = class {
         }
       }
     } catch (streamErr) {
-      console.warn("[duo-debug] #mapEventsToStream: caught error after", eventCount, "events:", streamErr instanceof Error ? streamErr.message : String(streamErr));
+      duoLog("streamErr", streamErr instanceof Error ? streamErr.message : String(streamErr));
       yield { type: "error", error: streamErr instanceof Error ? streamErr : new Error(String(streamErr)) };
       return;
     }
-    console.warn("[duo-debug] #mapEventsToStream: loop ended normally after", eventCount, "events => yielding finish:stop");
+    duoLog("finish", "events=" + eventCount);
     yield { type: "finish", finishReason: "stop", usage: this.#currentUsage };
   }
   // ---------------------------------------------------------------------------
@@ -1873,6 +1873,7 @@ var GitLabAgenticRuntime = class {
   #mapper = new WorkflowEventMapper();
   #containerParams;
   #startRequestSent = false;
+  #connectingPromise;
   constructor(options, dependencies) {
     this.#options = options;
     this.#dependencies = dependencies;
@@ -1895,26 +1896,32 @@ var GitLabAgenticRuntime = class {
   // Connection lifecycle
   // ---------------------------------------------------------------------------
   async ensureConnected(goal, workflowType) {
-    console.warn("[duo-debug] ensureConnected called", {
-      hasStream: !!this.#stream,
-      hasWorkflowId: !!this.#workflowId,
-      workflowId: this.#workflowId?.slice(0, 12),
-      hasQueue: !!this.#queue,
-      startRequestSent: this.#startRequestSent
-    });
+    duoLog("ensureConnected", "stream=" + !!this.#stream, "wfId=" + !!this.#workflowId, "queue=" + !!this.#queue, "connecting=" + !!this.#connectingPromise);
+    if (this.#connectingPromise) {
+      duoLog("ensureConnected", "awaiting in-flight connection");
+      await this.#connectingPromise;
+      return;
+    }
     if (this.#stream && this.#workflowId && this.#queue) {
-      console.warn("[duo-debug] ensureConnected: short-circuit (already connected)");
+      duoLog("ensureConnected", "skip (connected)");
       return;
     }
+    this.#connectingPromise = this.#doConnect(goal, workflowType);
+    try {
+      await this.#connectingPromise;
+    } finally {
+      this.#connectingPromise = void 0;
+    }
+  }
+  async #doConnect(goal, workflowType) {
     if (!this.#containerParams) {
       this.#containerParams = await this.#resolveContainerParams();
     }
     if (!this.#workflowId) {
-      console.warn("[duo-debug] ensureConnected: creating new workflow");
       this.#workflowId = await this.#createWorkflow(goal, workflowType);
-      console.warn("[duo-debug] ensureConnected: workflow created:", this.#workflowId?.slice(0, 12));
+      duoLog("workflow created", this.#workflowId);
     } else {
-      console.warn("[duo-debug] ensureConnected: reusing existing workflowId:", this.#workflowId?.slice(0, 12));
+      duoLog("workflow reuse", this.#workflowId);
     }
     const token = await this.#dependencies.workflowService.getWorkflowToken(
       this.#options.instanceUrl,
@@ -1922,19 +1929,17 @@ var GitLabAgenticRuntime = class {
       workflowType
     );
     this.#workflowToken = token;
-    console.warn("[duo-debug] ensureConnected: got workflow token");
     const MAX_LOCK_RETRIES = 3;
     const LOCK_RETRY_DELAY_MS = 3e3;
     for (let attempt = 1; attempt <= MAX_LOCK_RETRIES; attempt++) {
       this.#queue = new AsyncQueue();
       try {
-        console.warn("[duo-debug] ensureConnected: connecting WebSocket (attempt", attempt, ")");
         await this.#connectWebSocket();
-        console.warn("[duo-debug] ensureConnected: WebSocket connected OK");
+        duoLog("ws connected", "attempt=" + attempt);
         return;
       } catch (err2) {
         const msg = err2 instanceof Error ? err2.message : String(err2);
-        console.warn("[duo-debug] ensureConnected: WebSocket error:", msg);
+        duoLog("ws error", msg);
         if ((msg.includes("1013") || msg.includes("lock")) && attempt < MAX_LOCK_RETRIES) {
           this.#resetStreamState();
           await this.#dependencies.clock.sleep(LOCK_RETRY_DELAY_MS);
@@ -1979,13 +1984,8 @@ var GitLabAgenticRuntime = class {
         preapproved_tools: preapprovedTools
       }
     };
-    console.warn("[duo-debug] sendStartRequest: writing to stream", {
-      workflowId: this.#workflowId?.slice(0, 12),
-      goal: goal?.slice(0, 80),
-      contextCount: additionalContext.length
-    });
-    const writeResult = this.#stream.write(startRequest);
-    console.warn("[duo-debug] sendStartRequest: write() returned:", writeResult);
+    const ok2 = this.#stream.write(startRequest);
+    duoLog("startReq write=" + ok2, "wf=" + this.#workflowId);
     this.#startRequestSent = true;
   }
   sendToolResponse(requestId, response, responseType) {
@@ -2074,14 +2074,14 @@ var GitLabAgenticRuntime = class {
   #bindStream(stream, queue) {
     const now = () => this.#dependencies.clock.now();
     const closeWithError = (message) => {
-      console.warn("[duo-debug] stream closeWithError:", message);
+      duoLog("streamErr", message);
       queue.push({ type: "ERROR", message, timestamp: now() });
       queue.close();
       this.#resetStreamState();
     };
     const handleAction = async (action) => {
       if (action.newCheckpoint) {
-        console.warn("[duo-debug] stream data: newCheckpoint status=", action.newCheckpoint.status, "goal=", action.newCheckpoint.goal?.slice(0, 40));
+        duoLog("checkpoint", action.newCheckpoint.status);
         const duoEvent = {
           checkpoint: action.newCheckpoint.checkpoint,
           errors: action.newCheckpoint.errors || [],
@@ -2089,7 +2089,7 @@ var GitLabAgenticRuntime = class {
           workflowStatus: action.newCheckpoint.status
         };
         const events = await this.#mapper.mapWorkflowEvent(duoEvent);
-        console.warn("[duo-debug] mapper produced", events.length, "events:", events.map((e) => e.type));
+        duoLog("mapped", events.length, events.map((e) => e.type).join(","));
         for (const event of events) {
           queue.push(event);
         }
@@ -2097,7 +2097,7 @@ var GitLabAgenticRuntime = class {
       }
       const toolRequest = mapWorkflowActionToToolRequest(action);
       if (toolRequest) {
-        console.warn("[duo-debug] stream data: toolRequest", toolRequest.toolName);
+        duoLog("toolReq", toolRequest.toolName);
         queue.push({
           type: "TOOL_REQUEST",
           ...toolRequest,
@@ -2105,7 +2105,6 @@ var GitLabAgenticRuntime = class {
         });
         return;
       }
-      console.warn("[duo-debug] stream data: unhandled action", Object.keys(action));
     };
     stream.on("data", (action) => {
       void handleAction(action).catch((error) => {
@@ -2114,11 +2113,10 @@ var GitLabAgenticRuntime = class {
       });
     });
     stream.on("error", (err2) => {
-      console.warn("[duo-debug] stream error:", err2.message);
       closeWithError(err2.message);
     });
     stream.on("end", () => {
-      console.warn("[duo-debug] stream end => closing queue + resetStreamState");
+      duoLog("stream end");
       queue.close();
       this.#resetStreamState();
     });
@@ -2140,7 +2138,7 @@ var GitLabAgenticRuntime = class {
     this.#bindStream(stream, this.#queue);
   }
   #resetStreamState() {
-    console.warn("[duo-debug] #resetStreamState called", { hadStream: !!this.#stream, hadQueue: !!this.#queue, workflowId: this.#workflowId?.slice(0, 12) });
+    duoLog("reset", "wf=" + this.#workflowId);
     this.#stream = void 0;
     this.#queue = void 0;
     this.#startRequestSent = false;

package/package.json

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