@axhub/genie 0.2.7 → 0.2.9

package/server/external-agent/ws.js

@@ -12,6 +12,7 @@ import {
 import {
   buildSessionRuntimeSnapshot,
   createSessionRuntimeSubscriptionKey,
+  seedSessionRuntimeSubscriptionSnapshot,
   subscribeToSessionRuntimeStateChanges
 } from '../session-core/runtimeState.js';
 import { SUPPORTED_PROVIDERS } from '../../shared/conversationEvents.js';
@@ -24,6 +25,7 @@ const INTEGRATION_PING_TIMEOUT_MS = 1500;
 const INTEGRATION_EDITOR_REQUEST_TIMEOUT_MS = 15000;
 const INTEGRATION_EDITOR_TYPE_PREFIX = 'integration.editor.';
 const INTEGRATION_EDITOR_RESULT_SUFFIX = '.result';
+const VALID_EDITING_STATES = Object.freeze(['editing', 'idle', 'completed', 'error']);
 const INTEGRATION_EDITOR_CAPABILITIES = Object.freeze({
   'integration.editor.snapshot.get': 'editor.snapshot',
   'integration.editor.nodes.list': 'editor.nodes.list',
@@ -38,6 +40,35 @@ const pendingIntegrationPings = new Map();
 const sessionStateSubscriptionsByWs = new Map();
 const sessionStateSubscribersByKey = new Map();
 
+// Editing state cache for resilience across connection drops
+const recentEditingStates = new Map();
+const EDITING_STATE_TTL_MS = 30 * 60 * 1000;
+const EDITING_STATE_CLEANUP_INTERVAL_MS = 5 * 60 * 1000;
+
+function cacheEditingState(channel, targetClientId, elementKey, state, taskRef) {
+  const key = `${channel}::${targetClientId}::${elementKey}`;
+  recentEditingStates.set(key, {
+    channel,
+    targetClientId,
+    elementKey,
+    state,
+    taskRef: taskRef || null,
+    updatedAt: Date.now(),
+  });
+}
+
+function cleanupExpiredEditingStates() {
+  const now = Date.now();
+  for (const [key, entry] of recentEditingStates.entries()) {
+    if (now - entry.updatedAt > EDITING_STATE_TTL_MS) {
+      recentEditingStates.delete(key);
+    }
+  }
+}
+
+const editingStateCleanupTimer = setInterval(cleanupExpiredEditingStates, EDITING_STATE_CLEANUP_INTERVAL_MS);
+editingStateCleanupTimer.unref?.();
+
 function sendJson(ws, payload) {
   if (ws.readyState === WebSocket.OPEN) {
     ws.send(JSON.stringify(payload));
@@ -258,6 +289,7 @@ async function handleAgentStateSubscribe(ws, data) {
   }
 
   const subscriptionKey = createSessionRuntimeSubscriptionKey(normalized.provider, normalized.sessionId);
+  seedSessionRuntimeSubscriptionSnapshot(subscriptionKey, snapshot);
   addSessionStateSubscription(ws, subscriptionKey);
 
   sendJson(ws, {
@@ -369,6 +401,7 @@ function buildEditorClientSummary(meta) {
   return {
     channel: meta.channel,
     clientId: meta.clientId,
+    source: meta.source || null,
     sessionId: meta.sessionId || null,
     pageUrl: meta.pageUrl || null,
     lastSeenAt: meta.lastSeenAt || null,
@@ -565,6 +598,7 @@ function validateIntegrationConnectPayload(payload) {
       role,
       channel,
       clientId,
+      source: normalizeNonEmptyString(payload.source) || null,
       pageUrl: normalizeNonEmptyString(payload.pageUrl) || null,
       sessionId: normalizeNonEmptyString(payload.sessionId) || null,
       capabilities: Array.isArray(payload.capabilities)
@@ -948,8 +982,12 @@ function validateEditorEditingSetPayload(payload) {
   }
 
   const state = normalizeNonEmptyString(payload.state);
-  if (state !== 'editing' && state !== 'idle') {
-    return { ok: false, code: 'INVALID_PAYLOAD', message: 'state must be editing or idle' };
+  if (!VALID_EDITING_STATES.includes(state)) {
+    return {
+      ok: false,
+      code: 'INVALID_PAYLOAD',
+      message: `state must be one of: ${VALID_EDITING_STATES.join(', ')}`
+    };
   }
 
   return validateEditorTargetPayload(payload, {
@@ -1137,6 +1175,24 @@ async function forwardIntegrationResponseToOrigin(data) {
     outgoingData?.type === 'integration.error'
     || isEditorResultMessageType(outgoingData?.type)
     || (outgoingData?.type === 'integration.ack' && pendingRequest.awaitResult !== true);
+
+  // Cache successful editing state changes for resilience
+  if (
+    outgoingData?.type === 'integration.editor.editing.result'
+    && isPlainObject(outgoingData?.payload)
+    && outgoingData.payload.applied === true
+    && pendingRequest.requestPayload
+  ) {
+    const rp = pendingRequest.requestPayload;
+    cacheEditingState(
+      rp.channel,
+      rp.targetClientId,
+      outgoingData.payload.elementKey || rp.elementKey,
+      outgoingData.payload.state,
+      outgoingData.payload.taskRef || rp.taskRef,
+    );
+  }
+
   if (isTerminal) {
     clearPendingIntegrationRequest(requestId);
   }
@@ -1173,7 +1229,11 @@ class ExternalAgentWebSocketWriter {
         requestId: this.requestId,
         provider: payload.provider || this.provider,
         sessionId,
-        ...buildSessionNavigation(sessionId)
+        ...buildSessionNavigation({
+          provider: payload.provider || this.provider,
+          sessionId,
+          projectPath: payload.projectPath || null
+        })
       });
       return;
     }

package/server/gemini-cli.js

@@ -4,15 +4,13 @@ import {
   getActiveAgentSessions,
   isAgentSessionActive
 } from './acp-runtime/index.js';
-import { GEMINI_MODELS } from '../shared/modelConstants.js';
 
 export async function queryGemini(command, options = {}, writer) {
   return executeAgentPrompt({
     agentKey: 'gemini',
     command,
     options: {
-      ...options,
-      model: options.model || GEMINI_MODELS.DEFAULT
+      ...options
     },
     writer
   });

package/server/index.js

@@ -96,7 +96,7 @@ async function getPty() {
 import fetch from 'node-fetch';
 import mime from 'mime-types';
 
-import { getProjects, getSessions, getSessionMessages, renameProject, deleteSession, deleteProject, addProjectManually, extractProjectDirectory, clearProjectDirectoryCache, clearProviderSessionLookupCaches, getGeminiSessionMessages } from './projects.js';
+import { getProjects, getProjectsList, getProjectDetails, getSessions, getSessionMessages, renameProject, deleteSession, deleteProject, addProjectManually, extractProjectDirectory, clearProjectDirectoryCache, clearProviderSessionLookupCaches, getGeminiSessionMessages } from './projects.js';
 import {
   executeAgentPrompt,
   getActiveAgentSessions,
@@ -113,8 +113,20 @@ import commandsRoutes from './routes/commands.js';
 import settingsRoutes from './routes/settings.js';
 import channelsRoutes from './routes/channels.js';
 import agentRoutes from './routes/agent.js';
-import projectsRoutes, { WORKSPACES_ROOT, validateWorkspacePath } from './routes/projects.js';
+import projectsRoutes, {
+  DEFAULT_WORKSPACES_ROOT,
+  HAS_WORKSPACES_ROOT_RESTRICTION,
+  WORKSPACES_ROOTS,
+  validateWorkspacePath
+} from './routes/projects.js';
+import {
+  UNIX_WORKSPACE_ROOTS,
+  buildWorkspaceRootSuggestions,
+  expandWorkspacePath,
+  shouldUseVirtualWorkspaceRoots
+} from './utils/workspaceRoots.js';
 import cliAuthRoutes, { detectProviderInstallationStatus } from './routes/cli-auth.js';
+import ccConnectRoutes from './routes/cc-connect.js';
 import userRoutes from './routes/user.js';
 import codexRoutes from './routes/codex.js';
 import opencodeRoutes from './routes/opencode.js';
@@ -138,6 +150,7 @@ const UPDATE_PACKAGE_NAME = process.env.UPDATE_PACKAGE_NAME || packageInfo.id ||
 const VERSION_CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
 let cachedSystemVersion = null;
 let cachedSystemVersionExpiresAt = 0;
+const WINDOWS_DRIVES_ROOT = '__windows_drives__';
 const RUNTIME_STATUS_PATH = (() => {
     if (process.env.AXHUB_GENIE_STATUS_PATH) {
         return process.env.AXHUB_GENIE_STATUS_PATH;
@@ -320,8 +333,8 @@ async function setupProjectsWatcher() {
                     clearProjectDirectoryCache();
                     clearProviderSessionLookupCaches();
 
-                    // Get updated projects list
-                    const updatedProjects = await getProjects(broadcastProgress);
+                    // Get updated lightweight projects list
+                    const updatedProjects = await getProjectsList(broadcastProgress);
 
                     // Notify all connected clients about the project changes
                     const changedProvider = filePath.startsWith(codexSessionsPath)
@@ -330,14 +343,21 @@ async function setupProjectsWatcher() {
                     const changedFileRoot = changedProvider === 'codex'
                         ? codexSessionsPath
                         : claudeProjectsPath;
+                    const normalizedRelativePath = path.relative(changedFileRoot, filePath);
+                    const changedPathSegments = normalizedRelativePath.split(path.sep).filter(Boolean);
+                    const affectedProjectName = changedProvider === 'claude'
+                        ? (changedPathSegments[0] || null)
+                        : null;
                     const updateMessage = JSON.stringify({
                         type: 'projects_updated',
                         projects: updatedProjects,
                         timestamp: new Date().toISOString(),
                         changeType: eventType,
-                        changedFile: path.relative(changedFileRoot, filePath),
+                        changedFile: normalizedRelativePath,
                         changedProvider,
-                        changedSessionId: extractSessionIdFromChangedFile(filePath)
+                        changedSessionId: extractSessionIdFromChangedFile(filePath),
+                        affectedProjectName,
+                        requiresDetailsRefresh: Boolean(affectedProjectName)
                     });
 
                     connectedClients.forEach(client => {
@@ -504,6 +524,7 @@ app.use('/api/channels', authenticateToken, channelsRoutes);
 
 // CLI Authentication API Routes (protected)
 app.use('/api/cli', authenticateToken, cliAuthRoutes);
+app.use('/api/cc-connect', authenticateToken, ccConnectRoutes);
 
 // User API Routes (protected)
 app.use('/api/user', authenticateToken, userRoutes);
@@ -633,6 +654,7 @@ app.post('/api/system/update', authenticateToken, async (req, res) => {
 
 app.get('/api/projects', authenticateToken, async (req, res) => {
     try {
+        res.setHeader('Deprecation', 'true');
         const projects = await getProjects(broadcastProgress);
         res.json(projects);
     } catch (error) {
@@ -640,6 +662,27 @@ app.get('/api/projects', authenticateToken, async (req, res) => {
     }
 });
 
+app.get('/api/projects/list', authenticateToken, async (req, res) => {
+    try {
+        const projects = await getProjectsList(broadcastProgress);
+        res.json(projects);
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+app.get('/api/projects/:projectName/details', authenticateToken, async (req, res) => {
+    try {
+        const project = await getProjectDetails(req.params.projectName);
+        res.json(project);
+    } catch (error) {
+        if (/Project not found/i.test(error.message)) {
+            return res.status(404).json({ error: error.message });
+        }
+        res.status(500).json({ error: error.message });
+    }
+});
+
 app.get('/api/projects/:projectName/sessions', authenticateToken, async (req, res) => {
     try {
         const { limit = 5, offset = 0 } = req.query;
@@ -743,16 +786,31 @@ app.post('/api/projects/create', authenticateToken, async (req, res) => {
     }
 });
 
-const expandWorkspacePath = (inputPath) => {
-    if (!inputPath) return inputPath;
-    if (inputPath === '~') {
-        return WORKSPACES_ROOT;
-    }
-    if (inputPath.startsWith('~/') || inputPath.startsWith('~\\')) {
-        return path.join(WORKSPACES_ROOT, inputPath.slice(2));
-    }
-    return inputPath;
-};
+async function listWindowsDrives() {
+    const checks = await Promise.all(
+        'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('').map(async (letter) => {
+            const drivePath = `${letter}:\\`;
+            try {
+                await fsPromises.access(drivePath, fs.constants.R_OK);
+                const stats = await fsPromises.stat(drivePath);
+                if (!stats.isDirectory()) {
+                    return null;
+                }
+
+                return {
+                    path: drivePath,
+                    name: drivePath,
+                    type: 'directory',
+                    isDrive: true
+                };
+            } catch (error) {
+                return null;
+            }
+        })
+    );
+
+    return checks.filter(Boolean);
+}
 
 // Browse filesystem endpoint for project suggestions - uses existing getFileTree
 app.get('/api/browse-filesystem', authenticateToken, async (req, res) => {
@@ -760,9 +818,47 @@ app.get('/api/browse-filesystem', authenticateToken, async (req, res) => {
         const { path: dirPath } = req.query;
         
         console.log('[API] Browse filesystem request for path:', dirPath);
-        console.log('[API] WORKSPACES_ROOT is:', WORKSPACES_ROOT);
+        console.log('[API] WORKSPACES_ROOTS are:', WORKSPACES_ROOTS.length > 0 ? WORKSPACES_ROOTS : '(unrestricted)');
+
+        if (process.platform === 'win32' && dirPath === WINDOWS_DRIVES_ROOT) {
+            const suggestions = await listWindowsDrives();
+            return res.json({
+                path: WINDOWS_DRIVES_ROOT,
+                displayPath: 'This PC',
+                suggestions,
+                platform: process.platform,
+                virtualRoot: 'windows-drives',
+                hasWorkspaceRootRestriction: HAS_WORKSPACES_ROOT_RESTRICTION,
+                allowedRoots: WORKSPACES_ROOTS
+            });
+        }
+
+        if (shouldUseVirtualWorkspaceRoots({ dirPath })) {
+            const suggestions = buildWorkspaceRootSuggestions({
+                allowedWorkspaceRoots: WORKSPACES_ROOTS,
+                homeDir: DEFAULT_WORKSPACES_ROOT,
+                platform: process.platform
+            }).filter((entry) => {
+                try {
+                    return fs.existsSync(entry.path);
+                } catch (error) {
+                    return false;
+                }
+            });
+
+            return res.json({
+                path: UNIX_WORKSPACE_ROOTS,
+                displayPath: 'Allowed workspace roots',
+                suggestions,
+                platform: process.platform,
+                virtualRoot: 'workspace-roots',
+                hasWorkspaceRootRestriction: HAS_WORKSPACES_ROOT_RESTRICTION,
+                allowedRoots: WORKSPACES_ROOTS
+            });
+        }
+
         // Default to home directory if no path provided
-        const defaultRoot = WORKSPACES_ROOT;
+        const defaultRoot = DEFAULT_WORKSPACES_ROOT;
         let targetPath = dirPath ? expandWorkspacePath(dirPath) : defaultRoot;
         
         // Resolve and normalize the path
@@ -826,7 +922,12 @@ app.get('/api/browse-filesystem', authenticateToken, async (req, res) => {
         
         res.json({
             path: resolvedPath,
-            suggestions: suggestions
+            displayPath: resolvedPath,
+            suggestions: suggestions,
+            platform: process.platform,
+            virtualRoot: null,
+            hasWorkspaceRootRestriction: HAS_WORKSPACES_ROOT_RESTRICTION,
+            allowedRoots: WORKSPACES_ROOTS
         });
         
     } catch (error) {

package/server/openai-codex.js

@@ -4,15 +4,13 @@ import {
   getActiveAgentSessions,
   isAgentSessionActive
 } from './acp-runtime/index.js';
-import { CODEX_MODELS } from '../shared/modelConstants.js';
 
 export async function queryCodex(command, options = {}, writer) {
   return executeAgentPrompt({
     agentKey: 'codex',
     command,
     options: {
-      ...options,
-      model: options.model || CODEX_MODELS.DEFAULT
+      ...options
     },
     writer
   });

package/server/opencode-cli.js

@@ -4,7 +4,6 @@ import {
   getActiveAgentSessions,
   isAgentSessionActive
 } from './acp-runtime/index.js';
-import { OPENCODE_MODELS } from '../shared/modelConstants.js';
 import { spawnCommand } from './utils/spawnCommand.js';
 import { resolveWorkingDirectory } from './utils/defaultWorkingDirectory.js';
 
@@ -84,8 +83,7 @@ export async function queryOpencode(command, options = {}, writer) {
     agentKey: 'opencode',
     command,
     options: {
-      ...options,
-      model: options.model || OPENCODE_MODELS.DEFAULT
+      ...options
     },
     writer
   });