@axhub/genie 0.1.2 → 0.1.3

package/server/opencode-sdk.js

@@ -0,0 +1,474 @@
+import { getOpencodeClient, resolveOpencodeModel } from './opencode-manager.js';
+
+const activeOpencodeSessions = new Map();
+
+function getEventSessionId(event) {
+  if (!event || typeof event !== 'object') return null;
+
+  const direct = event.sessionID || event.sessionId;
+  if (typeof direct === 'string' && direct.trim()) {
+    return direct.trim();
+  }
+
+  const props = event.properties || {};
+  const propId = props.sessionID || props.sessionId;
+  if (typeof propId === 'string' && propId.trim()) {
+    return propId.trim();
+  }
+
+  if (props.info && typeof props.info === 'object') {
+    const infoId = props.info.sessionID || props.info.sessionId;
+    if (typeof infoId === 'string' && infoId.trim()) {
+      return infoId.trim();
+    }
+  }
+
+  if (props.part && typeof props.part === 'object') {
+    const partId = props.part.sessionID || props.part.sessionId;
+    if (typeof partId === 'string' && partId.trim()) {
+      return partId.trim();
+    }
+  }
+
+  return null;
+}
+
+function toIso(value, fallback = null) {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return new Date(value).toISOString();
+  }
+
+  if (typeof value === 'string' && value.trim()) {
+    const parsed = Date.parse(value);
+    if (!Number.isNaN(parsed)) {
+      return new Date(parsed).toISOString();
+    }
+  }
+
+  return fallback;
+}
+
+function parsePermissionMode(permissionMode) {
+  switch (permissionMode) {
+    case 'acceptEdits':
+      return {
+        edit: 'allow',
+        bash: 'allow',
+        webfetch: 'allow'
+      };
+    case 'bypassPermissions':
+      return {
+        edit: 'allow',
+        bash: 'allow',
+        webfetch: 'allow',
+        external_directory: 'allow'
+      };
+    case 'default':
+    default:
+      return null;
+  }
+}
+
+function normalizeToolName(toolName = 'tool') {
+  if (toolName === 'bash') return 'Bash';
+  return toolName;
+}
+
+function mapPartToDelta(part, context) {
+  if (!part || typeof part !== 'object') return null;
+
+  const partId = part.id;
+  const messageId = part.messageID;
+
+  if (part.type === 'text') {
+    const currentText = typeof part.text === 'string' ? part.text : '';
+    const previousText = context.textPartCache.get(partId) || '';
+    let delta = currentText;
+
+    if (currentText.startsWith(previousText)) {
+      delta = currentText.slice(previousText.length);
+    }
+
+    context.textPartCache.set(partId, currentText);
+
+    if (!delta) {
+      return null;
+    }
+
+    return {
+      type: 'text_delta',
+      messageId,
+      partId,
+      delta,
+      timestamp: toIso(part.time?.start, new Date().toISOString())
+    };
+  }
+
+  if (part.type === 'reasoning') {
+    const currentText = typeof part.text === 'string' ? part.text : '';
+    const previousText = context.reasoningPartCache.get(partId) || '';
+    let delta = currentText;
+
+    if (currentText.startsWith(previousText)) {
+      delta = currentText.slice(previousText.length);
+    }
+
+    context.reasoningPartCache.set(partId, currentText);
+
+    if (!delta) {
+      return null;
+    }
+
+    return {
+      type: 'reasoning_delta',
+      messageId,
+      partId,
+      delta,
+      timestamp: toIso(part.time?.start, new Date().toISOString())
+    };
+  }
+
+  if (part.type === 'tool') {
+    const callId = part.callID || part.id;
+    const toolName = normalizeToolName(part.tool);
+    const state = part.state || {};
+
+    let toolInput = '';
+    if (state.input && typeof state.input === 'object') {
+      if (typeof state.input.command === 'string') {
+        toolInput = state.input.command;
+      } else {
+        try {
+          toolInput = JSON.stringify(state.input);
+        } catch {
+          toolInput = String(state.input);
+        }
+      }
+    }
+
+    let toolOutput = null;
+    if (state.output !== undefined && state.output !== null) {
+      toolOutput = typeof state.output === 'string' ? state.output : JSON.stringify(state.output);
+    } else if (state.metadata?.output !== undefined && state.metadata?.output !== null) {
+      toolOutput = typeof state.metadata.output === 'string'
+        ? state.metadata.output
+        : JSON.stringify(state.metadata.output);
+    }
+
+    return {
+      type: 'tool_update',
+      messageId,
+      partId,
+      toolCallId: callId,
+      toolName,
+      status: state.status || 'pending',
+      toolInput,
+      toolOutput,
+      exitCode: typeof state.metadata?.exit === 'number' ? state.metadata.exit : undefined,
+      timestamp: toIso(state.time?.start || part.time?.start, new Date().toISOString())
+    };
+  }
+
+  if (part.type === 'step-finish' && part.tokens) {
+    const input = Number(part.tokens.input || 0);
+    const output = Number(part.tokens.output || 0);
+    const reasoning = Number(part.tokens.reasoning || 0);
+    const cacheRead = Number(part.tokens.cache?.read || 0);
+    const cacheWrite = Number(part.tokens.cache?.write || 0);
+
+    return {
+      type: 'token_usage',
+      usage: {
+        used: input + output + reasoning + cacheRead + cacheWrite,
+        total: 0,
+        percentage: null,
+        unsupported: true,
+        message: 'OpenCode token total is unavailable from current event payload',
+        breakdown: {
+          input,
+          output,
+          reasoning,
+          cacheRead,
+          cacheCreation: cacheWrite
+        }
+      }
+    };
+  }
+
+  return null;
+}
+
+function sendMessage(ws, data) {
+  try {
+    if (ws.isSSEStreamWriter || ws.isWebSocketWriter) {
+      ws.send(data);
+    } else if (typeof ws.send === 'function') {
+      ws.send(JSON.stringify(data));
+    }
+  } catch (error) {
+    console.error('[OpenCode] Error sending message:', error);
+  }
+}
+
+function updateSessionId(session, ws, nextSessionId, broadcastUpdate = false) {
+  if (!nextSessionId || nextSessionId === session.sessionId) return;
+
+  const previousSessionId = session.sessionId;
+  session.sessionId = nextSessionId;
+
+  if (previousSessionId && activeOpencodeSessions.has(previousSessionId)) {
+    activeOpencodeSessions.delete(previousSessionId);
+  }
+
+  activeOpencodeSessions.set(nextSessionId, session);
+
+  if (ws?.setSessionId && typeof ws.setSessionId === 'function') {
+    ws.setSessionId(nextSessionId);
+  }
+
+  if (broadcastUpdate) {
+    sendMessage(ws, {
+      type: 'session-created',
+      sessionId: nextSessionId,
+      provider: 'opencode'
+    });
+  }
+}
+
+export async function queryOpencode(command, options = {}, ws) {
+  const {
+    sessionId,
+    cwd,
+    projectPath,
+    model,
+    permissionMode = 'default'
+  } = options;
+
+  const workingDirectory = cwd || projectPath || process.cwd();
+
+  let client;
+  let currentSessionId = sessionId;
+
+  const sessionState = {
+    sessionId: currentSessionId || null,
+    status: 'running',
+    startedAt: new Date().toISOString(),
+    abortController: new AbortController(),
+    textPartCache: new Map(),
+    reasoningPartCache: new Map()
+  };
+
+  try {
+    client = await getOpencodeClient({ directory: workingDirectory });
+
+    if (!currentSessionId) {
+      const created = await client.session.create({
+        query: { directory: workingDirectory },
+        body: {
+          title: 'OpenCode Session'
+        }
+      });
+
+      currentSessionId = created?.data?.id;
+      if (!currentSessionId) {
+        throw new Error('Failed to create OpenCode session');
+      }
+    }
+
+    sessionState.sessionId = currentSessionId;
+    activeOpencodeSessions.set(currentSessionId, sessionState);
+
+    if (ws?.setSessionId && typeof ws.setSessionId === 'function') {
+      ws.setSessionId(currentSessionId);
+    }
+
+    sendMessage(ws, {
+      type: 'session-created',
+      sessionId: currentSessionId,
+      provider: 'opencode'
+    });
+
+    const modelSelection = resolveOpencodeModel(model);
+    const permission = parsePermissionMode(permissionMode);
+
+    const events = await client.event.subscribe({
+      query: { directory: workingDirectory },
+      signal: sessionState.abortController.signal
+    });
+
+    await client.session.promptAsync({
+      path: { id: currentSessionId },
+      query: { directory: workingDirectory },
+      body: {
+        model: modelSelection,
+        permission: permission || undefined,
+        parts: [{
+          type: 'text',
+          text: command
+        }]
+      }
+    });
+
+    for await (const event of events.stream) {
+      if (!event || sessionState.status !== 'running') {
+        break;
+      }
+
+      const eventSessionId = getEventSessionId(event);
+      if (eventSessionId) {
+        updateSessionId(sessionState, ws, eventSessionId, true);
+        currentSessionId = sessionState.sessionId;
+      }
+
+      if (eventSessionId && currentSessionId && eventSessionId !== currentSessionId) {
+        continue;
+      }
+
+      if (event.type === 'server.connected') {
+        continue;
+      }
+
+      if (event.type === 'message.part.updated') {
+        const part = event.properties?.part;
+        const deltaEvent = mapPartToDelta(part, sessionState);
+        if (deltaEvent) {
+          sendMessage(ws, {
+            type: 'opencode-response',
+            data: deltaEvent,
+            sessionId: currentSessionId
+          });
+
+          if (deltaEvent.type === 'token_usage') {
+            sendMessage(ws, {
+              type: 'token-budget',
+              data: deltaEvent.usage,
+              sessionId: currentSessionId
+            });
+          }
+        }
+
+        continue;
+      }
+
+      if (event.type === 'message.updated') {
+        const info = event.properties?.info;
+        if (info?.error?.data?.message) {
+          sendMessage(ws, {
+            type: 'opencode-response',
+            data: {
+              type: 'error',
+              message: info.error.data.message
+            },
+            sessionId: currentSessionId
+          });
+        }
+        continue;
+      }
+
+      if (event.type === 'session.status') {
+        sendMessage(ws, {
+          type: 'opencode-response',
+          data: {
+            type: 'session_status',
+            status: event.properties?.status?.type || 'unknown'
+          },
+          sessionId: currentSessionId
+        });
+        continue;
+      }
+
+      if (event.type === 'session.error') {
+        sendMessage(ws, {
+          type: 'opencode-response',
+          data: {
+            type: 'error',
+            message: event.properties?.error?.data?.message || 'OpenCode session failed'
+          },
+          sessionId: currentSessionId
+        });
+        continue;
+      }
+
+      if (event.type === 'session.idle') {
+        break;
+      }
+    }
+
+    if (sessionState.status === 'running') {
+      sendMessage(ws, {
+        type: 'opencode-complete',
+        sessionId: currentSessionId,
+        actualSessionId: currentSessionId
+      });
+      sessionState.status = 'completed';
+    }
+  } catch (error) {
+    if (sessionState.status === 'aborted') {
+      sendMessage(ws, {
+        type: 'opencode-complete',
+        sessionId: currentSessionId,
+        actualSessionId: currentSessionId,
+        aborted: true
+      });
+    } else {
+      sendMessage(ws, {
+        type: 'opencode-error',
+        error: error.message,
+        sessionId: currentSessionId
+      });
+      sessionState.status = 'failed';
+    }
+  }
+}
+
+export function abortOpencodeSession(sessionId) {
+  const session = activeOpencodeSessions.get(sessionId);
+  if (!session) {
+    return false;
+  }
+
+  session.status = 'aborted';
+  try {
+    session.abortController.abort();
+  } catch {
+    // no-op
+  }
+
+  return true;
+}
+
+export function isOpencodeSessionActive(sessionId) {
+  const session = activeOpencodeSessions.get(sessionId);
+  return session?.status === 'running';
+}
+
+export function getActiveOpencodeSessions() {
+  const sessions = [];
+
+  for (const [id, session] of activeOpencodeSessions.entries()) {
+    if (session.status === 'running') {
+      sessions.push({
+        id,
+        status: session.status,
+        startedAt: session.startedAt
+      });
+    }
+  }
+
+  return sessions;
+}
+
+setInterval(() => {
+  const now = Date.now();
+  const maxAge = 30 * 60 * 1000;
+
+  for (const [id, session] of activeOpencodeSessions.entries()) {
+    if (session.status === 'running') continue;
+
+    const startedAt = new Date(session.startedAt).getTime();
+    if (now - startedAt > maxAge) {
+      activeOpencodeSessions.delete(id);
+    }
+  }
+}, 5 * 60 * 1000);
+

package/server/projects.js

@@ -66,6 +66,7 @@ import sqlite3 from 'sqlite3';
 import { open } from 'sqlite';
 import os from 'os';
 import { parseCodexTokenCountInfo } from './utils/codexTokenUsage.js';
+import { listOpencodeSessions, getOpencodeSessionMessages, deleteOpencodeSession } from './opencode-manager.js';
 
 // Import TaskMaster detection functions
 async function detectTaskMasterFolder(projectPath) {
@@ -467,6 +468,14 @@ async function getProjects(progressCallback = null) {
           project.codexSessions = [];
         }
 
+        // Also fetch OpenCode sessions for this project
+        try {
+          project.opencodeSessions = await getOpencodeSessions(actualProjectDir);
+        } catch (e) {
+          console.warn(`Could not load OpenCode sessions for project ${entry.name}:`, e.message);
+          project.opencodeSessions = [];
+        }
+
         // Add TaskMaster detection
         try {
           const taskMasterResult = await detectTaskMasterFolder(actualProjectDir);
@@ -535,7 +544,8 @@ async function getProjects(progressCallback = null) {
           isManuallyAdded: true,
           sessions: [],
           cursorSessions: [],
-          codexSessions: []
+          codexSessions: [],
+          opencodeSessions: []
         };
 
       // Try to fetch Cursor sessions for manual projects too
@@ -552,6 +562,13 @@ async function getProjects(progressCallback = null) {
         console.warn(`Could not load Codex sessions for manual project ${projectName}:`, e.message);
       }
 
+      // Try to fetch OpenCode sessions for manual projects too
+      try {
+        project.opencodeSessions = await getOpencodeSessions(actualProjectDir);
+      } catch (e) {
+        console.warn(`Could not load OpenCode sessions for manual project ${projectName}:`, e.message);
+      }
+
       // Add TaskMaster detection for manual projects
       try {
         const taskMasterResult = await detectTaskMasterFolder(actualProjectDir);
@@ -1063,6 +1080,20 @@ async function deleteProject(projectName, force = false) {
         console.warn('Failed to delete Codex sessions:', err.message);
       }
 
+      // Delete all OpenCode sessions associated with this project
+      try {
+        const opencodeSessions = await getOpencodeSessions(projectPath, { limit: 0 });
+        for (const session of opencodeSessions) {
+          try {
+            await deleteOpencodeSession(session.id, { directory: projectPath });
+          } catch (err) {
+            console.warn(`Failed to delete OpenCode session ${session.id}:`, err.message);
+          }
+        }
+      } catch (err) {
+        console.warn('Failed to delete OpenCode sessions:', err.message);
+      }
+
       // Delete Cursor sessions directory if it exists
       try {
         const hash = crypto.createHash('md5').update(projectPath).digest('hex');
@@ -1129,7 +1160,9 @@ async function addProjectManually(projectPath, displayName = null) {
     displayName: displayName || await generateDisplayName(projectName, absolutePath),
     isManuallyAdded: true,
     sessions: [],
-    cursorSessions: []
+    cursorSessions: [],
+    codexSessions: [],
+    opencodeSessions: []
   };
 }
 
@@ -1321,6 +1354,28 @@ async function getCodexSessions(projectPath, options = {}) {
   }
 }
 
+
+
+let opencodeDiscoveryUnavailable = false;
+
+async function getOpencodeSessions(projectPath, options = {}) {
+  const { limit = 5 } = options;
+
+  if (opencodeDiscoveryUnavailable) {
+    return [];
+  }
+
+  try {
+    const sessions = await listOpencodeSessions(projectPath, { limit });
+    opencodeDiscoveryUnavailable = false;
+    return sessions;
+  } catch (error) {
+    opencodeDiscoveryUnavailable = true;
+    console.error('Error fetching OpenCode sessions:', error.message);
+    return [];
+  }
+}
+
 // Parse a Codex session JSONL file to extract metadata
 async function parseCodexSessionFile(filePath) {
   try {
@@ -1622,6 +1677,17 @@ async function getCodexSessionMessages(sessionId, limit = null, offset = 0) {
   }
 }
 
+
+
+async function getOpencodeSessionMessagesFromManager(sessionId, options = {}) {
+  try {
+    return await getOpencodeSessionMessages(sessionId, options);
+  } catch (error) {
+    console.error(`Error reading OpenCode session messages for ${sessionId}:`, error);
+    return { messages: [], total: 0, hasMore: false };
+  }
+}
+
 async function deleteCodexSession(sessionId) {
   try {
     const codexSessionsDir = path.join(os.homedir(), '.codex', 'sessions');
@@ -1675,5 +1741,8 @@ export {
   clearProjectDirectoryCache,
   getCodexSessions,
   getCodexSessionMessages,
-  deleteCodexSession
+  deleteCodexSession,
+  getOpencodeSessions,
+  getOpencodeSessionMessagesFromManager,
+  deleteOpencodeSession
 };