haltija 1.1.21 → 1.2.2

package/apps/desktop/index.html

@@ -105,6 +105,6 @@
     </div>
   </div>
   
-  <script src="renderer.js"></script>
+  <script type="module" src="renderer.js"></script>
 </body>
 </html>

package/apps/desktop/main.js

@@ -13,7 +13,7 @@ const {
   BrowserWindow,
   session,
   ipcMain,
-  desktopCapturer,
+
   Menu,
   dialog,
   clipboard,
@@ -267,6 +267,7 @@ function createWindow() {
   mainWindow = new BrowserWindow({
     width: 1280,
     height: 900,
+    show: false, // Don't show until content is ready
     webPreferences: {
       preload: path.join(__dirname, 'preload.js'),
       nodeIntegration: false,
@@ -275,7 +276,12 @@ function createWindow() {
       webviewTag: true, // Enable <webview> tag
     },
     titleBarStyle: 'hiddenInset', // Minimal chrome on macOS
-    trafficLightPosition: { x: 12, y: 12 },
+    windowButtonPosition: { x: 12, y: 12 },
+  })
+
+  // Show window once shell UI is rendered (avoids flashing empty/intermediate states)
+  mainWindow.once('ready-to-show', () => {
+    mainWindow.show()
   })
 
   // Load the shell UI
@@ -652,10 +658,10 @@ function setupWebContentsInjection(wc) {
   })
 
   // Capture console messages from the webview
-  wc.on('console-message', (event, level, message, line, sourceId) => {
+  wc.on('console-message', (event) => {
     try {
-      const prefix = level === 2 ? 'WARN' : level === 3 ? 'ERROR' : 'LOG'
-      console.log(`[Webview ${prefix}] ${message}`)
+      const prefix = event.level === 2 ? 'WARN' : event.level === 3 ? 'ERROR' : 'LOG'
+      console.log(`[Webview ${prefix}] ${event.message}`)
     } catch (e) {
       // Ignore write errors when app is closing
     }
@@ -680,6 +686,14 @@ function setupWebContentsInjection(wc) {
       // Ignore errors when app is closing
     }
   })
+
+  // Handle beforeunload dialogs — allow navigation by default so agents aren't blocked.
+  // The component's dialog policy (configurable via /dialog/configure) controls this,
+  // but as a safety net, Electron's will-prevent-unload always allows navigation.
+  wc.on('will-prevent-unload', (event) => {
+    console.log('[Haltija Desktop] Preventing beforeunload block for:', wc.getURL())
+    event.preventDefault() // Tells Electron to proceed with navigation despite beforeunload
+  })
 }
 
 async function injectWidget(webContents) {
@@ -867,6 +881,133 @@ function setupScreenCapture() {
     }
   })
 
+  // Tab management — forwarded to renderer
+  ipcMain.handle('open-tab', async (event, url) => {
+    if (!mainWindow) return false
+    mainWindow.webContents.send('open-tab', { url })
+    return true
+  })
+
+  ipcMain.handle('close-tab', async (event, windowId) => {
+    if (!mainWindow) return false
+    mainWindow.webContents.send('close-tab', { windowId })
+    return true
+  })
+
+  ipcMain.handle('focus-tab', async (event, windowId) => {
+    if (!mainWindow) return false
+    mainWindow.webContents.send('focus-tab', { windowId })
+    return true
+  })
+
+  // Video capture — forwarded to renderer where MediaRecorder runs
+  // Widget (webview) → main → renderer → main → widget
+  // Main also provides media source ID from webContents (not available on webview DOM element)
+  ipcMain.handle('get-media-source-id', async (event, webContentsId) => {
+    try {
+      const { webContents } = require('electron')
+      const wc = webContents.fromId(webContentsId)
+      if (!wc) return null
+      // getMediaSourceId requires the requesting WebContents as argument —
+      // i.e. the renderer that will call getUserMedia with the returned ID
+      const requestingWc = event.sender
+      return wc.getMediaSourceId(requestingWc)
+    } catch (err) {
+      console.error('[Haltija Desktop] Failed to get media source ID:', err.message)
+      return null
+    }
+  })
+
+  // Video file streaming — renderer sends chunks, main writes to disk
+  const activeVideoFiles = new Map() // recordingId -> { fd, path, size }
+
+  ipcMain.handle('video-file-create', async () => {
+    try {
+      const dir = '/tmp/haltija-videos'
+      fs.mkdirSync(dir, { recursive: true })
+      const shortId = Math.random().toString(36).slice(2, 6)
+      const recordingId = `vid-${Date.now().toString(36)}-${shortId}`
+      const filepath = `${dir}/hj-${Date.now()}-${shortId}.webm`
+      const fd = fs.openSync(filepath, 'w')
+      activeVideoFiles.set(recordingId, { fd, path: filepath, size: 0 })
+      return { success: true, recordingId }
+    } catch (err) {
+      return { success: false, error: err.message }
+    }
+  })
+
+  ipcMain.on('video-file-chunk', (event, recordingId, buffer) => {
+    const file = activeVideoFiles.get(recordingId)
+    if (!file) return
+    try {
+      const data = Buffer.from(buffer)
+      fs.writeSync(file.fd, data)
+      file.size += data.length
+    } catch (err) {
+      console.error('[Haltija Desktop] Failed to write video chunk:', err.message)
+    }
+  })
+
+  ipcMain.handle('video-file-close', async (event, recordingId, duration) => {
+    const file = activeVideoFiles.get(recordingId)
+    if (!file) return { success: false, error: 'No active recording with that ID' }
+    try {
+      fs.closeSync(file.fd)
+      activeVideoFiles.delete(recordingId)
+      return { success: true, path: file.path, duration, size: file.size, format: 'webm' }
+    } catch (err) {
+      activeVideoFiles.delete(recordingId)
+      return { success: false, error: err.message }
+    }
+  })
+
+  // Video start/stop/status — forwarded to renderer where MediaRecorder runs
+  ipcMain.handle('video-start', async (event, opts) => {
+    if (!mainWindow) return { success: false, error: 'No main window' }
+    mainWindow.webContents.send('video-start', { ...opts, senderWebContentsId: event.sender.id })
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => resolve({ success: false, error: 'Video start timed out' }), 10000)
+      ipcMain.once('video-start-result', (_, result) => {
+        clearTimeout(timeout)
+        resolve(result)
+      })
+    })
+  })
+
+  ipcMain.handle('video-stop', async (event) => {
+    if (!mainWindow) return { success: false, error: 'No main window' }
+    mainWindow.webContents.send('video-stop', { senderWebContentsId: event.sender.id })
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => resolve({ success: false, error: 'Video stop timed out' }), 30000)
+      ipcMain.once('video-stop-result', (_, result) => {
+        clearTimeout(timeout)
+        resolve(result)
+      })
+    })
+  })
+
+  ipcMain.handle('video-status', async (event) => {
+    if (!mainWindow) return { recording: false }
+    mainWindow.webContents.send('video-status', { senderWebContentsId: event.sender.id })
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => resolve({ recording: false }), 5000)
+      ipcMain.once('video-status-result', (_, result) => {
+        clearTimeout(timeout)
+        resolve(result)
+      })
+    })
+  })
+
+  // Hard refresh — bypasses all caches (called from widget in webview)
+  ipcMain.handle('hard-refresh', async (event) => {
+    const wc = event.sender
+    if (wc) {
+      wc.reloadIgnoringCache()
+      return { success: true }
+    }
+    return { success: false, error: 'No webContents' }
+  })
+
   // Create a new agent tab (called from widget in webview)
   ipcMain.handle('open-agent-tab', async (event) => {
     if (!mainWindow) return { error: 'No window' }
@@ -1046,17 +1187,44 @@ async function startEmbeddedServer() {
 async function killZombieServer() {
   if (os.platform() === 'win32') return
 
-  try {
-    const { execSync } = require('child_process')
-    const pids = execSync(`lsof -ti:${HALTIJA_PORT} 2>/dev/null`, { encoding: 'utf-8' }).trim()
-    if (pids) {
-      console.log(`[Haltija Desktop] Killing zombie process(es) on port ${HALTIJA_PORT}: ${pids.replace(/\n/g, ', ')}`)
-      execSync(`lsof -ti:${HALTIJA_PORT} | xargs kill 2>/dev/null`, { encoding: 'utf-8' })
-      await new Promise(r => setTimeout(r, 1000))
+  const { execSync } = require('child_process')
+  
+  // Try up to 3 times to kill the process
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    try {
+      const pids = execSync(`lsof -ti:${HALTIJA_PORT} 2>/dev/null`, { encoding: 'utf-8' }).trim()
+      if (!pids) {
+        console.log(`[Haltija Desktop] Port ${HALTIJA_PORT} is free`)
+        return true
+      }
+      
+      console.log(`[Haltija Desktop] Attempt ${attempt}: Killing process(es) on port ${HALTIJA_PORT}: ${pids.replace(/\n/g, ', ')}`)
+      
+      // Use SIGTERM first, then SIGKILL if needed
+      const signal = attempt < 3 ? '' : '-9'
+      execSync(`lsof -ti:${HALTIJA_PORT} | xargs kill ${signal} 2>/dev/null`, { encoding: 'utf-8' })
+      
+      // Wait for process to die
+      await new Promise(r => setTimeout(r, 500 * attempt))
+      
+      // Check if port is now free
+      try {
+        execSync(`lsof -ti:${HALTIJA_PORT} 2>/dev/null`, { encoding: 'utf-8' })
+        // Still occupied, continue trying
+      } catch {
+        // No process found = success
+        console.log(`[Haltija Desktop] Port ${HALTIJA_PORT} freed successfully`)
+        return true
+      }
+    } catch {
+      // lsof found nothing = port is free
+      console.log(`[Haltija Desktop] Port ${HALTIJA_PORT} is free`)
+      return true
     }
-  } catch {
-    // No processes found or kill failed — proceed
   }
+  
+  console.error(`[Haltija Desktop] Warning: Could not free port ${HALTIJA_PORT} after 3 attempts`)
+  return false
 }
 
 async function ensureServer() {
@@ -1093,61 +1261,93 @@ async function ensureServer() {
   }
 }
 
-// App lifecycle
-app.whenReady().then(async () => {
-  // Start or connect to server first
-  const serverReady = await ensureServer()
+// Single-instance lock — prevent multiple Electron windows from launching
+const gotTheLock = app.requestSingleInstanceLock()
+
+if (!gotTheLock) {
+  console.log('[Haltija Desktop] Another instance is already running. Focusing existing window.')
+  app.quit()
+} else {
+  app.on('second-instance', () => {
+    // Focus the existing window when user tries to launch again
+    const win = BrowserWindow.getAllWindows()[0]
+    if (win) {
+      if (win.isMinimized()) win.restore()
+      win.focus()
+    }
+  })
 
-  if (!serverReady) {
-    console.error(
-      '[Haltija Desktop] Could not start server. Install bun: https://bun.sh',
-    )
-    // Continue anyway - user might start server manually
-  }
+  // App lifecycle
+  app.whenReady().then(async () => {
+    console.log('[Haltija Desktop] App ready, starting initialization...')
+    
+    try {
+      // Start or connect to server first
+      const serverReady = await ensureServer()
+
+      if (!serverReady) {
+        console.error(
+          '[Haltija Desktop] Could not start server. Install bun: https://bun.sh',
+        )
+        // Continue anyway - user might start server manually
+      }
 
-  setupMenu()
-  setupHeaderStripping()
-  setupWidgetInjection()
-  setupScreenCapture()
-  createWindow()
+      setupMenu()
+      setupHeaderStripping()
+      setupWidgetInjection()
+      setupScreenCapture()
+      
+      console.log('[Haltija Desktop] Creating main window...')
+      createWindow()
+      console.log('[Haltija Desktop] Window created successfully')
+    } catch (err) {
+      console.error('[Haltija Desktop] Fatal error during startup:', err)
+      // Still try to create a window so user sees something
+      try {
+        createWindow()
+      } catch (windowErr) {
+        console.error('[Haltija Desktop] Failed to create window:', windowErr)
+      }
+    }
 
-  // Check for Claude Desktop MCP setup (after window is ready)
-  if (!hasSkippedMcpSetup()) {
-    // Small delay to let window fully render
-    setTimeout(() => checkAndPromptMcpSetup(), 1500)
-  }
+    // Check for Claude Desktop MCP setup (after window is ready)
+    if (!hasSkippedMcpSetup()) {
+      // Small delay to let window fully render
+      setTimeout(() => checkAndPromptMcpSetup(), 1500)
+    }
 
-  app.on('activate', () => {
-    if (BrowserWindow.getAllWindows().length === 0) {
-      createWindow()
+    app.on('activate', () => {
+      if (BrowserWindow.getAllWindows().length === 0) {
+        createWindow()
+      }
+    })
+  })
+
+  app.on('window-all-closed', () => {
+    if (process.platform !== 'darwin') {
+      app.quit()
     }
   })
-})
 
-app.on('window-all-closed', () => {
-  if (process.platform !== 'darwin') {
-    app.quit()
-  }
-})
-
-app.on('will-quit', () => {
-  // Kill embedded server when app quits
-  if (embeddedServer) {
-    console.log('[Haltija Desktop] Stopping embedded server')
-    embeddedServer.kill()
-    embeddedServer = null
-  }
-})
-
-// Handle certificate errors (for self-signed certs in dev)
-app.on(
-  'certificate-error',
-  (event, webContents, url, error, certificate, callback) => {
-    if (url.startsWith('https://localhost')) {
-      event.preventDefault()
-      callback(true)
-    } else {
-      callback(false)
+  app.on('will-quit', () => {
+    // Kill embedded server when app quits
+    if (embeddedServer) {
+      console.log('[Haltija Desktop] Stopping embedded server')
+      embeddedServer.kill()
+      embeddedServer = null
     }
-  },
-)
+  })
+
+  // Handle certificate errors (for self-signed certs in dev)
+  app.on(
+    'certificate-error',
+    (event, webContents, url, error, certificate, callback) => {
+      if (url.startsWith('https://localhost')) {
+        event.preventDefault()
+        callback(true)
+      } else {
+        callback(false)
+      }
+    },
+  )
+}

package/apps/desktop/package.json

@@ -1,6 +1,6 @@
 {
   "name": "haltija-desktop",
-  "version": "1.1.18",
+  "version": "1.2.2",
   "description": "Haltija Desktop - God Mode Browser for AI Agents",
   "homepage": "https://github.com/tonioloewald/haltija",
   "author": {
@@ -24,7 +24,7 @@
   },
   "license": "Apache-2.0",
   "devDependencies": {
-    "electron": "^28.0.0",
+    "electron": "^40.6.1",
     "electron-builder": "^24.9.1"
   },
   "build": {
@@ -40,6 +40,9 @@
       "gatekeeperAssess": false,
       "entitlements": "entitlements.mac.plist",
       "entitlementsInherit": "entitlements.mac.plist",
+      "extendInfo": {
+        "CFBundleIconName": "AppIcon"
+      },
       "notarize": {
         "teamId": "TSAD7CQ4HH"
       },
@@ -83,7 +86,8 @@
       "index.html",
       "terminal.html",
       "styles.css",
-      "renderer.js"
+      "renderer.js",
+      "renderer/**/*.js"
     ],
     "extraResources": [
       {
@@ -101,6 +105,10 @@
       {
         "from": "resources/icon.svg",
         "to": "icon.svg"
+      },
+      {
+        "from": "resources/Assets.car",
+        "to": "Assets.car"
       }
     ],
     "asarUnpack": [

package/apps/desktop/preload.js

@@ -61,6 +61,23 @@ contextBridge.exposeInMainWorld('haltija', {
   // Navigation (from widget via main process) - uses renderer's smart navigate with fallback
   onNavigateUrl: (callback) => ipcRenderer.on('navigate-url', (event, data) => callback(data)),
   
+  // Tab management from widget (via main process)
+  onOpenTab: (callback) => ipcRenderer.on('open-tab', (event, data) => callback(data)),
+  onCloseTab: (callback) => ipcRenderer.on('close-tab', (event, data) => callback(data)),
+  onFocusTab: (callback) => ipcRenderer.on('focus-tab', (event, data) => callback(data)),
+
+  // Video capture — renderer streams chunks directly to disk via main process
+  getMediaSourceId: (webContentsId) => ipcRenderer.invoke('get-media-source-id', webContentsId),
+  videoFileCreate: () => ipcRenderer.invoke('video-file-create'),
+  videoFileChunk: (recordingId, buffer) => ipcRenderer.send('video-file-chunk', recordingId, buffer),
+  videoFileClose: (recordingId, duration) => ipcRenderer.invoke('video-file-close', recordingId, duration),
+  onVideoStart: (callback) => ipcRenderer.on('video-start', (event, data) => callback(data)),
+  onVideoStop: (callback) => ipcRenderer.on('video-stop', (event, data) => callback(data)),
+  onVideoStatus: (callback) => ipcRenderer.on('video-status', (event, data) => callback(data)),
+  videoStartResult: (result) => ipcRenderer.send('video-start-result', result),
+  videoStopResult: (result) => ipcRenderer.send('video-stop-result', result),
+  videoStatusResult: (result) => ipcRenderer.send('video-status-result', result),
+  
   // Window management
   closeWindow: () => ipcRenderer.send('close-window'),
 })

package/apps/desktop/renderer/agent-status.js

@@ -0,0 +1,210 @@
+/**
+ * Agent status bar — WebSocket connection, status rendering, memos panel.
+ */
+
+import { tabs, el, getServerUrl } from './state.js'
+import { escapeHtml, createFloatPanel } from './ui-utils.js'
+
+let agentStatusWs = null
+let connectedShells = new Map()
+
+// Exposed so tabs.js can check it
+window._currentStatusLine = ''
+
+function connectAgentStatusWs() {
+  if (agentStatusWs && agentStatusWs.readyState === WebSocket.OPEN) return
+
+  const wsUrl = `ws://localhost:${window.haltija?.port || 8700}/ws/terminal`
+  agentStatusWs = new WebSocket(wsUrl)
+
+  agentStatusWs.onopen = () => {
+    console.log('[Agent Status] Connected to terminal WebSocket')
+  }
+
+  agentStatusWs.onmessage = (event) => {
+    try {
+      const msg = JSON.parse(event.data)
+      handleAgentStatusMessage(msg)
+    } catch (err) { /* Ignore non-JSON */ }
+  }
+
+  agentStatusWs.onclose = () => {
+    console.log('[Agent Status] WebSocket closed, reconnecting in 3s...')
+    setTimeout(connectAgentStatusWs, 3000)
+  }
+
+  agentStatusWs.onerror = () => {}
+}
+
+function handleAgentStatusMessage(msg) {
+  switch (msg.type) {
+    case 'status':
+      window._currentStatusLine = msg.line || ''
+      renderAgentStatusBar(window._currentStatusLine)
+      break
+    case 'shell-joined':
+      connectedShells.set(msg.shellId, { name: msg.name, isAgent: msg.name?.includes('agent') })
+      updateAgentSelector()
+      break
+    case 'shell-left':
+      connectedShells.delete(msg.shellId)
+      updateAgentSelector()
+      break
+    case 'shell-renamed':
+      if (connectedShells.has(msg.shellId)) {
+        connectedShells.get(msg.shellId).name = msg.name
+        updateAgentSelector()
+      }
+      break
+  }
+}
+
+function renderAgentStatusBar(line) {
+  if (!line) {
+    el.agentStatusBar.classList.add('hidden')
+    return
+  }
+
+  // Only show for terminal tabs
+  const { getActiveTab } = window._tabs
+  const activeTab = getActiveTab()
+  if (activeTab && !activeTab.isTerminal) {
+    el.agentStatusBar.classList.add('hidden')
+    return
+  }
+
+  el.agentStatusBar.classList.remove('hidden')
+
+  const segments = line.split(' | ')
+  let html = ''
+
+  for (const segment of segments) {
+    const trimmed = segment.trim()
+    if (!trimmed) continue
+
+    let label = ''
+    let value = trimmed
+
+    if (trimmed.startsWith('hj ')) {
+      const rest = trimmed.substring(3)
+      const words = rest.split(' ')
+      if (words.length > 1 && /^(memos|board|tasks)$/.test(words[0])) {
+        label = words[0]
+        value = words.slice(1).join(' ')
+      } else {
+        label = 'hj'
+        value = rest
+      }
+    }
+
+    let cls = 'status-segment'
+    if (/fail|error|no browser/i.test(trimmed)) cls += ' error'
+    else if (/warn|blocked|pending/i.test(trimmed)) cls += ' alert'
+    else if (/ready|connected|pass|active/i.test(trimmed)) cls += ' ok'
+
+    html += `<div class="${cls}" data-segment="${escapeHtml(label || 'status')}">`
+    if (label) html += `<span class="label">${escapeHtml(label)}:</span>`
+    html += `<span class="value">${escapeHtml(value)}</span>`
+    html += `</div>`
+  }
+
+  el.agentStatusItems.innerHTML = html
+
+  el.agentStatusItems.querySelectorAll('.status-segment').forEach(seg => {
+    seg.addEventListener('click', (e) => {
+      handleStatusSegmentClick(seg.dataset.segment, e.target)
+    })
+  })
+}
+
+function handleStatusSegmentClick(segmentName, target) {
+  if (segmentName === 'memos') showMemosPanel(target)
+}
+
+async function showMemosPanel(target) {
+  const content = document.createElement('div')
+  content.className = 'memos-panel-content'
+  content.innerHTML = '<div class="loading">Loading memos...</div>'
+
+  const panel = createFloatPanel({ target, content, title: 'Memos', position: 's' })
+  if (!panel) return
+
+  try {
+    const resp = await fetch(`${getServerUrl()}/terminal/command`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ tool: 'tasks', command: 'board' })
+    })
+    const result = await resp.json()
+
+    if (result.boardJson?.items) {
+      renderMemosPanel(content, result.boardJson.items)
+    } else {
+      content.innerHTML = '<div class="empty">No memos</div>'
+    }
+  } catch (err) {
+    content.innerHTML = `<div class="error">Failed to load memos: ${escapeHtml(err.message)}</div>`
+  }
+}
+
+function renderMemosPanel(container, items) {
+  const columns = ['in_progress', 'blocked', 'queued', 'review']
+  const columnNames = {
+    in_progress: '\uD83D\uDD04 In Progress',
+    blocked: '\uD83D\uDEA7 Blocked',
+    queued: '\uD83D\uDCCB Queued',
+    review: '\uD83D\uDC40 Review'
+  }
+
+  let html = '<div class="memos-list">'
+
+  for (const col of columns) {
+    const colItems = items.filter(i => i.column === col)
+    if (colItems.length === 0) continue
+
+    html += `<div class="memos-column">
+      <div class="memos-column-header">${columnNames[col]} (${colItems.length})</div>`
+
+    for (const item of colItems) {
+      html += `<div class="memo-item" data-id="${item.id}">
+        <span class="memo-title">${escapeHtml(item.title)}</span>
+      </div>`
+    }
+
+    html += '</div>'
+  }
+
+  if (html === '<div class="memos-list">') {
+    html += '<div class="empty">No active memos</div>'
+  }
+
+  html += '</div>'
+  container.innerHTML = html
+}
+
+function updateAgentSelector() {
+  const agents = Array.from(connectedShells.entries())
+    .filter(([_, info]) => info.isAgent)
+
+  if (agents.length === 0) {
+    el.agentSelect.innerHTML = '<option value="">No agents</option>'
+  } else {
+    el.agentSelect.innerHTML = agents.map(([id, info]) =>
+      `<option value="${id}">${escapeHtml(info.name || id)}</option>`
+    ).join('')
+  }
+}
+
+export async function initAgentStatusBar() {
+  try {
+    const response = await fetch(`${getServerUrl()}/terminal/status`)
+    if (response.ok) {
+      const line = await response.text()
+      renderAgentStatusBar(line)
+    }
+  } catch (err) {
+    console.log('[Agent Status] Could not fetch initial status:', err.message)
+  }
+
+  connectAgentStatusWs()
+}