@axhub/genie 0.2.6 → 0.2.8

package/server/utils/ccConnectState.js

@@ -0,0 +1,575 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import TOML from '@iarna/toml';
+
+export const CC_CONNECT_STATE_VERSION = 2;
+export const CC_CONNECT_CONFIG_DIR = path.join(os.homedir(), '.cc-connect');
+export const CC_CONNECT_CONFIG_PATH = path.join(CC_CONNECT_CONFIG_DIR, 'config.toml');
+export const CC_CONNECT_STATE_PATH = path.join(CC_CONNECT_CONFIG_DIR, 'ai-web-ui-connect-state.json');
+export const LEGACY_WEIXIN_STATE_PATH = path.join(CC_CONNECT_CONFIG_DIR, 'axhub-weixin-state.json');
+
+export const CC_CONNECT_PROVIDERS = [
+  { id: 'claude', label: 'Claude', command: 'claude', ccAgentType: 'claudecode' },
+  { id: 'codex', label: 'Codex', command: 'codex', ccAgentType: 'codex' },
+  { id: 'gemini', label: 'Gemini', command: 'gemini', ccAgentType: 'gemini' },
+  { id: 'opencode', label: 'OpenCode', command: 'opencode', ccAgentType: 'opencode' }
+];
+
+export const CC_CONNECT_PLATFORMS = [
+  {
+    id: 'weixin',
+    label: 'Weixin',
+    description: 'Connect Weixin personal via QR code',
+    blockedAllowFrom: 'blocked@im.wechat',
+    supportedModes: ['qr', 'token'],
+    timeoutSeconds: 480
+  },
+  {
+    id: 'feishu',
+    label: 'Feishu',
+    description: 'Connect Feishu via QR onboarding or app credentials',
+    blockedAllowFrom: 'blocked_open_id',
+    supportedModes: ['qr', 'credentials'],
+    timeoutSeconds: 600
+  }
+];
+
+const PROVIDER_MAP = Object.fromEntries(CC_CONNECT_PROVIDERS.map((provider) => [provider.id, provider]));
+const PROVIDER_BY_AGENT_TYPE = {
+  claude: 'claude',
+  claudecode: 'claude',
+  codex: 'codex',
+  gemini: 'gemini',
+  opencode: 'opencode'
+};
+const PLATFORM_MAP = Object.fromEntries(CC_CONNECT_PLATFORMS.map((platform) => [platform.id, platform]));
+const LEGACY_WEIXIN_PROJECT_NAMES = new Set(['axhub-claudecode', 'axhub-codex', 'axhub-gemini', 'axhub-opencode']);
+
+function createEmptyState() {
+  return {
+    version: CC_CONNECT_STATE_VERSION,
+    connections: {}
+  };
+}
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function dedupeOrdered(values) {
+  const seen = new Set();
+  return values.filter((value) => {
+    if (!value || seen.has(value)) {
+      return false;
+    }
+    seen.add(value);
+    return true;
+  });
+}
+
+function normalizeProviderId(value) {
+  const providerId = String(value || '').trim().toLowerCase();
+  return PROVIDER_MAP[providerId] ? providerId : null;
+}
+
+function normalizeProviderFromAgentType(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  return PROVIDER_BY_AGENT_TYPE[normalized] || null;
+}
+
+function normalizePlatformId(value) {
+  const platformId = String(value || '').trim().toLowerCase();
+  return PLATFORM_MAP[platformId] ? platformId : null;
+}
+
+function sanitizePlainObject(value) {
+  if (!isPlainObject(value)) {
+    return {};
+  }
+
+  return Object.fromEntries(
+    Object.entries(value).filter(([, item]) => item !== undefined && item !== null)
+  );
+}
+
+function normalizePlatformOptions(platformId, value) {
+  return sanitizePlainObject(value);
+}
+
+function ensureConfigDir() {
+  if (!fs.existsSync(CC_CONNECT_CONFIG_DIR)) {
+    fs.mkdirSync(CC_CONNECT_CONFIG_DIR, { recursive: true });
+  }
+}
+
+function readJsonFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function normalizeConnection(connection) {
+  if (!isPlainObject(connection)) {
+    return null;
+  }
+
+  const configuredProviders = dedupeOrdered(
+    (Array.isArray(connection.configuredProviders) ? connection.configuredProviders : [])
+      .map(normalizeProviderId)
+      .filter(Boolean)
+  );
+
+  const activeProvider = normalizeProviderId(connection.activeProvider) || configuredProviders[0] || null;
+  const projectPath = typeof connection.projectPath === 'string' ? connection.projectPath.trim() : '';
+  const platformType = normalizePlatformId(connection.platformType) || null;
+  const connectionOptions = normalizePlatformOptions(platformType, connection.connectionOptions);
+
+  if (!activeProvider || configuredProviders.length === 0 || !projectPath) {
+    return null;
+  }
+
+  return {
+    configuredProviders,
+    activeProvider: configuredProviders.includes(activeProvider) ? activeProvider : configuredProviders[0],
+    projectPath,
+    connectionOptions,
+    platformType,
+    connectedAt: typeof connection.connectedAt === 'string' ? connection.connectedAt : null,
+    updatedAt: typeof connection.updatedAt === 'string' ? connection.updatedAt : null
+  };
+}
+
+export function normalizeCcConnectState(input) {
+  const nextState = createEmptyState();
+  if (!isPlainObject(input)) {
+    return nextState;
+  }
+
+  const connections = isPlainObject(input.connections) ? input.connections : {};
+  for (const [rawPlatformId, rawConnection] of Object.entries(connections)) {
+    const platformId = normalizePlatformId(rawPlatformId);
+    const connection = normalizeConnection(rawConnection);
+    if (!platformId || !connection) {
+      continue;
+    }
+
+    nextState.connections[platformId] = {
+      ...connection,
+      platformType: connection.platformType || platformId,
+      connectedAt: connection.connectedAt || new Date().toISOString(),
+      updatedAt: connection.updatedAt || new Date().toISOString()
+    };
+  }
+
+  return nextState;
+}
+
+function readTomlConfig(content) {
+  if (typeof content !== 'string' || !content.trim()) {
+    return { projects: [] };
+  }
+
+  try {
+    const parsed = TOML.parse(content);
+    return isPlainObject(parsed) ? parsed : { projects: [] };
+  } catch {
+    return { projects: [] };
+  }
+}
+
+function getProjectPlatformEntry(project, platformId) {
+  const platforms = Array.isArray(project?.platforms) ? project.platforms : [];
+  return platforms.find((entry) => normalizePlatformId(entry?.type) === platformId) || null;
+}
+
+function getManagedProjectName(platformId, providerId) {
+  return `ai-web-ui-${platformId}-${providerId}`;
+}
+
+export function getCcConnectManagedProjectName(platformId, providerId) {
+  return getManagedProjectName(platformId, providerId);
+}
+
+function isManagedProject(project, platformId = null) {
+  const projectName = String(project?.name || '').trim().toLowerCase();
+  if (!projectName) {
+    return false;
+  }
+
+  if (projectName.startsWith('ai-web-ui-')) {
+    if (!platformId) {
+      return true;
+    }
+    return projectName.startsWith(`ai-web-ui-${platformId}-`);
+  }
+
+  if (platformId === 'weixin' || platformId === null) {
+    return LEGACY_WEIXIN_PROJECT_NAMES.has(projectName);
+  }
+
+  return false;
+}
+
+function isBlockedAllowFrom(platformId, value) {
+  if (typeof value !== 'string') {
+    return false;
+  }
+
+  return value.trim() === PLATFORM_MAP[platformId]?.blockedAllowFrom;
+}
+
+function buildConnectionFromProjects(platformId, entries) {
+  if (!Array.isArray(entries) || entries.length === 0) {
+    return null;
+  }
+
+  const configuredProviders = dedupeOrdered(entries.map((entry) => entry.providerId));
+  const activeEntry = entries.find(({ options }) => {
+    const allowFrom = options?.allow_from;
+    if (platformId === 'weixin') {
+      return typeof allowFrom === 'string' && allowFrom.trim() && !isBlockedAllowFrom(platformId, allowFrom);
+    }
+
+    if (typeof allowFrom !== 'string' || !allowFrom.trim()) {
+      return true;
+    }
+
+    return !isBlockedAllowFrom(platformId, allowFrom);
+  }) || entries[0];
+
+  const projectPath = String(activeEntry.project?.agent?.options?.work_dir || entries[0]?.project?.agent?.options?.work_dir || '').trim();
+  if (!configuredProviders.length || !projectPath) {
+    return null;
+  }
+
+  return {
+    configuredProviders,
+    activeProvider: activeEntry.providerId,
+    projectPath,
+    connectionOptions: normalizePlatformOptions(platformId, activeEntry.options),
+    platformType: platformId,
+    connectedAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString()
+  };
+}
+
+export function bootstrapStateFromConfigContent(content) {
+  const config = readTomlConfig(content);
+  const projects = Array.isArray(config.projects) ? config.projects : [];
+  const nextState = createEmptyState();
+
+  for (const platform of CC_CONNECT_PLATFORMS) {
+    const entries = [];
+    for (const project of projects) {
+      if (!isManagedProject(project, platform.id)) {
+        continue;
+      }
+
+      const providerId = normalizeProviderFromAgentType(project?.agent?.type);
+      if (!providerId) {
+        continue;
+      }
+
+      const platformEntry = getProjectPlatformEntry(project, platform.id);
+      if (!platformEntry || !isPlainObject(platformEntry.options)) {
+        continue;
+      }
+
+      entries.push({
+        providerId,
+        project,
+        options: sanitizePlainObject(platformEntry.options)
+      });
+    }
+
+    const connection = buildConnectionFromProjects(platform.id, entries);
+    if (connection) {
+      nextState.connections[platform.id] = connection;
+    }
+  }
+
+  return Object.keys(nextState.connections).length > 0 ? nextState : null;
+}
+
+function migrateLegacyWeixinState() {
+  const legacy = readJsonFile(LEGACY_WEIXIN_STATE_PATH);
+  if (!legacy || Number(legacy.version) !== 1) {
+    return null;
+  }
+
+  const configuredProviders = dedupeOrdered(
+    (Array.isArray(legacy.configuredAgents) ? legacy.configuredAgents : [])
+      .map(normalizeProviderFromAgentType)
+      .filter(Boolean)
+  );
+  const activeProvider = normalizeProviderFromAgentType(legacy.activeAgent) || configuredProviders[0] || null;
+  const projectPath = typeof legacy.workDir === 'string' ? legacy.workDir.trim() : '';
+  const connectionOptions = normalizePlatformOptions('weixin', legacy.weixinOptions);
+
+  if (!configuredProviders.length || !activeProvider || !projectPath || !Object.keys(connectionOptions).length) {
+    return null;
+  }
+
+  return normalizeCcConnectState({
+    version: CC_CONNECT_STATE_VERSION,
+    connections: {
+      weixin: {
+        configuredProviders,
+        activeProvider,
+        projectPath,
+        connectionOptions,
+        platformType: 'weixin',
+        connectedAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString()
+      }
+    }
+  });
+}
+
+export function readCcConnectState() {
+  const stored = readJsonFile(CC_CONNECT_STATE_PATH);
+  if (stored) {
+    return normalizeCcConnectState(stored);
+  }
+
+  const configContent = readCcConnectConfigContent();
+  const bootstrapped = bootstrapStateFromConfigContent(configContent);
+  if (bootstrapped) {
+    writeCcConnectState(bootstrapped);
+    return bootstrapped;
+  }
+
+  const migratedLegacy = migrateLegacyWeixinState();
+  if (migratedLegacy) {
+    writeCcConnectState(migratedLegacy);
+    return migratedLegacy;
+  }
+
+  return createEmptyState();
+}
+
+export function writeCcConnectState(state) {
+  ensureConfigDir();
+  const normalized = normalizeCcConnectState(state);
+  fs.writeFileSync(CC_CONNECT_STATE_PATH, JSON.stringify(normalized, null, 2), 'utf8');
+  return normalized;
+}
+
+export function readCcConnectConfigContent() {
+  if (!fs.existsSync(CC_CONNECT_CONFIG_PATH)) {
+    return '';
+  }
+
+  try {
+    return fs.readFileSync(CC_CONNECT_CONFIG_PATH, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function buildManagedProject(platformId, connection, providerId) {
+  const provider = PROVIDER_MAP[providerId];
+  const options = normalizePlatformOptions(platformId, connection.connectionOptions);
+
+  if (providerId !== connection.activeProvider) {
+    options.allow_from = PLATFORM_MAP[platformId].blockedAllowFrom;
+  }
+
+  return {
+    name: getManagedProjectName(platformId, providerId),
+    agent: {
+      type: provider.ccAgentType,
+      options: {
+        work_dir: connection.projectPath,
+        mode: 'yolo'
+      }
+    },
+    platforms: [
+      {
+        type: connection.platformType || platformId,
+        options
+      }
+    ]
+  };
+}
+
+function shouldMaterializeManagedProject(platformId, connection, providerId) {
+  if (platformId === 'feishu') {
+    return providerId === connection.activeProvider;
+  }
+
+  return true;
+}
+
+export function buildManagedProjects(state) {
+  const normalized = normalizeCcConnectState(state);
+  const projects = [];
+
+  for (const platform of CC_CONNECT_PLATFORMS) {
+    const connection = normalized.connections[platform.id];
+    if (!connection) {
+      continue;
+    }
+
+    for (const providerId of connection.configuredProviders) {
+      if (!PROVIDER_MAP[providerId]) {
+        continue;
+      }
+      if (!shouldMaterializeManagedProject(platform.id, connection, providerId)) {
+        continue;
+      }
+      projects.push(buildManagedProject(platform.id, connection, providerId));
+    }
+  }
+
+  return projects;
+}
+
+export function serializeCcConnectConfig(baseContent, state) {
+  const existingConfig = readTomlConfig(baseContent);
+  const existingProjects = Array.isArray(existingConfig.projects) ? existingConfig.projects : [];
+  const unmanagedProjects = existingProjects.filter((project) => !isManagedProject(project));
+  const managedProjects = buildManagedProjects(state);
+  const nextConfig = {
+    ...existingConfig,
+    log: isPlainObject(existingConfig.log) ? existingConfig.log : { level: 'info' }
+  };
+
+  const allProjects = [...unmanagedProjects, ...managedProjects];
+  if (allProjects.length > 0) {
+    nextConfig.projects = allProjects;
+  } else {
+    delete nextConfig.projects;
+  }
+
+  return TOML.stringify(nextConfig);
+}
+
+export function writeCcConnectConfig(state) {
+  ensureConfigDir();
+  const content = serializeCcConnectConfig(readCcConnectConfigContent(), state);
+  fs.writeFileSync(CC_CONNECT_CONFIG_PATH, content, 'utf8');
+  return {
+    configPath: CC_CONNECT_CONFIG_PATH,
+    content
+  };
+}
+
+export function getPlatformConnection(state, platformId) {
+  const normalized = normalizeCcConnectState(state);
+  const resolvedPlatformId = normalizePlatformId(platformId);
+  if (!resolvedPlatformId) {
+    return null;
+  }
+
+  return normalized.connections[resolvedPlatformId] || null;
+}
+
+export function upsertPlatformConnection(state, platformId, connection) {
+  const normalized = normalizeCcConnectState(state);
+  const resolvedPlatformId = normalizePlatformId(platformId);
+  const normalizedConnection = normalizeConnection(connection);
+  if (!resolvedPlatformId || !normalizedConnection) {
+    return normalized;
+  }
+
+  normalized.connections[resolvedPlatformId] = {
+    ...normalizedConnection,
+    platformType: normalizedConnection.platformType || resolvedPlatformId,
+    connectedAt: normalizedConnection.connectedAt || new Date().toISOString(),
+    updatedAt: new Date().toISOString()
+  };
+  return normalized;
+}
+
+export function removePlatformConnection(state, platformId) {
+  const normalized = normalizeCcConnectState(state);
+  const resolvedPlatformId = normalizePlatformId(platformId);
+  if (resolvedPlatformId) {
+    delete normalized.connections[resolvedPlatformId];
+  }
+  return normalized;
+}
+
+export function createSetupConfigContent({
+  platformId,
+  providerId,
+  projectName,
+  projectPath,
+  setupOptions = {}
+}) {
+  const platform = PLATFORM_MAP[platformId];
+  const provider = PROVIDER_MAP[providerId];
+  if (!platform || !provider) {
+    throw new Error('Unsupported platform or provider');
+  }
+
+  return TOML.stringify({
+    log: { level: 'info' },
+    projects: [
+      {
+        name: projectName,
+        agent: {
+          type: provider.ccAgentType,
+          options: {
+            work_dir: projectPath,
+            mode: 'yolo'
+          }
+        },
+        platforms: [
+          {
+            type: platform.id,
+            options: normalizePlatformOptions(platform.id, setupOptions)
+          }
+        ]
+      }
+    ]
+  });
+}
+
+export function extractPlatformOptionsFromConfigContent(content, projectName, platformId) {
+  const config = readTomlConfig(content);
+  const projects = Array.isArray(config.projects) ? config.projects : [];
+  const project = projects.find((item) => String(item?.name || '').trim() === String(projectName || '').trim());
+  if (!project) {
+    return null;
+  }
+
+  const platformEntry = getProjectPlatformEntry(project, platformId);
+  if (!platformEntry || !isPlainObject(platformEntry.options)) {
+    return null;
+  }
+
+  return normalizePlatformOptions(platformId, platformEntry.options);
+}
+
+export function listCcConnectPlatformSummaries(state) {
+  const normalized = normalizeCcConnectState(state);
+
+  return CC_CONNECT_PLATFORMS.map((platform) => {
+    const connection = normalized.connections[platform.id] || null;
+    return {
+      id: platform.id,
+      label: platform.label,
+      description: platform.description,
+      connected: Boolean(connection),
+      activeProvider: connection?.activeProvider || null,
+      configuredProviders: connection?.configuredProviders || [],
+      projectPath: connection?.projectPath || null,
+      supportedModes: platform.supportedModes,
+      connectionMeta: connection
+        ? {
+            optionKeys: Object.keys(connection.connectionOptions || {}),
+            hasAllowFrom: typeof connection.connectionOptions?.allow_from === 'string'
+          }
+        : null
+    };
+  });
+}

package/server/utils/resolveCommandPath.js

@@ -0,0 +1,71 @@
+import { constants as fsConstants } from 'fs';
+import fs from 'fs/promises';
+import path from 'path';
+
+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;
+  }
+}
+
+export 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`
+  };
+}