@axhub/genie 0.2.7 → 0.2.8

package/server/routes/cli-auth.js

@@ -1,9 +1,9 @@
 import express from 'express';
-import { constants as fsConstants } from 'fs';
 import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
 import { listOpencodeModels } from '../opencode-cli.js';
+import { resolveCommandPath } from '../utils/resolveCommandPath.js';
 
 const router = express.Router();
 const INSTALLATION_CACHE_TTL_MS = 12 * 60 * 60 * 1000;
@@ -22,78 +22,6 @@ const PROVIDER_INSTALL_HINTS = {
 const installationStatusCache = new Map(); // provider -> status
 const installationStatusInFlight = new Map(); // provider -> Promise
 
-function getLocatorCommand() {
-  return process.platform === 'win32' ? 'where' : 'which';
-}
-
-async function isRunnableCommand(candidatePath) {
-  try {
-    if (process.platform === 'win32') {
-      await fs.access(candidatePath, fsConstants.F_OK);
-      return true;
-    }
-
-    await fs.access(candidatePath, fsConstants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function resolveCommandPath(command) {
-  const normalizedCommand = String(command || '').trim();
-  if (!normalizedCommand) {
-    return {
-      found: false,
-      resolvedPath: null,
-      reason: 'Command name is empty'
-    };
-  }
-
-  const isDirectPath = normalizedCommand.includes(path.sep) || (process.platform === 'win32' && normalizedCommand.includes('/'));
-  const pathEntries = isDirectPath
-    ? ['']
-    : String(process.env.PATH || '')
-      .split(path.delimiter)
-      .map((entry) => entry.trim())
-      .filter(Boolean);
-
-  const windowsExtensions = process.platform === 'win32'
-    ? String(process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM')
-      .split(';')
-      .map((ext) => ext.trim())
-      .filter(Boolean)
-    : [''];
-
-  const candidatePaths = [];
-  for (const baseDir of pathEntries) {
-    const baseCandidate = isDirectPath ? normalizedCommand : path.join(baseDir, normalizedCommand);
-    candidatePaths.push(baseCandidate);
-
-    if (process.platform === 'win32' && !path.extname(baseCandidate)) {
-      for (const ext of windowsExtensions) {
-        candidatePaths.push(`${baseCandidate}${ext}`);
-      }
-    }
-  }
-
-  for (const candidatePath of candidatePaths) {
-    if (await isRunnableCommand(candidatePath)) {
-      return {
-        found: true,
-        resolvedPath: candidatePath,
-        reason: null
-      };
-    }
-  }
-
-  return {
-    found: false,
-    resolvedPath: null,
-    reason: `${normalizedCommand} not found in PATH`
-  };
-}
-
 function buildInstallationStatus(provider, command, installed, resolvedPath, reason, cacheHit = false) {
   return {
     success: true,

package/server/routes/commands.js

@@ -199,13 +199,8 @@ Custom commands can be created in:
     }, {});
 
     const currentProvider = context?.provider || 'claude';
-    const providerDefaults = {
-      claude: CLAUDE_MODELS.DEFAULT,
-      codex: CODEX_MODELS.DEFAULT,
-      gemini: GEMINI_MODELS.DEFAULT,
-      opencode: OPENCODE_MODELS.DEFAULT
-    };
-    const currentModel = context?.model || providerDefaults[currentProvider] || CLAUDE_MODELS.DEFAULT;
+    const discoveredCurrentModel = providerDiscovery.find((item) => item.provider === currentProvider)?.currentModel || null;
+    const currentModel = context?.model || discoveredCurrentModel || null;
     const opencodeDiscovery = providerDiscovery.find((item) => item.provider === 'opencode') || null;
 
     return {
@@ -220,7 +215,7 @@ Custom commands can be created in:
         opencodeDiscovery,
         message: args.length > 0
           ? `Switching to model: ${args[0]}`
-          : `Current model: ${currentModel}`
+          : (currentModel ? `Current model: ${currentModel}` : 'Current model is managed by the active provider configuration.')
       }
     };
   },
@@ -254,7 +249,7 @@ Custom commands can be created in:
         packageName,
         uptime: uptimeFormatted,
         uptimeSeconds: Math.floor(uptime),
-        model: context?.model || 'claude-sonnet-4.5',
+        model: context?.model || null,
         provider: context?.provider || 'claude',
         nodeVersion: process.version,
         platform: process.platform

package/server/routes/projects.js

@@ -1,13 +1,23 @@
 import express from 'express';
 import { promises as fs } from 'fs';
 import path from 'path';
-import os from 'os';
 import { addProjectManually } from '../projects.js';
+import {
+  DEFAULT_WORKSPACES_ROOT,
+  HAS_WORKSPACES_ROOT_RESTRICTION,
+  WORKSPACES_ROOTS,
+  formatAllowedWorkspaceRoots,
+  isPathWithinAllowedRoots,
+  resolveAllowedWorkspaceRoots
+} from '../utils/workspaceRoots.js';
 
-const router = express.Router();
+export {
+  DEFAULT_WORKSPACES_ROOT,
+  HAS_WORKSPACES_ROOT_RESTRICTION,
+  WORKSPACES_ROOTS
+} from '../utils/workspaceRoots.js';
 
-// Configure allowed workspace root (defaults to user's home directory)
-export const WORKSPACES_ROOT = process.env.WORKSPACES_ROOT || os.homedir();
+const router = express.Router();
 
 // System-critical paths that should never be used as workspace directories
 export const FORBIDDEN_PATHS = [
@@ -42,8 +52,14 @@ export const FORBIDDEN_PATHS = [
  * @param {string} requestedPath - The path to validate
  * @returns {Promise<{valid: boolean, resolvedPath?: string, error?: string}>}
  */
-export async function validateWorkspacePath(requestedPath) {
+export async function validateWorkspacePath(requestedPath, options = {}) {
   try {
+    const {
+      fsImpl = fs,
+      hasWorkspaceRootRestriction = HAS_WORKSPACES_ROOT_RESTRICTION,
+      allowedWorkspaceRoots = WORKSPACES_ROOTS
+    } = options;
+
     // Resolve to absolute path
     let absolutePath = path.resolve(requestedPath);
 
@@ -79,14 +95,14 @@ export async function validateWorkspacePath(requestedPath) {
     let realPath;
     try {
       // Check if path exists to resolve real path
-      await fs.access(absolutePath);
-      realPath = await fs.realpath(absolutePath);
+      await fsImpl.access(absolutePath);
+      realPath = await fsImpl.realpath(absolutePath);
     } catch (error) {
       if (error.code === 'ENOENT') {
         // Path doesn't exist yet - check parent directory
         let parentPath = path.dirname(absolutePath);
         try {
-          const parentRealPath = await fs.realpath(parentPath);
+          const parentRealPath = await fsImpl.realpath(parentPath);
 
           // Reconstruct the full path with real parent
           realPath = path.join(parentRealPath, path.basename(absolutePath));
@@ -104,31 +120,36 @@ export async function validateWorkspacePath(requestedPath) {
       }
     }
 
-    // Resolve the workspace root to its real path
-    const resolvedWorkspaceRoot = await fs.realpath(WORKSPACES_ROOT);
+    if (hasWorkspaceRootRestriction && allowedWorkspaceRoots.length > 0) {
+      const resolvedWorkspaceRoots = await resolveAllowedWorkspaceRoots({
+        fsImpl,
+        allowedWorkspaceRoots
+      });
 
-    // Ensure the resolved path is contained within the allowed workspace root
-    if (!realPath.startsWith(resolvedWorkspaceRoot + path.sep) &&
-        realPath !== resolvedWorkspaceRoot) {
-      return {
-        valid: false,
-        error: `Workspace path must be within the allowed workspace root: ${WORKSPACES_ROOT}`
-      };
+      if (!isPathWithinAllowedRoots(realPath, resolvedWorkspaceRoots)) {
+        return {
+          valid: false,
+          error: `Workspace path must be within one of the allowed workspace roots: ${formatAllowedWorkspaceRoots(allowedWorkspaceRoots)}`
+        };
+      }
     }
 
     // Additional symlink check for existing paths
     try {
-      await fs.access(absolutePath);
-      const stats = await fs.lstat(absolutePath);
+      await fsImpl.access(absolutePath);
+      const stats = await fsImpl.lstat(absolutePath);
 
-      if (stats.isSymbolicLink()) {
+      if (stats.isSymbolicLink() && hasWorkspaceRootRestriction && allowedWorkspaceRoots.length > 0) {
+        const resolvedWorkspaceRoots = await resolveAllowedWorkspaceRoots({
+          fsImpl,
+          allowedWorkspaceRoots
+        });
         // Verify symlink target is also within allowed root
-        const linkTarget = await fs.readlink(absolutePath);
+        const linkTarget = await fsImpl.readlink(absolutePath);
         const resolvedTarget = path.resolve(path.dirname(absolutePath), linkTarget);
-        const realTarget = await fs.realpath(resolvedTarget);
+        const realTarget = await fsImpl.realpath(resolvedTarget);
 
-        if (!realTarget.startsWith(resolvedWorkspaceRoot + path.sep) &&
-            realTarget !== resolvedWorkspaceRoot) {
+        if (!isPathWithinAllowedRoots(realTarget, resolvedWorkspaceRoots)) {
           return {
             valid: false,
             error: 'Symlink target is outside the allowed workspace root'

package/server/session-core/providerDiscovery.js

@@ -151,7 +151,12 @@ async function discoverOpenCodeModels(projectPath) {
 }
 
 async function discoverClaudeModels() {
-  return { models: mapModelOptions(CLAUDE_MODELS.OPTIONS, 'runtime-fallback'), source: 'runtime-fallback', error: null, currentModel: process.env.CLAUDE_MODEL || CLAUDE_MODELS.DEFAULT };
+  return {
+    models: mapModelOptions(CLAUDE_MODELS.OPTIONS, 'runtime-fallback'),
+    source: 'runtime-fallback',
+    error: null,
+    currentModel: null
+  };
 }
 
 async function discoverCodexModels() {
@@ -163,11 +168,11 @@ async function discoverCodexModels() {
     if (match) currentModel = match[1];
   } catch {
   }
-  return { models: mapModelOptions(CODEX_MODELS.OPTIONS, 'runtime-fallback'), source: 'runtime-fallback', error: null, currentModel: currentModel || CODEX_MODELS.DEFAULT };
+  return { models: mapModelOptions(CODEX_MODELS.OPTIONS, 'runtime-fallback'), source: 'runtime-fallback', error: null, currentModel: currentModel || null };
 }
 
 async function discoverGeminiModels() {
-  return { models: mapModelOptions(GEMINI_MODELS.OPTIONS, 'runtime-fallback'), source: 'runtime-fallback', error: null, currentModel: GEMINI_MODELS.DEFAULT };
+  return { models: mapModelOptions(GEMINI_MODELS.OPTIONS, 'runtime-fallback'), source: 'runtime-fallback', error: null, currentModel: null };
 }
 
 const AUTH_CHECKERS = {

package/server/utils/ccConnectManager.js

@@ -0,0 +1,390 @@
+import fs from 'fs';
+import { spawnSync } from 'child_process';
+import crossSpawn from 'cross-spawn';
+import { detectProviderInstallationStatus } from '../routes/cli-auth.js';
+import { resolveCommandPath } from './resolveCommandPath.js';
+import { spawnCommand } from './spawnCommand.js';
+import {
+  CC_CONNECT_PLATFORMS,
+  CC_CONNECT_PROVIDERS,
+  getPlatformConnection,
+  listCcConnectPlatformSummaries,
+  readCcConnectState,
+  upsertPlatformConnection,
+  writeCcConnectConfig,
+  writeCcConnectState
+} from './ccConnectState.js';
+
+const CC_CONNECT_COMMAND = 'cc-connect';
+const COMMAND_TIMEOUT_MS = 5000;
+const DAEMON_COMMAND_TIMEOUT_MS = 20000;
+
+const PROVIDER_ORDER = CC_CONNECT_PROVIDERS.map((provider) => provider.id);
+const PLATFORM_MAP = Object.fromEntries(CC_CONNECT_PLATFORMS.map((platform) => [platform.id, platform]));
+
+function createCcConnectError(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function runCommandSync({ command, args = [], timeoutMs = COMMAND_TIMEOUT_MS, cwd = process.cwd(), env = process.env }) {
+  const runner = process.platform === 'win32' ? crossSpawn.sync : spawnSync;
+  const result = runner(command, args, {
+    cwd,
+    env,
+    encoding: 'utf8',
+    timeout: timeoutMs
+  });
+
+  return {
+    status: result.status,
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+    error: result.error || null
+  };
+}
+
+function buildCommandEnv() {
+  const env = { ...process.env };
+  delete env.CLAUDECODE;
+  return env;
+}
+
+function buildShortErrorMessage(result) {
+  const stderr = String(result?.stderr || '').trim();
+  if (stderr) {
+    return stderr.replace(/\s+/g, ' ').slice(0, 260);
+  }
+
+  const stdout = String(result?.stdout || '').trim();
+  if (stdout) {
+    return stdout.replace(/\s+/g, ' ').slice(0, 260);
+  }
+
+  if (result?.error?.message) {
+    return result.error.message;
+  }
+
+  return 'Unknown error';
+}
+
+function runCcConnectDaemonCommand(args, timeoutMs = DAEMON_COMMAND_TIMEOUT_MS) {
+  return runCommandSync({
+    command: CC_CONNECT_COMMAND,
+    args,
+    timeoutMs,
+    env: buildCommandEnv()
+  });
+}
+
+function startCcConnectViaDaemon(configPath) {
+  const statusResult = runCcConnectDaemonCommand(['daemon', 'status']);
+  const isRunning = statusResult.status === 0 && /status:\s+running/i.test(statusResult.stdout || '');
+
+  if (isRunning) {
+    const restartResult = runCcConnectDaemonCommand(['daemon', 'restart']);
+    if (restartResult.status === 0) {
+      return { ok: true, detail: 'cc-connect daemon restarted with the latest configuration.' };
+    }
+
+    return {
+      ok: false,
+      detail: `Configuration written, but daemon restart failed: ${buildShortErrorMessage(restartResult)}`
+    };
+  }
+
+  const startResult = runCcConnectDaemonCommand(['daemon', 'start']);
+  if (startResult.status === 0) {
+    return { ok: true, detail: 'cc-connect daemon started with the latest configuration.' };
+  }
+
+  const installResult = runCcConnectDaemonCommand(['daemon', 'install', '--config', configPath], 60000);
+  if (installResult.status === 0) {
+    return { ok: true, detail: 'cc-connect daemon installed and started.' };
+  }
+
+  return {
+    ok: false,
+    detail: `Configuration written, but daemon start failed: ${buildShortErrorMessage(installResult)}`
+  };
+}
+
+function startCcConnectDetached(configPath) {
+  try {
+    const child = spawnCommand(CC_CONNECT_COMMAND, ['--config', configPath], {
+      detached: true,
+      stdio: 'ignore',
+      env: buildCommandEnv(),
+      windowsHide: true
+    });
+    child.unref();
+    return { ok: true, detail: 'cc-connect started in the background.' };
+  } catch (error) {
+    return {
+      ok: false,
+      detail: `Configuration written, but background start failed: ${error.message}`
+    };
+  }
+}
+
+export function ensureCcConnectDaemonRunning(configPath) {
+  if (process.platform === 'win32') {
+    return startCcConnectDetached(configPath);
+  }
+
+  return startCcConnectViaDaemon(configPath);
+}
+
+export function normalizeCcConnectPlatformId(value) {
+  const platformId = String(value || '').trim().toLowerCase();
+  return PLATFORM_MAP[platformId] ? platformId : null;
+}
+
+export function normalizeCcConnectProviderId(value) {
+  const providerId = String(value || '').trim().toLowerCase();
+  return PROVIDER_ORDER.includes(providerId) ? providerId : null;
+}
+
+export function mergeAvailableCcConnectProviders(configuredProviders = [], installedProviderIds = [], activeProvider = null) {
+  const available = new Set();
+
+  for (const providerId of configuredProviders) {
+    if (PROVIDER_ORDER.includes(providerId)) {
+      available.add(providerId);
+    }
+  }
+
+  for (const providerId of installedProviderIds) {
+    if (PROVIDER_ORDER.includes(providerId)) {
+      available.add(providerId);
+    }
+  }
+
+  if (activeProvider && PROVIDER_ORDER.includes(activeProvider)) {
+    available.add(activeProvider);
+  }
+
+  return PROVIDER_ORDER.filter((providerId) => available.has(providerId));
+}
+
+function buildPlatformSummaries(state, installedProviderIds) {
+  return listCcConnectPlatformSummaries(state).map((platform) => {
+    if (!platform.connected) {
+      return platform;
+    }
+
+    const connection = getPlatformConnection(state, platform.id);
+    const configuredProviders = mergeAvailableCcConnectProviders(
+      connection?.configuredProviders,
+      installedProviderIds,
+      connection?.activeProvider || null
+    );
+
+    return {
+      ...platform,
+      configuredProviders
+    };
+  });
+}
+
+function resolveInstalledProviderIdsFromStatuses(statuses = []) {
+  return statuses.filter((provider) => provider.installed).map((provider) => provider.id);
+}
+
+export async function getCcConnectStatus() {
+  const resolved = await resolveCommandPath(CC_CONNECT_COMMAND);
+  if (!resolved.found) {
+    return {
+      installed: false,
+      version: null,
+      isBeta: false,
+      resolvedPath: null
+    };
+  }
+
+  const result = runCommandSync({
+    command: resolved.resolvedPath || CC_CONNECT_COMMAND,
+    args: ['--version'],
+    timeoutMs: COMMAND_TIMEOUT_MS,
+    env: buildCommandEnv()
+  });
+  const version = String(result.stdout || '').trim() || null;
+
+  return {
+    installed: true,
+    version,
+    isBeta: Boolean(version && /beta|alpha|rc|pre/i.test(version)),
+    resolvedPath: resolved.resolvedPath || null
+  };
+}
+
+export async function getCcConnectProviderStatuses() {
+  return Promise.all(
+    PROVIDER_ORDER.map(async (providerId) => {
+      const label = CC_CONNECT_PROVIDERS.find((provider) => provider.id === providerId)?.label || providerId;
+      try {
+        const status = await detectProviderInstallationStatus(providerId);
+        return {
+          id: providerId,
+          label,
+          ...status
+        };
+      } catch (error) {
+        return {
+          id: providerId,
+          label,
+          success: false,
+          installed: false,
+          error: error.message
+        };
+      }
+    })
+  );
+}
+
+export async function getCcConnectInstalledProviderIds() {
+  const statuses = await getCcConnectProviderStatuses();
+  return resolveInstalledProviderIdsFromStatuses(statuses);
+}
+
+export async function getCcConnectConnectionSummary(platformId = null) {
+  const normalizedPlatformId = platformId == null ? null : normalizeCcConnectPlatformId(platformId);
+  if (platformId != null && !normalizedPlatformId) {
+    throw createCcConnectError('UNSUPPORTED_PLATFORM', 'Unsupported platform.');
+  }
+
+  const ccConnect = await getCcConnectStatus();
+  const providers = await getCcConnectProviderStatuses();
+  const installedProviderIds = resolveInstalledProviderIdsFromStatuses(providers);
+  const state = readCcConnectState();
+  const platforms = buildPlatformSummaries(state, installedProviderIds);
+
+  return {
+    ccConnect,
+    providers,
+    platforms,
+    platform: normalizedPlatformId
+      ? platforms.find((entry) => entry.id === normalizedPlatformId) || null
+      : null
+  };
+}
+
+function normalizeProjectPath(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function validateProjectPath(projectPath) {
+  const normalizedProjectPath = normalizeProjectPath(projectPath);
+  if (!normalizedProjectPath) {
+    throw createCcConnectError('PROJECT_PATH_REQUIRED', 'projectPath is required.');
+  }
+
+  if (!fs.existsSync(normalizedProjectPath)) {
+    throw createCcConnectError('PROJECT_PATH_NOT_FOUND', 'Selected project path does not exist.');
+  }
+
+  return normalizedProjectPath;
+}
+
+export async function updateCcConnectPlatformBinding({ platformId, provider, projectPath }) {
+  const normalizedPlatformId = normalizeCcConnectPlatformId(platformId);
+  if (!normalizedPlatformId) {
+    throw createCcConnectError('UNSUPPORTED_PLATFORM', 'Unsupported platform.');
+  }
+
+  const hasProviderUpdate = provider !== undefined;
+  const hasProjectUpdate = projectPath !== undefined;
+  if (!hasProviderUpdate && !hasProjectUpdate) {
+    throw createCcConnectError('NO_MUTATION', 'At least one of provider or projectPath is required.');
+  }
+
+  const ccConnect = await getCcConnectStatus();
+  if (!ccConnect.installed) {
+    throw createCcConnectError('CC_CONNECT_NOT_INSTALLED', 'cc-connect is not installed.');
+  }
+
+  const currentState = readCcConnectState();
+  const connection = getPlatformConnection(currentState, normalizedPlatformId);
+  if (!connection) {
+    throw createCcConnectError('PLATFORM_NOT_CONNECTED', `${PLATFORM_MAP[normalizedPlatformId].label} is not connected.`);
+  }
+
+  const installedProviderIds = await getCcConnectInstalledProviderIds();
+  const availableProviders = mergeAvailableCcConnectProviders(
+    connection.configuredProviders,
+    installedProviderIds,
+    connection.activeProvider
+  );
+
+  let nextProvider = connection.activeProvider;
+  let nextProjectPath = connection.projectPath;
+  const changedFields = [];
+
+  if (hasProviderUpdate) {
+    const normalizedProviderId = normalizeCcConnectProviderId(provider);
+    if (!normalizedProviderId) {
+      throw createCcConnectError('UNSUPPORTED_PROVIDER', `Unsupported provider: ${provider}`);
+    }
+
+    if (!availableProviders.includes(normalizedProviderId)) {
+      throw createCcConnectError('PROVIDER_NOT_AVAILABLE', `Unsupported provider: ${normalizedProviderId}`);
+    }
+
+    if (normalizedProviderId !== nextProvider) {
+      changedFields.push('provider');
+      nextProvider = normalizedProviderId;
+    }
+  }
+
+  if (hasProjectUpdate) {
+    const normalizedProjectPath = validateProjectPath(projectPath);
+    if (normalizedProjectPath !== nextProjectPath) {
+      changedFields.push('projectPath');
+      nextProjectPath = normalizedProjectPath;
+    }
+  }
+
+  if (changedFields.length === 0) {
+    return {
+      platform: normalizedPlatformId,
+      label: PLATFORM_MAP[normalizedPlatformId].label,
+      provider: nextProvider,
+      projectPath: nextProjectPath,
+      configuredProviders: availableProviders,
+      changed: false,
+      changedFields,
+      message: 'No changes applied.'
+    };
+  }
+
+  const nextState = upsertPlatformConnection(currentState, normalizedPlatformId, {
+    ...connection,
+    configuredProviders: availableProviders,
+    activeProvider: nextProvider,
+    projectPath: nextProjectPath,
+    updatedAt: nowIso()
+  });
+
+  writeCcConnectState(nextState);
+  const { configPath } = writeCcConnectConfig(nextState);
+  const daemonResult = ensureCcConnectDaemonRunning(configPath);
+  if (!daemonResult.ok) {
+    throw createCcConnectError('DAEMON_UPDATE_FAILED', daemonResult.detail);
+  }
+
+  return {
+    platform: normalizedPlatformId,
+    label: PLATFORM_MAP[normalizedPlatformId].label,
+    provider: nextProvider,
+    projectPath: nextProjectPath,
+    configuredProviders: availableProviders,
+    changed: true,
+    changedFields,
+    message: daemonResult.detail
+  };
+}