@axhub/genie 0.2.7 → 0.2.8

package/server/acp-runtime/index.js

@@ -1,10 +1,4 @@
 import { resolveWorkingDirectory } from '../utils/defaultWorkingDirectory.js';
-import {
-  CLAUDE_MODELS,
-  CODEX_MODELS,
-  GEMINI_MODELS,
-  OPENCODE_MODELS
-} from '../../shared/modelConstants.js';
 import { AcpClient } from './client.js';
 import {
   findAcpSessionRecord,
@@ -54,16 +48,11 @@ function registerActiveClient(provider, sessionId, client) {
   return entry;
 }
 
-function resolveDefaultModel(agentKey, requestedModel) {
-  if (requestedModel) {
-    return requestedModel;
-  }
-
-  if (agentKey === 'claude') return CLAUDE_MODELS.DEFAULT;
-  if (agentKey === 'codex') return CODEX_MODELS.DEFAULT;
-  if (agentKey === 'gemini') return GEMINI_MODELS.DEFAULT;
-  if (agentKey === 'opencode') return OPENCODE_MODELS.DEFAULT;
-  return null;
+export function resolveDefaultModel(agentKey, requestedModel) {
+  const normalizedRequestedModel = typeof requestedModel === 'string'
+    ? requestedModel.trim()
+    : '';
+  return normalizedRequestedModel || null;
 }
 
 function unregisterActiveClient(provider, sessionId, client = null) {

package/server/channels/runtime/AgentRuntimeAdapter.js

@@ -1,4 +1,3 @@
-import { CODEX_MODELS, GEMINI_MODELS, OPENCODE_MODELS } from '../../../shared/modelConstants.js';
 import { executeAgentPrompt } from '../../acp-runtime/index.js';
 
 function normalizeBackend(backend) {
@@ -9,13 +8,6 @@ function normalizeBackend(backend) {
   return 'codex';
 }
 
-function getDefaultModel(backend) {
-  if (backend === 'codex') return CODEX_MODELS.DEFAULT;
-  if (backend === 'gemini') return GEMINI_MODELS.DEFAULT;
-  if (backend === 'opencode') return OPENCODE_MODELS.DEFAULT;
-  return undefined;
-}
-
 function createWriter(callbacks) {
   const state = {
     sessionId: null,
@@ -96,7 +88,6 @@ export async function runBackendSession({
   onError,
 }) {
   const resolvedBackend = normalizeBackend(backend);
-  const resolvedModel = model || getDefaultModel(resolvedBackend);
 
   const writer = createWriter({
     onSessionId,
@@ -108,7 +99,7 @@ export async function runBackendSession({
     projectPath,
     cwd: projectPath,
     sessionId: sessionId || undefined,
-    model: resolvedModel,
+    model: model || undefined,
     permissionMode: 'bypassPermissions',
     resume: !!sessionId,
     skipPermissions: true,

package/server/claude-sdk.js

@@ -5,15 +5,13 @@ import {
   isAgentSessionActive,
   resolveAgentPermission
 } from './acp-runtime/index.js';
-import { CLAUDE_MODELS } from '../shared/modelConstants.js';
 
 export async function queryClaudeSDK(command, options = {}, writer) {
   return executeAgentPrompt({
     agentKey: 'claude',
     command,
     options: {
-      ...options,
-      model: options.model || CLAUDE_MODELS.DEFAULT
+      ...options
     },
     writer
   });

package/server/cli.js

@@ -24,6 +24,10 @@ import {
     DEFAULT_WORKING_DIRECTORY_ENV,
     getConfiguredDefaultProjectPath,
 } from './utils/defaultWorkingDirectory.js';
+import {
+    getCcConnectConnectionSummary,
+    updateCcConnectPlatformBinding,
+} from './utils/ccConnectManager.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -374,6 +378,27 @@ function buildEditorErrorResponse({ requestId, channel = null, targetClientId =
     };
 }
 
+function buildCcConnectSuccessResponse({ command, platform = null, data = {} }) {
+    return {
+        ok: true,
+        command,
+        platform,
+        data,
+    };
+}
+
+function buildCcConnectErrorResponse({ command, platform = null, code, message }) {
+    return {
+        ok: false,
+        command,
+        platform,
+        error: {
+            code,
+            message,
+        },
+    };
+}
+
 function printJson(payload) {
     console.log(JSON.stringify(payload, null, 2));
 }
@@ -627,6 +652,96 @@ async function runEditorCommand(positionals, options) {
     }
 }
 
+function buildCcConnectCommand(positionals, options) {
+    const commandPath = positionals.join(' ');
+    const requestedPlatform = typeof options.platform === 'string' ? options.platform.trim() : '';
+
+    if (commandPath === 'cc-connect' || commandPath === 'cc-connect status') {
+        return {
+            command: 'cc-connect status',
+            action: 'status',
+            platform: requestedPlatform || null,
+        };
+    }
+
+    if (commandPath === 'cc-connect set') {
+        const platform = requireOption(options, 'platform', '--platform is required');
+        const provider = typeof options.provider === 'string' && options.provider.trim()
+            ? options.provider.trim()
+            : null;
+        const projectPath = typeof options.projectPath === 'string' && options.projectPath.trim()
+            ? path.resolve(options.projectPath)
+            : null;
+
+        if (!provider && !projectPath) {
+            throw new Error('At least one of --provider or --project-path is required.');
+        }
+
+        return {
+            command: 'cc-connect set',
+            action: 'set',
+            platform,
+            provider,
+            projectPath,
+        };
+    }
+
+    throw new Error(`Unknown cc-connect command: ${commandPath}`);
+}
+
+async function runCcConnectCommand(positionals, options) {
+    const command = buildCcConnectCommand(positionals, options);
+
+    try {
+        if (command.action === 'status') {
+            const summary = await getCcConnectConnectionSummary(command.platform);
+            const data = command.platform
+                ? {
+                    ccConnect: summary.ccConnect,
+                    providers: summary.providers,
+                    platform: summary.platform,
+                }
+                : {
+                    ccConnect: summary.ccConnect,
+                    providers: summary.providers,
+                    platforms: summary.platforms,
+                };
+
+            printJson(buildCcConnectSuccessResponse({
+                command: command.command,
+                platform: command.platform,
+                data,
+            }));
+            return;
+        }
+
+        if (command.action === 'set') {
+            const result = await updateCcConnectPlatformBinding({
+                platformId: command.platform,
+                provider: command.provider === null ? undefined : command.provider,
+                projectPath: command.projectPath === null ? undefined : command.projectPath,
+            });
+
+            printJson(buildCcConnectSuccessResponse({
+                command: command.command,
+                platform: result.platform,
+                data: result,
+            }));
+            return;
+        }
+
+        throw new Error(`Unsupported cc-connect action: ${command.action}`);
+    } catch (error) {
+        printJson(buildCcConnectErrorResponse({
+            command: command.command,
+            platform: command.platform || null,
+            code: error.code || 'CC_CONNECT_COMMAND_FAILED',
+            message: error.message,
+        }));
+        process.exit(1);
+    }
+}
+
 // Show status command
 function showStatus(options = {}) {
     const runtimeStatus = getRuntimeStatus();
@@ -754,6 +869,7 @@ Commands:
   start          Start the Axhub Genie server (default)
   stop           Stop the running Axhub Genie server
   status         Show configuration and data locations
+  cc-connect     Inspect or update platform connection bindings
   editor         Query or control a connected web editor frontend
   update         Update to the latest version
   help           Show this help information
@@ -769,9 +885,12 @@ Options:
   --json                      Output JSON (status or editor commands)
   --api-base <url>            Override API base URL for editor commands
   --api-key <key>             API key for /api/agent/ws editor commands
+  --platform <id>             Target platform for cc-connect commands
+  --provider <id>             Provider for cc-connect updates or editor task references
   --channel <name>            Integration channel for editor commands
   --target-client-id <id>     Target frontend client ID for editor commands
   --client-id <id>            Optional client filter for editor clients list
+  --project-path <path>       Project path for cc-connect platform binding updates
   --element-key <key>         Target element key for editor node commands
   --status <values>           Comma-separated status filters for editor nodes list
   --state <editing|idle>      Target editing state for editor editing set
@@ -790,6 +909,9 @@ Examples:
   $ axhub-genie stop                   # Stop running server
   $ axhub-genie status                 # Show configuration
   $ axhub-genie status --json          # Get machine-readable status
+  $ axhub-genie cc-connect status
+  $ axhub-genie cc-connect set --platform weixin --provider codex
+  $ axhub-genie cc-connect set --platform feishu --project-path /path/to/repo
   $ axhub-genie editor clients list --channel project-a
   $ axhub-genie editor snapshot --channel project-a --target-client-id figma-123
   $ axhub-genie editor nodes list --channel project-a --target-client-id figma-123 --status pending-dispatch,dirty
@@ -940,10 +1062,18 @@ function parseArgs(args) {
             parsed.options.apiKey = args[++i];
         } else if (arg.startsWith('--api-key=')) {
             parsed.options.apiKey = arg.split('=')[1];
+        } else if (arg === '--platform') {
+            parsed.options.platform = args[++i];
+        } else if (arg.startsWith('--platform=')) {
+            parsed.options.platform = arg.split('=')[1];
         } else if (arg === '--channel') {
             parsed.options.channel = args[++i];
         } else if (arg.startsWith('--channel=')) {
             parsed.options.channel = arg.split('=')[1];
+        } else if (arg === '--project-path') {
+            parsed.options.projectPath = args[++i];
+        } else if (arg.startsWith('--project-path=')) {
+            parsed.options.projectPath = arg.split('=')[1];
         } else if (arg === '--target-client-id') {
             parsed.options.targetClientId = args[++i];
         } else if (arg.startsWith('--target-client-id=')) {
@@ -1041,6 +1171,9 @@ async function main() {
         case 'editor':
             await runEditorCommand(positionals, options);
             break;
+        case 'cc-connect':
+            await runCcConnectCommand(positionals, options);
+            break;
         case 'status':
         case 'info':
             showStatus(options);
@@ -1078,6 +1211,9 @@ if (isDirectExecution) {
 }
 
 export {
+    buildCcConnectCommand,
+    buildCcConnectErrorResponse,
+    buildCcConnectSuccessResponse,
     buildEditorRequest,
     buildEditorSuccessResponse,
     buildEditorErrorResponse,

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

@@ -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;
@@ -504,6 +517,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);
@@ -743,16 +757,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 +789,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 +893,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
   });