jettypod 4.4.115 → 4.4.118

package/apps/dashboard/lib/session-stream-manager.ts

@@ -29,6 +29,12 @@ export type StreamStatus = 'idle' | 'connecting' | 'creating' | 'streaming' | 'd
 export interface SessionContext {
   workItemId: string;
   standalone: boolean;
+  conversational?: boolean;
+}
+
+export interface QueuedMessage {
+  message: string;
+  images?: AttachedImage[];
 }
 
 export interface StreamState {
@@ -40,6 +46,7 @@ export interface StreamState {
   isReconnecting: boolean;
   reconnectAttempt: number;
   narratedMode: boolean;
+  queuedMessage: QueuedMessage | null;
 }
 
 export interface StreamManagerCallbacks {
@@ -267,8 +274,12 @@ export class SessionStreamManager {
   private _reconnectAttempt: number = 0;
   private _narratedMode: boolean = true;
   private _pendingQuestion: ClaudeMessage | null = null;
+  private _queuedMessage: QueuedMessage | null = null;
   private _isFirstMessage: boolean = true;
 
+  // Notification batching — coalesces rapid state changes into one callback per frame
+  private _notifyPending: boolean = false;
+
   // Control
   private abortController: AbortController | null = null;
   private creatingStatusTimeout: ReturnType<typeof setTimeout> | null = null;
@@ -327,6 +338,27 @@ export class SessionStreamManager {
     return this._pendingQuestion;
   }
 
+  get queuedMessage(): QueuedMessage | null {
+    return this._queuedMessage;
+  }
+
+  /**
+   * Queue a message to be sent after the current stream completes.
+   * Only one message can be queued at a time (last one wins).
+   */
+  queueMessage(message: string, images?: AttachedImage[]): void {
+    this._queuedMessage = { message, images };
+    this.notifyStateChange();
+  }
+
+  /**
+   * Clear a queued message (e.g., if user stops the stream).
+   */
+  clearQueuedMessage(): void {
+    this._queuedMessage = null;
+    this.notifyStateChange();
+  }
+
   setNarratedMode(enabled: boolean): void {
     this._narratedMode = enabled;
     this.notifyStateChange();
@@ -351,6 +383,7 @@ export class SessionStreamManager {
       isReconnecting: this._isReconnecting,
       reconnectAttempt: this._reconnectAttempt,
       narratedMode: this._narratedMode,
+      queuedMessage: this._queuedMessage,
     };
   }
 
@@ -359,7 +392,20 @@ export class SessionStreamManager {
   // -------------------------------------------------------------------------
 
   private notifyStateChange(): void {
-    this.callbacks.onStateChange?.(this.getState());
+    if (!this._notifyPending) {
+      this._notifyPending = true;
+      const notify = () => {
+        this._notifyPending = false;
+        this.callbacks.onStateChange?.(this.getState());
+      };
+      // Batch rapid state changes (e.g., multiple stream events per frame) into one callback.
+      // requestAnimationFrame syncs with display refresh (~16ms); queueMicrotask as fallback.
+      if (typeof requestAnimationFrame !== 'undefined') {
+        requestAnimationFrame(notify);
+      } else {
+        queueMicrotask(notify);
+      }
+    }
   }
 
   setMessages(messages: ClaudeMessage[]): void {
@@ -401,6 +447,11 @@ export class SessionStreamManager {
     // Check for gate markers in tool results and text content
     const gate = extractGateFromMessage(message);
     if (gate) {
+      // Skip if the previous gate has the same gateType (prevents duplicate consecutive cards)
+      const lastGate = [...this._messages].reverse().find(m => m.type === 'gate');
+      if (lastGate && lastGate.gateType === gate.gateType) {
+        return;
+      }
       // Add the gate message instead of (or in addition to) the raw message
       this._messages = [...this._messages, gate];
       this._narratedMode = true; // Auto-enable narrated mode on first gate
@@ -508,19 +559,25 @@ export class SessionStreamManager {
     };
     this.addMessage(userMessage);
 
-    // For first message in a new session, show "creating" status for 5 seconds
+    // For first message in a new session, show "creating" status
+    // Conversational sessions skip the 5s delay and go straight to streaming
     if (this._isFirstMessage) {
       this._isFirstMessage = false;
-      this._status = 'creating';
-      this.notifyStateChange();
-
-      // Transition to streaming after 5 seconds
-      this.creatingStatusTimeout = setTimeout(() => {
-        if (this._status === 'creating') {
-          this._status = 'streaming';
-          this.notifyStateChange();
-        }
-      }, 5000);
+      if (this.sessionContext.conversational) {
+        this._status = 'streaming';
+        this.notifyStateChange();
+      } else {
+        this._status = 'creating';
+        this.notifyStateChange();
+
+        // Transition to streaming after 5 seconds
+        this.creatingStatusTimeout = setTimeout(() => {
+          if (this._status === 'creating') {
+            this._status = 'streaming';
+            this.notifyStateChange();
+          }
+        }, 5000);
+      }
     } else {
       // Set status to streaming
       this._status = 'streaming';
@@ -541,7 +598,6 @@ export class SessionStreamManager {
         },
         body: JSON.stringify({
           message,
-          conversationHistory: this._messages.slice(0, -1), // Exclude the user message we just added
           images: images?.map(img => ({
             type: img.type,
             data: img.dataUrl,
@@ -667,6 +723,7 @@ export class SessionStreamManager {
     this._status = 'idle';
     this._isReconnecting = false;
     this._reconnectAttempt = 0;
+    this._queuedMessage = null; // Clear queue on stop
     this.notifyStateChange();
   }
 
@@ -681,6 +738,7 @@ export class SessionStreamManager {
     this._canRetry = false;
     this._isReconnecting = false;
     this._reconnectAttempt = 0;
+    this._queuedMessage = null;
     this.lastMessage = null;
     this.lastImages = undefined;
     this.notifyStateChange();
@@ -717,6 +775,11 @@ export class SessionStreamManager {
    * This adds the gate directly to the message list without parsing from stream text.
    */
   injectGate(gateType: string, gateData: Record<string, unknown> = {}): void {
+    // Skip if the previous gate has the same type (prevents duplicate consecutive cards)
+    const lastGate = [...this._messages].reverse().find(m => m.type === 'gate');
+    if (lastGate && lastGate.gateType === gateType) {
+      return;
+    }
     const gate: ClaudeMessage = {
       type: 'gate',
       gateType,

package/apps/dashboard/lib/tests.ts

@@ -12,6 +12,7 @@ export interface TestScenario {
   title: string;
   status: 'pass' | 'fail' | 'pending';
   duration: string;
+  lastRun: string | null;
   error?: string;
   failedStep?: string;
   steps: string[];
@@ -200,7 +201,7 @@ export function getTestDashboardData(): TestDashboardData {
   const featureFiles = getFeatureFiles(projectRoot);
 
   // Build a map of scenario name → latest DB result
-  let dbResults: Map<string, { status: string; duration_ms: number; error_message: string | null; failed_step: string | null }>;
+  let dbResults: Map<string, { status: string; duration_ms: number; error_message: string | null; failed_step: string | null; run_at: string }>;
   let lastRun: string | null = null;
   try {
     const rows = getLatestResults();
@@ -248,6 +249,7 @@ export function getTestDashboardData(): TestDashboardData {
         title: scenario.name,
         status,
         duration,
+        lastRun: result?.run_at || null,
         error,
         failedStep,
         steps: scenario.steps,

package/apps/dashboard/next.config.js

@@ -1,9 +1,5 @@
 const path = require('path');
 
-// Dashboard is at apps/dashboard, jettypod lib is at ../../lib relative to that
-// process.cwd() is the dashboard directory during build
-const jettypodLibPath = path.resolve(process.cwd(), '../../lib');
-
 /** @type {import('next').NextConfig} */
 const nextConfig = {
   // Externalize modules with native bindings or dynamic requires
@@ -19,21 +15,30 @@ const nextConfig = {
 
   webpack: (config, { isServer }) => {
     if (isServer) {
-      // Externalize the jettypod lib using absolute path resolution
       config.externals = config.externals || [];
-      config.externals.push(({ request, context }, callback) => {
-        // Externalize any require that goes to jettypod lib (dynamic requires)
+      config.externals.push(({ request }, callback) => {
+        // Externalize worktree-facade with RUNTIME path resolution.
+        // Uses 'var' external type so the path expression evaluates at runtime,
+        // not at build time (which would bake in the build machine's absolute path).
+        // Packaged app: JETTYPOD_RESOURCES_PATH/bin/lib/<module>
+        // Dev mode: process.cwd()/../../lib/<module>
         if (request && request.includes('lib/worktree-facade')) {
-          // Use absolute path to jettypod lib
           const moduleName = request.split('lib/')[1];
-          const absolutePath = path.join(jettypodLibPath, moduleName);
-          return callback(null, `commonjs ${absolutePath}`);
+          return callback(null,
+            `var require(process.env.JETTYPOD_RESOURCES_PATH ` +
+            `? require('path').join(process.env.JETTYPOD_RESOURCES_PATH, 'bin', 'lib', '${moduleName}') ` +
+            `: require('path').resolve(process.cwd(), '../../lib', '${moduleName}'))`
+          );
         }
-        // Externalize run-migrations.js - it uses dynamic require() to load
-        // migration files at runtime, which webpack replaces with a dead stub
+        // Externalize run-migrations.js with RUNTIME path resolution.
+        // It uses dynamic require() to load migration files, which webpack
+        // replaces with a dead stub if bundled.
+        // In both packaged and dev: process.cwd() is the dashboard dir,
+        // and run-migrations.js is at lib/run-migrations.js relative to it.
         if (request && request.includes('run-migrations')) {
-          const absolutePath = path.resolve(context || __dirname, request);
-          return callback(null, `commonjs ${absolutePath}`);
+          return callback(null,
+            `var require(require('path').join(process.cwd(), 'lib', 'run-migrations'))`
+          );
         }
         callback(undefined);
       });

package/apps/dashboard/package.json

@@ -18,7 +18,9 @@
     "electron:build:mac:universal": "npm run build && npx electron-builder --config electron-builder.config.js --mac --universal",
     "electron:build:win": "npm run build && npx electron-builder --config electron-builder.config.js --win",
     "electron:build:linux": "npm run build && npx electron-builder --config electron-builder.config.js --linux",
-    "electron:pack": "npm run build && npx electron-builder --config electron-builder.config.js --dir"
+    "electron:pack": "npm run build && npx electron-builder --config electron-builder.config.js --dir",
+    "upload:r2": "node scripts/upload-to-r2.js",
+    "electron:release": "npm run electron:build:mac && npm run upload:r2"
   },
   "dependencies": {
     "@dnd-kit/core": "^6.3.1",

package/apps/dashboard/scripts/upload-to-r2.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+/**
+ * Upload release artifacts to Cloudflare R2.
+ * Run after electron-builder: npm run upload:r2
+ *
+ * Requires CLOUDFLARE_API_TOKEN env var (or wrangler login).
+ * Uploads: latest-mac.yml, DMG, ZIP, and blockmap files.
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const BUCKET_NAME = 'jettypod-releases';
+const DIST_DIR = path.join(__dirname, '..', 'dist');
+
+// File patterns to upload
+const UPLOAD_PATTERNS = [
+  /^latest-mac\.yml$/,
+  /\.dmg$/,
+  /\.zip$/,
+  /\.blockmap$/,
+];
+
+function findArtifacts() {
+  if (!fs.existsSync(DIST_DIR)) {
+    console.error(`❌ dist/ directory not found at ${DIST_DIR}`);
+    console.error('Run electron:build first.');
+    process.exit(1);
+  }
+
+  const files = fs.readdirSync(DIST_DIR);
+  return files.filter((file) =>
+    UPLOAD_PATTERNS.some((pattern) => pattern.test(file))
+  );
+}
+
+function uploadFile(filename) {
+  const filePath = path.join(DIST_DIR, filename);
+  const stats = fs.statSync(filePath);
+  const sizeMB = (stats.size / (1024 * 1024)).toFixed(1);
+
+  console.log(`  Uploading ${filename} (${sizeMB} MB)...`);
+
+  try {
+    execSync(
+      `npx wrangler r2 object put "${BUCKET_NAME}/${filename}" --file="${filePath}" --remote`,
+      { stdio: 'pipe' }
+    );
+    console.log(`  ✅ ${filename}`);
+    return true;
+  } catch (error) {
+    console.error(`  ❌ Failed to upload ${filename}: ${error.message}`);
+    return false;
+  }
+}
+
+function main() {
+  console.log('🚀 Uploading release artifacts to R2...\n');
+
+  const artifacts = findArtifacts();
+  if (artifacts.length === 0) {
+    console.error('❌ No release artifacts found in dist/');
+    console.error('Expected: latest-mac.yml, .dmg, .zip, or .blockmap files');
+    process.exit(1);
+  }
+
+  console.log(`Found ${artifacts.length} artifact(s):\n`);
+
+  let success = 0;
+  let failed = 0;
+
+  for (const artifact of artifacts) {
+    if (uploadFile(artifact)) {
+      success++;
+    } else {
+      failed++;
+    }
+  }
+
+  console.log(`\n📦 Upload complete: ${success} uploaded, ${failed} failed`);
+
+  if (failed > 0) {
+    process.exit(1);
+  }
+}
+
+main();