@axhub/genie 0.2.11 → 0.2.12

package/server/routes/cc-connect.js

@@ -27,6 +27,7 @@ import {
 const router = express.Router();
 
 const CC_CONNECT_COMMAND = 'cc-connect';
+const CC_CONNECT_NPM_PACKAGE = 'cc-connect@latest';
 const COMMAND_TIMEOUT_MS = 5000;
 const INSTALL_TIMEOUT_MS = 120000;
 const DAEMON_COMMAND_TIMEOUT_MS = 20000;
@@ -772,17 +773,17 @@ router.get('/platforms', async (req, res) => {
 router.post('/install', async (req, res) => {
   try {
     const existing = await getCcConnectStatus();
-    if (existing.installed && existing.isBeta) {
+    if (existing.installed && !existing.isBeta) {
       return res.json({
         success: true,
         version: existing.version,
-        message: 'cc-connect@beta is already installed.'
+        message: 'cc-connect is already installed.'
       });
     }
 
     const result = runCommandSync({
       command: getNpmCommand(),
-      args: ['install', '-g', 'cc-connect@beta'],
+      args: ['install', '-g', CC_CONNECT_NPM_PACKAGE],
       timeoutMs: INSTALL_TIMEOUT_MS,
       env: buildCommandEnv()
     });
@@ -798,7 +799,7 @@ router.post('/install', async (req, res) => {
     return res.json({
       success: true,
       version: installed.version,
-      message: 'cc-connect@beta installed successfully.'
+      message: 'cc-connect installed successfully.'
     });
   } catch (error) {
     return res.status(500).json({ success: false, error: error.message });

package/server/routes/codex.js

@@ -8,6 +8,10 @@ import {
   getCodexSessionMessages,
   getCodexSessions
 } from '../projects.js';
+import {
+  buildCodexImagePlaygroundLaunch,
+  resolveCodexImagePlaygroundConfig
+} from '../utils/codexImagePlayground.js';
 
 const router = express.Router();
 const CODEX_CONFIG_PATH = path.join(os.homedir(), '.codex', 'config.toml');
@@ -66,6 +70,26 @@ router.get('/config', async (_req, res) => {
   }
 });
 
+router.get('/image-playground/launch', async (req, res) => {
+  try {
+    const projectPath = typeof req.query.projectPath === 'string' && req.query.projectPath.trim()
+      ? req.query.projectPath.trim()
+      : null;
+    const config = await resolveCodexImagePlaygroundConfig({ projectPath });
+    const routePath = typeof req.query.routePath === 'string' && req.query.routePath.trim()
+      ? req.query.routePath.trim()
+      : '/image-playground';
+
+    res.json({
+      success: true,
+      launch: buildCodexImagePlaygroundLaunch({ routePath, config })
+    });
+  } catch (error) {
+    console.error('Error building Codex image playground launch:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
 router.get('/sessions', async (req, res) => {
   const projectPath = String(req.query.projectPath || '').trim();
 

package/server/routes/commands.js

@@ -4,6 +4,7 @@ import os from 'os';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import matter from 'gray-matter';
+import { spawnCommand } from '../utils/spawnCommand.js';
 import {
   CLAUDE_MODELS,
   CODEX_MODELS,
@@ -35,6 +36,15 @@ const FALLBACK_PROVIDER_MODELS = {
   opencode: OPENCODE_MODELS.OPTIONS.map((option) => option.value)
 };
 
+const SKILLS_LIST_TIMEOUT_MS = 5000;
+const PROVIDER_AGENT_NAMES = {
+  claude: 'Claude Code',
+  codex: 'Codex',
+  openai: 'Codex',
+  gemini: 'Gemini',
+  opencode: 'OpenCode'
+};
+
 function trimText(value) {
   return typeof value === 'string' ? value.trim() : '';
 }
@@ -80,6 +90,136 @@ function inferDescription(frontmatter, markdownBody) {
   return firstMeaningfulLine.replace(/^#+\s*/, '').trim() || 'Custom slash command';
 }
 
+function providerAgentName(provider) {
+  return PROVIDER_AGENT_NAMES[trimText(provider).toLowerCase()] || '';
+}
+
+function normalizeSlashName(value) {
+  const normalized = trimText(value);
+  if (!normalized) return '';
+  return normalized.startsWith('/') ? normalized : `/${normalized}`;
+}
+
+async function inferSkillDescription(skillPath) {
+  const normalizedPath = trimText(skillPath);
+  if (!normalizedPath) {
+    return 'Project skill';
+  }
+
+  try {
+    const rawDocument = await fs.readFile(path.join(normalizedPath, 'SKILL.md'), 'utf8');
+    const parsedDocument = matter(rawDocument);
+    const explicit = trimText(parsedDocument.data?.description);
+    if (explicit) {
+      return explicit;
+    }
+
+    const firstMeaningfulLine = parsedDocument.content
+      .split('\n')
+      .map((line) => line.trim())
+      .find((line) => line && !line.startsWith('---'));
+
+    return firstMeaningfulLine?.replace(/^#+\s*/, '').trim() || 'Project skill';
+  } catch {
+    return 'Project skill';
+  }
+}
+
+function parseSkillsListOutput(stdout) {
+  if (!trimText(stdout)) {
+    return [];
+  }
+
+  const parsed = JSON.parse(stdout);
+  return Array.isArray(parsed) ? parsed : [];
+}
+
+async function runProjectSkillsList(projectPath) {
+  return new Promise((resolve) => {
+    const command = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    const child = spawnCommand(command, ['skills', 'ls', '--json'], {
+      cwd: projectPath,
+      env: {
+        ...process.env,
+        DISABLE_TELEMETRY: process.env.DISABLE_TELEMETRY ?? '1'
+      },
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+
+    const timer = setTimeout(() => {
+      child.kill?.();
+      finish([]);
+    }, SKILLS_LIST_TIMEOUT_MS);
+
+    child.stdout?.setEncoding?.('utf8');
+    child.stderr?.setEncoding?.('utf8');
+    child.stdout?.on('data', (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr?.on('data', (chunk) => {
+      stderr += chunk;
+    });
+    child.on('error', () => finish([]));
+    child.on('close', (code) => {
+      if (code !== 0) {
+        finish([]);
+        return;
+      }
+
+      try {
+        finish(parseSkillsListOutput(stdout));
+      } catch {
+        finish([]);
+      }
+    });
+  });
+}
+
+async function listProjectSkills(projectPath, provider) {
+  const normalizedProjectPath = trimText(projectPath);
+  const targetAgent = providerAgentName(provider);
+  if (!normalizedProjectPath || !targetAgent) {
+    return [];
+  }
+
+  const rawSkills = await runProjectSkillsList(normalizedProjectPath);
+  const normalizedSkills = [];
+
+  for (const skill of rawSkills) {
+    if (!skill || typeof skill !== 'object') continue;
+
+    const name = normalizeSlashName(skill.name);
+    const agents = Array.isArray(skill.agents)
+      ? skill.agents.map((agent) => trimText(agent)).filter(Boolean)
+      : [];
+    if (!name || !agents.includes(targetAgent)) continue;
+
+    const skillPath = trimText(skill.path);
+    normalizedSkills.push({
+      name,
+      path: skillPath,
+      scope: trimText(skill.scope) || 'project',
+      agents,
+      namespace: 'skill',
+      type: 'skill',
+      source: 'skill',
+      description: await inferSkillDescription(skillPath)
+    });
+  }
+
+  return normalizedSkills.sort((left, right) => left.name.localeCompare(right.name));
+}
+
 async function walkCommandTree(rootPath, namespace) {
   const collected = [];
 
@@ -345,9 +485,11 @@ async function runBuiltinCommand(commandName, args, context) {
 router.post('/list', async (req, res) => {
   try {
     const projectPath = trimText(req.body?.projectPath);
+    const provider = trimText(req.body?.provider);
     const builtin = BUILTIN_COMMANDS.map(toBuiltinRecord);
     const discoveredRoots = commandRootsFor(projectPath);
     const custom = [];
+    const skills = await listProjectSkills(projectPath, provider);
 
     for (const root of discoveredRoots) {
       custom.push(...await walkCommandTree(root.rootPath, root.namespace));
@@ -355,8 +497,9 @@ router.post('/list', async (req, res) => {
 
     res.json({
       builtIn: builtin,
+      skills,
       custom,
-      count: builtin.length + custom.length
+      count: builtin.length + skills.length + custom.length
     });
   } catch (error) {
     console.error('Error listing commands:', error);