@forloop-cc/forloop-opencode-plugin-planner 2.2.5 → 2.2.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@forloop-cc/forloop-opencode-plugin-planner",
-  "version": "2.2.5",
+  "version": "2.2.7",
   "description": "ForLoop integration plugin for opencode — Sprint, story, and agent tools for the ForLoop platform",
   "type": "module",
   "license": "MIT",
@@ -24,6 +24,10 @@
     ".": {
       "import": "./plugins/forloop-plugin.ts",
       "types": "./plugins/forloop-plugin.ts"
+    },
+    "./exports": {
+      "import": "./plugins/exports.ts",
+      "types": "./plugins/exports.ts"
     }
   },
   "files": [

package/plugins/capabilities/api-client.ts

@@ -519,6 +519,19 @@ export class ForLoopAPIClient {
       body: JSON.stringify({ sprintId, sessionId }),
     });
   }
+
+  async sendStreamChunk(data: {
+    taskId: string;
+    trackingId: string;
+    sprintId: number;
+    chunk: string;
+    index: number;
+  }): Promise<any> {
+    return this.request('/api/opencode/agents/stream', {
+      method: 'POST',
+      body: JSON.stringify(data),
+    });
+  }
 }
 
 export interface AgentSuggestionRequest {

package/plugins/exports.ts

@@ -0,0 +1,14 @@
+// Re-exports for @forloop-cc/forloop-cli consumption.
+// These were moved out of forloop-plugin.ts because Bun's TypeScript
+// transpiler in opencode-ai@1.15.6 fails when a file has both
+// `export default async` and additional `export { }` / `export type { }` lines.
+export { ForLoopAPIClient } from './capabilities/api-client';
+export type { APIError, CreateStoryRequest, CreateSprintRequest, ListSprintsParams, SprintOptions } from './capabilities/api-client';
+export { getConfig, isLambdaExecution, PROD_API_URL, DEV_API_URL } from './capabilities/config';
+export type { ForLoopConfig } from './capabilities/config';
+export { getToken, setToken, clearToken } from './capabilities/token-storage';
+export type { TokenProfile } from './capabilities/token-storage';
+export { validateToken, detectTokenType } from './capabilities/auth';
+export type { TokenValidationResult } from './capabilities/auth';
+export { resolveSprintId, getCurrentBranch, resolveSprintFromBranch, getForloopRoot, getManifestPath } from './capabilities/context-resolver';
+export type { ContextResolution } from './capabilities/context-resolver';

package/plugins/forloop-plugin.ts

@@ -35,6 +35,7 @@ import {
   createFileListTool,
   createFileDeleteTool,
   createFileDownloadUrlTool,
+  createFileDownloadTool,
 } from './tools/file-tools';
 import {
   createScheduleTool,
@@ -66,6 +67,18 @@ import { createDeveloperStatusTool } from './tools/developer-status-tool';
 import { injectEnvironment } from './hooks/shell-env';
 import { createChatMessageHook, createEventHook } from './hooks/message-recorder';
 
+// Named re-exports — see plugins/exports.ts for details
+export { ForLoopAPIClient } from './capabilities/api-client';
+export type { APIError, CreateStoryRequest, CreateSprintRequest, ListSprintsParams, SprintOptions } from './capabilities/api-client';
+export { getConfig, isLambdaExecution, PROD_API_URL, DEV_API_URL } from './capabilities/config';
+export type { ForLoopConfig } from './capabilities/config';
+export { getToken, setToken, clearToken } from './capabilities/token-storage';
+export type { TokenProfile } from './capabilities/token-storage';
+export { validateToken, detectTokenType } from './capabilities/auth';
+export type { TokenValidationResult } from './capabilities/auth';
+export { resolveSprintId, getCurrentBranch, resolveSprintFromBranch, getForloopRoot, getManifestPath } from './capabilities/context-resolver';
+export type { ContextResolution } from './capabilities/context-resolver';
+
 export default async (ctx: any) => {
   const config = getConfig();
   const token = (await getToken()) || '';
@@ -123,7 +136,8 @@ export default async (ctx: any) => {
       'forloopFileUpload': createFileUploadTool(client),
       'forloopFileList': createFileListTool(client),
       'forloopFileDelete': createFileDeleteTool(client),
-      'forloopFileDownload': createFileDownloadUrlTool(client),
+      'forloopFileDownloadUrl': createFileDownloadUrlTool(client),
+      'forloopFileDownload': createFileDownloadTool(client),
       
       // Schedule Meetings
       'forloopScheduleCreate': createScheduleTool(client),
@@ -174,13 +188,3 @@ export default async (ctx: any) => {
   };
 };
 
-export { ForLoopAPIClient } from './capabilities/api-client';
-export type { APIError, CreateStoryRequest, CreateSprintRequest, ListSprintsParams, SprintOptions } from './capabilities/api-client';
-export { getConfig, isLambdaExecution, PROD_API_URL, DEV_API_URL } from './capabilities/config';
-export type { ForLoopConfig } from './capabilities/config';
-export { getToken, setToken, clearToken } from './capabilities/token-storage';
-export type { TokenProfile } from './capabilities/token-storage';
-export { validateToken, detectTokenType } from './capabilities/auth';
-export type { TokenValidationResult } from './capabilities/auth';
-export { resolveSprintId, getCurrentBranch, resolveSprintFromBranch, getForloopRoot, getManifestPath } from './capabilities/context-resolver';
-export type { ContextResolution } from './capabilities/context-resolver';

package/plugins/hooks/message-recorder.ts

@@ -49,8 +49,13 @@ async function recordAssistantMessage(
         await new Promise((resolve) => setTimeout(resolve, 600 * i));
       }
       const result = await client.recordMessage(data);
-      if (result?.message !== 'no matching user message to update') return;
-      console.log(`[ForLoop] Retry ${i + 1}/${attempts}: user row not found yet`);
+      // "no matching user message" is expected in Lambda — the server's
+      // handleAICallback creates the full Conversation record separately.
+      if (result?.message === 'no matching user message to update') {
+        console.log(`[ForLoop] No matching user message (expected in Lambda) — callback handles persistence`);
+        return;
+      }
+      return;
     } catch (err: any) {
       console.warn(`[ForLoop] Attempt ${i + 1}/${attempts} failed:`, err.message);
       if (i === attempts - 1) {
@@ -72,19 +77,26 @@ export function createChatMessageHook(client: ForLoopAPIClient) {
     const sprintId = readActiveSprintId();
     if (!sprintId) return;
 
+    const { sessionID, agent, model, messageID } = input;
+    const { message, parts } = output;
+    const content = extractTextFromParts(parts);
+
+    // Log incoming user message for debug visibility (Lambda)
+    if (content && messageID) {
+      console.log(`[ForLoop] REQUEST — user message (${content.length} chars)`, {
+        sprintId,
+        agent: agent || 'unknown',
+        sessionId: sessionID,
+        preview: content.substring(0, 300),
+      });
+    }
     // Only record on user's local machine; Lambda records via its own system
     if (isLambdaExecution()) return;
 
-    const { sessionID, agent, model, messageID } = input;
-
     // Only record messages with a model (indicates actual LLM processing,
     // not system events like context compaction or summary generation)
     if (!model || !model.providerID) return;
 
-    const { message, parts } = output;
-    const content = extractTextFromParts(parts);
-    if (!content) return;
-
     const conversationId = buildConversationId(sprintId, agent || 'unknown', sessionID);
 
     // Fire-and-forget: don't await - must not block the LLM from receiving the message
@@ -107,28 +119,23 @@ export function createChatMessageHook(client: ForLoopAPIClient) {
 export function createEventHook(client: ForLoopAPIClient) {
   const textBuffer = new Map<string, string>();
   const readyToStream = new Set<string>(); // messageIDs that have passed the context phase
+  const directSentText = new Map<string, string>(); // trackingId → last full text sent via direct HTTP
 
-  const writeStreamChunk = (sprintId: number, trackingId: string, taskId: string, text: string, done: boolean) => {
-    try {
-      const dir = '/tmp/forloop-stream';
-      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-      const filePath = path.join(dir, `sprint_${sprintId}.json`);
-      let data: Record<string, any> = {};
-      try { data = JSON.parse(fs.readFileSync(filePath, 'utf8')); } catch {}
-      const existing = data[trackingId] || { index: 0 };
-      data[trackingId] = {
-        trackingId,
-        taskId: taskId || '',
-        sprintId,
-        text,
-        index: existing.index + 1,
-        done,
-        lastUpdated: Date.now(),
-      };
-      fs.writeFileSync(filePath, JSON.stringify(data));
-    } catch (err: any) {
-      console.warn('[ForLoop] Failed to write stream chunk:', err.message);
-    }
+  const sendStreamDelta = (sprintId: number, trackingId: string, taskId: string, fullText: string) => {
+    const lastSent = directSentText.get(trackingId) || '';
+    if (!fullText || fullText.length <= lastSent.length) return;
+    const delta = fullText.startsWith(lastSent) ? fullText.substring(lastSent.length) : fullText;
+    if (!delta) return;
+    directSentText.set(trackingId, fullText);
+    client.sendStreamChunk({
+      taskId: taskId || '',
+      trackingId,
+      sprintId,
+      chunk: delta,
+      index: 0,
+    }).catch((err: Error) => {
+      console.warn('[ForLoop] Direct stream chunk failed:', err.message);
+    });
   };
 
   return async ({ event }: { event: { type: string; properties: any } }) => {
@@ -138,14 +145,15 @@ export function createEventHook(client: ForLoopAPIClient) {
     const trackingId = process.env.FORLOOP_TRACKING_ID;
     const taskId = process.env.FORLOOP_TASK_ID;
     const isLambda = isLambdaExecution();
+    const debugStream = process.env.FORLOOP_DEBUG_STREAM === 'true';
 
-    // Lambda with streaming: write chunks to file for parent process to poll
+    // Lambda with streaming: send chunks directly via HTTP
     if (isLambda && trackingId && process.env.FORLOOP_STREAM_ENABLED === 'true') {
       switch (event.type) {
         case 'message.part.updated': {
           const part = event.properties?.part;
           const messageID = part?.messageID || '';
-          console.error('[stream-event] message.part.updated', { type: part?.type, trackingId, sprintId, messageID });
+          if (debugStream) console.error('[stream-event] message.part.updated', { type: part?.type, trackingId, sprintId, messageID });
 
           // Skip non-text parts — but track that this messageID is now in "generation" phase
           if (!part || part.type !== 'text') {
@@ -160,7 +168,7 @@ export function createEventHook(client: ForLoopAPIClient) {
           // Also track that we've seen the context and subsequent text is streamable.
           const textLen = (part.text || '').length;
           if (!readyToStream.has(messageID) && textLen > 5000) {
-            console.error('[stream-event] skipping context text', { trackingId, messageID, textLen });
+            if (debugStream) console.error('[stream-event] skipping context text', { trackingId, messageID, textLen });
             readyToStream.add(messageID); // mark as past context
             break;
           }
@@ -168,8 +176,10 @@ export function createEventHook(client: ForLoopAPIClient) {
           readyToStream.add(messageID);
           const current = textBuffer.get(part.messageID) || '';
           textBuffer.set(part.messageID, part.text || current);
-          console.error('[stream-event] writing chunk', { trackingId, textLen });
-          writeStreamChunk(sprintId, trackingId, taskId || '', part.text || '', false);
+          if (debugStream) console.error('[stream-event] writing chunk', { trackingId, textLen });
+
+          // Send delta directly for real-time streaming (primary path)
+          sendStreamDelta(sprintId, trackingId, taskId || '', part.text || '');
           break;
         }
         case 'message.updated': {
@@ -177,7 +187,14 @@ export function createEventHook(client: ForLoopAPIClient) {
           if (!info || info.role !== 'assistant') break;
           const bufferedText = textBuffer.get(info.id);
           if (!bufferedText) break;
-          writeStreamChunk(sprintId, trackingId, taskId || '', bufferedText, true);
+
+          console.log(`[ForLoop] RESPONSE — planner message (${bufferedText.length} chars)`, {
+            sprintId,
+            trackingId,
+            sessionId: info.sessionID,
+            agent: info.agent || 'unknown',
+            preview: bufferedText.substring(0, 500),
+          });
 
           const conversationId = buildConversationId(
             sprintId,

package/plugins/tools/file-tools.ts

@@ -176,10 +176,10 @@ export function createFileDeleteTool(client: ForLoopAPIClient) {
 
 export function createFileDownloadUrlTool(client: ForLoopAPIClient) {
   return tool({
-    description: 'Get a download URL for a file',
+    description: 'Get a presigned download URL for a file (does not download the file itself)',
     args: {
       fileId: tool.schema.number()
-        .describe('File ID to download'),
+        .describe('File ID to get download URL for'),
     },
     async execute(args, _context) {
       const tokenResult = await validateToken();
@@ -189,10 +189,9 @@ export function createFileDownloadUrlTool(client: ForLoopAPIClient) {
       client.setToken?.(tokenResult.token);
 
       try {
-        // Log file read (tracks access)
-        await client.logFileRead(args.fileId);
+        // Fire-and-forget audit log — don't block download on audit failure
+        client.logFileRead(args.fileId).catch(() => {});
 
-        // Get download URL
         const download = await client.getFileDownloadUrl(args.fileId);
 
         return [
@@ -209,3 +208,59 @@ export function createFileDownloadUrlTool(client: ForLoopAPIClient) {
     },
   });
 }
+
+export function createFileDownloadTool(client: ForLoopAPIClient) {
+  return tool({
+    description: 'Download a sprint file by ID to the local sandbox',
+    args: {
+      fileId: tool.schema.number()
+        .describe('File ID to download (from forloopFileList)'),
+      destPath: tool.schema.string()
+        .optional()
+        .describe('Destination path relative to sandbox downloads dir (default: <filename>)'),
+    },
+    async execute(args, _context) {
+      const tokenResult = await validateToken();
+      if (!tokenResult.valid) {
+        return tokenResult.error ?? '❌ No API token configured.';
+      }
+      client.setToken?.(tokenResult.token);
+
+      try {
+        const open = await client.getFileOpenUrl(Number(args.fileId));
+        const url = String(open?.openUrl || open?.url || '');
+        if (!url) {
+          return `❌ Could not get download URL for file #${args.fileId}.`;
+        }
+
+        const response = await fetch(url);
+        if (!response.ok) {
+          return `❌ Download failed: HTTP ${response.status}`;
+        }
+
+        const buf = Buffer.from(await response.arrayBuffer());
+        const fileName = open?.originalName || open?.filename || `file-${args.fileId}`;
+        const downloadDir = path.join(process.env.HOME || '/tmp', 'downloads');
+        if (!fs.existsSync(downloadDir)) {
+          fs.mkdirSync(downloadDir, { recursive: true });
+        }
+
+        const destFile = args.destPath
+          ? path.join(downloadDir, args.destPath)
+          : path.join(downloadDir, fileName);
+        const destDir = path.dirname(destFile);
+        if (!fs.existsSync(destDir)) {
+          fs.mkdirSync(destDir, { recursive: true });
+        }
+        fs.writeFileSync(destFile, buf);
+
+        // Log file read (fire-and-forget audit)
+        client.logFileRead(args.fileId).catch(() => {});
+
+        return `✅ Downloaded file #${args.fileId} → ${destFile} (${buf.length} bytes)`;
+      } catch (error: any) {
+        return `❌ File download failed: ${error.message}`;
+      }
+    },
+  });
+}