@axhub/genie 0.2.10 → 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,
@@ -17,15 +18,16 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const PACKAGE_JSON_PATH = path.join(__dirname, '..', '..', 'package.json');
 
-const BUILTIN_COMMANDS = [
-  { name: '/help', description: 'Show the built-in and custom slash commands available here.' },
-  { name: '/clear', description: 'Clear the current in-memory conversation preview.' },
-  { name: '/model', description: 'Show the active model and available provider model lists.' },
-  { name: '/memory', description: 'Open the project-level CLAUDE.md memory file.' },
-  { name: '/config', description: 'Open the local settings modal.' },
-  { name: '/status', description: 'Show runtime metadata for the local Genie server.' },
-  { name: '/rewind', description: 'Drop the last N user/assistant turns from the current chat.' }
-];
+const BUILTIN_COMMANDS = [];
+const DISABLED_BUILTIN_COMMANDS = new Set([
+  '/help',
+  '/clear',
+  '/model',
+  '/memory',
+  '/config',
+  '/status',
+  '/rewind',
+]);
 
 const FALLBACK_PROVIDER_MODELS = {
   claude: CLAUDE_MODELS.OPTIONS.map((option) => option.value),
@@ -34,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() : '';
 }
@@ -79,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 = [];
 
@@ -216,6 +357,10 @@ async function buildModelPayload(context) {
 }
 
 async function runBuiltinCommand(commandName, args, context) {
+  if (BUILTIN_COMMANDS.length === 0) {
+    return null;
+  }
+
   switch (commandName) {
     case '/help':
       return {
@@ -340,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));
@@ -350,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);
@@ -402,6 +550,14 @@ router.post('/execute', async (req, res) => {
     });
   }
 
+  if (DISABLED_BUILTIN_COMMANDS.has(commandName)) {
+    return res.status(404).json({
+      error: 'Command not found',
+      message: `${commandName} is currently disabled`,
+      command: commandName
+    });
+  }
+
   try {
     const builtinResult = await runBuiltinCommand(commandName, args, context);
     if (builtinResult) {