@glwhappen/web-code 1.32.9 → 1.32.10

package/server/routes/commands.js

@@ -1,12 +1,12 @@
-import { promises as fs } from 'fs';
-import os from 'os';
-import path from 'path';
+import { promises as fs } from "fs";
+import os from "os";
+import path from "path";
 
-import express from 'express';
+import express from "express";
 
-import { CLAUDE_MODELS, CURSOR_MODELS, CODEX_MODELS } from '../../shared/modelConstants.js';
-import { parseFrontMatter } from '../shared/frontmatter.js';
-import { findAppRoot, getModuleDir } from '../utils/runtime-paths.js';
+import { providerModelsService } from "../modules/providers/services/provider-models.service.js";
+import { parseFrontMatter } from "../shared/frontmatter.js";
+import { findAppRoot, getModuleDir } from "../utils/runtime-paths.js";
 
 const __dirname = getModuleDir(import.meta.url);
 // This route reads the top-level package.json for the status command, so it needs the real
@@ -15,6 +15,77 @@ const APP_ROOT = findAppRoot(__dirname);
 
 const router = express.Router();
 
+const MODEL_PROVIDERS = ["claude", "cursor", "codex", "gemini", "opencode"];
+
+const MODEL_PROVIDER_LABELS = {
+  claude: "Claude",
+  cursor: "Cursor",
+  codex: "Codex",
+  gemini: "Gemini",
+  opencode: "OpenCode",
+};
+
+const readModelProvider = (value) => {
+  if (typeof value !== "string") {
+    return "claude";
+  }
+
+  const normalized = value.trim().toLowerCase();
+  return MODEL_PROVIDERS.includes(normalized) ? normalized : "claude";
+};
+
+const hasConcreteSessionId = (value) =>
+  typeof value === "string" && value.trim().length > 0;
+
+const resolveCommandModel = async (provider, catalog, sessionId) => {
+  if (!hasConcreteSessionId(sessionId)) {
+    return catalog.DEFAULT;
+  }
+
+  const currentActiveModel = await providerModelsService.getCurrentActiveModel(
+    provider,
+    sessionId,
+  );
+  return currentActiveModel?.model || catalog.DEFAULT;
+};
+
+export const executeModelsCommand = async (args, context) => {
+  const currentProvider = readModelProvider(context?.provider);
+  const result = await providerModelsService.getProviderModels(currentProvider);
+  const catalog = result.models;
+  const currentModel = await resolveCommandModel(
+    currentProvider,
+    catalog,
+    context?.sessionId,
+  );
+  const availableModels = catalog.OPTIONS.map((option) => option.value);
+  const availableOptions = catalog.OPTIONS.map((option) => ({
+    value: option.value,
+    label: option.label,
+    description: option.description,
+  }));
+
+  return {
+    type: "builtin",
+    action: "models",
+    data: {
+      current: {
+        provider: currentProvider,
+        providerLabel: MODEL_PROVIDER_LABELS[currentProvider],
+        model: currentModel,
+      },
+      available: {
+        [currentProvider]: availableModels,
+      },
+      availableModels,
+      availableOptions,
+      defaultModel: catalog.DEFAULT,
+      cache: result.cache,
+      message: `Current model: ${currentModel}`,
+    },
+  };
+};
+
 /**
  * Recursively scan directory for command files (.md)
  * @param {string} dir - Directory to scan
@@ -36,24 +107,30 @@ async function scanCommandsDirectory(dir, baseDir, namespace) {
 
       if (entry.isDirectory()) {
         // Recursively scan subdirectories
-        const subCommands = await scanCommandsDirectory(fullPath, baseDir, namespace);
+        const subCommands = await scanCommandsDirectory(
+          fullPath,
+          baseDir,
+          namespace,
+        );
         commands.push(...subCommands);
-      } else if (entry.isFile() && entry.name.endsWith('.md')) {
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
         // Parse markdown file for metadata
         try {
-          const content = await fs.readFile(fullPath, 'utf8');
-          const { data: frontmatter, content: commandContent } = parseFrontMatter(content);
+          const content = await fs.readFile(fullPath, "utf8");
+          const { data: frontmatter, content: commandContent } =
+            parseFrontMatter(content);
 
           // Calculate relative path from baseDir for command name
           const relativePath = path.relative(baseDir, fullPath);
           // Remove .md extension and convert to command name
-          const commandName = '/' + relativePath.replace(/\.md$/, '').replace(/\\/g, '/');
+          const commandName =
+            "/" + relativePath.replace(/\.md$/, "").replace(/\\/g, "/");
 
           // Extract description from frontmatter or first line of content
-          let description = frontmatter.description || '';
+          let description = frontmatter.description || "";
           if (!description) {
-            const firstLine = commandContent.trim().split('\n')[0];
-            description = firstLine.replace(/^#+\s*/, '').trim();
+            const firstLine = commandContent.trim().split("\n")[0];
+            description = firstLine.replace(/^#+\s*/, "").trim();
           }
 
           commands.push({
@@ -62,7 +139,7 @@ async function scanCommandsDirectory(dir, baseDir, namespace) {
             relativePath,
             description,
             namespace,
-            metadata: frontmatter
+            metadata: frontmatter,
           });
         } catch (err) {
           console.error(`Error parsing command file ${fullPath}:`, err.message);
@@ -71,7 +148,7 @@ async function scanCommandsDirectory(dir, baseDir, namespace) {
     }
   } catch (err) {
     // Directory doesn't exist or can't be accessed - this is okay
-    if (err.code !== 'ENOENT' && err.code !== 'EACCES') {
+    if (err.code !== "ENOENT" && err.code !== "EACCES") {
       console.error(`Error scanning directory ${dir}:`, err.message);
     }
   }
@@ -84,53 +161,41 @@ async function scanCommandsDirectory(dir, baseDir, namespace) {
  */
 const builtInCommands = [
   {
-    name: '/help',
-    description: 'Show help documentation for Claude Code',
-    namespace: 'builtin',
-    metadata: { type: 'builtin' }
-  },
-  {
-    name: '/clear',
-    description: 'Clear the conversation history',
-    namespace: 'builtin',
-    metadata: { type: 'builtin' }
+    name: "/help",
+    description: "Show help documentation for Claude Code",
+    namespace: "builtin",
+    metadata: { type: "builtin" },
   },
   {
-    name: '/model',
-    description: 'Switch or view the current AI model',
-    namespace: 'builtin',
-    metadata: { type: 'builtin' }
+    name: "/models",
+    description: "View available models for the current provider",
+    namespace: "builtin",
+    metadata: { type: "builtin" },
   },
   {
-    name: '/cost',
-    description: 'Display token usage and cost information',
-    namespace: 'builtin',
-    metadata: { type: 'builtin' }
+    name: "/cost",
+    description: "Display token usage information",
+    namespace: "builtin",
+    metadata: { type: "builtin" },
   },
   {
-    name: '/memory',
-    description: 'Open CLAUDE.md memory file for editing',
-    namespace: 'builtin',
-    metadata: { type: 'builtin' }
+    name: "/memory",
+    description: "Open CLAUDE.md memory file for editing",
+    namespace: "builtin",
+    metadata: { type: "builtin" },
   },
   {
-    name: '/config',
-    description: 'Open settings and configuration',
-    namespace: 'builtin',
-    metadata: { type: 'builtin' }
+    name: "/config",
+    description: "Open settings and configuration",
+    namespace: "builtin",
+    metadata: { type: "builtin" },
   },
   {
-    name: '/status',
-    description: 'Show system status and version information',
-    namespace: 'builtin',
-    metadata: { type: 'builtin' }
+    name: "/status",
+    description: "Show system status and version information",
+    namespace: "builtin",
+    metadata: { type: "builtin" },
   },
-  {
-    name: '/rewind',
-    description: 'Rewind the conversation to a previous state',
-    namespace: 'builtin',
-    metadata: { type: 'builtin' }
-  }
 ];
 
 /**
@@ -138,14 +203,18 @@ const builtInCommands = [
  * Each handler returns { type: 'builtin', action: string, data: any }
  */
 const builtInHandlers = {
-  '/help': async (args, context) => {
+  "/help": async (args, context) => {
     const helpText = `# Claude Code Commands
 
 ## Built-in Commands
 
-${builtInCommands.map(cmd => `### ${cmd.name}
+${builtInCommands
+  .map(
+    (cmd) => `### ${cmd.name}
 ${cmd.description}
-`).join('\n')}
+`,
+  )
+  .join("\n")}
 
 ## Custom Commands
 
@@ -167,77 +236,45 @@ Custom commands can be created in:
 `;
 
     return {
-      type: 'builtin',
-      action: 'help',
+      type: "builtin",
+      action: "help",
       data: {
         content: helpText,
-        format: 'markdown'
-      }
-    };
-  },
-
-  '/clear': async (args, context) => {
-    return {
-      type: 'builtin',
-      action: 'clear',
-      data: {
-        message: 'Conversation history cleared'
-      }
+        format: "markdown",
+        commands: builtInCommands.map((command) => ({
+          name: command.name,
+          description: command.description,
+          namespace: command.namespace,
+        })),
+      },
     };
   },
 
-  '/model': async (args, context) => {
-    // Read available models from centralized constants
-    const availableModels = {
-      claude: CLAUDE_MODELS.OPTIONS.map(o => o.value),
-      cursor: CURSOR_MODELS.OPTIONS.map(o => o.value),
-      codex: CODEX_MODELS.OPTIONS.map(o => o.value)
-    };
-
-    const currentProvider = context?.provider || 'claude';
-    const currentModel = context?.model || CLAUDE_MODELS.DEFAULT;
+  "/models": executeModelsCommand,
 
-    return {
-      type: 'builtin',
-      action: 'model',
-      data: {
-        current: {
-          provider: currentProvider,
-          model: currentModel
-        },
-        available: availableModels,
-        message: args.length > 0
-          ? `Switching to model: ${args[0]}`
-          : `Current model: ${currentModel}`
-      }
-    };
-  },
-
-  '/cost': async (args, context) => {
+  "/cost": async (args, context) => {
     const tokenUsage = context?.tokenUsage || {};
-    const provider = context?.provider || 'claude';
-    const model =
-      context?.model ||
-      (provider === 'cursor'
-        ? CURSOR_MODELS.DEFAULT
-        : provider === 'codex'
-          ? CODEX_MODELS.DEFAULT
-          : CLAUDE_MODELS.DEFAULT);
-
-    const used = Number(tokenUsage.used ?? tokenUsage.totalUsed ?? tokenUsage.total_tokens ?? 0) || 0;
+    const provider = readModelProvider(context?.provider);
+    const catalog = (await providerModelsService.getProviderModels(provider)).models;
+    const model = await resolveCommandModel(provider, catalog, context?.sessionId);
+
+    const reportedUsed =
+      Number(
+        tokenUsage.used ?? tokenUsage.totalUsed ?? tokenUsage.total_tokens ?? 0,
+      ) || 0;
     const total =
       Number(
         tokenUsage.total ??
           tokenUsage.contextWindow ??
-          parseInt(process.env.CONTEXT_WINDOW || '160000', 10),
-      ) || 160000;
-    const percentage = total > 0 ? Number(((used / total) * 100).toFixed(1)) : 0;
-
+          0,
+      ) || 0;
     const inputTokensRaw =
       Number(
         tokenUsage.inputTokens ??
           tokenUsage.input ??
+          tokenUsage.input_tokens ??
           tokenUsage.cumulativeInputTokens ??
+          tokenUsage.breakdown?.input ??
           tokenUsage.promptTokens ??
           0,
       ) || 0;
@@ -245,106 +282,103 @@ Custom commands can be created in:
       Number(
         tokenUsage.outputTokens ??
           tokenUsage.output ??
+          tokenUsage.output_tokens ??
           tokenUsage.cumulativeOutputTokens ??
+          tokenUsage.breakdown?.output ??
           tokenUsage.completionTokens ??
           0,
       ) || 0;
-    const cacheTokens =
-      Number(
-        tokenUsage.cacheReadTokens ??
-          tokenUsage.cacheCreationTokens ??
-          tokenUsage.cacheTokens ??
-          tokenUsage.cachedTokens ??
-          0,
-      ) || 0;
-
-    // If we only have total used tokens, treat them as input for display/estimation.
-    const inputTokens =
-      inputTokensRaw > 0 || outputTokens > 0 || cacheTokens > 0 ? inputTokensRaw + cacheTokens : used;
-
-    // Rough default rates by provider (USD / 1M tokens).
-    const pricingByProvider = {
-      claude: { input: 3, output: 15 },
-      cursor: { input: 3, output: 15 },
-      codex: { input: 1.5, output: 6 },
-    };
-    const rates = pricingByProvider[provider] || pricingByProvider.claude;
-
-    const inputCost = (inputTokens / 1_000_000) * rates.input;
-    const outputCost = (outputTokens / 1_000_000) * rates.output;
-    const totalCost = inputCost + outputCost;
+    const hasTokenBreakdown = inputTokensRaw > 0 || outputTokens > 0;
+    const used = reportedUsed || inputTokensRaw + outputTokens;
 
     return {
-      type: 'builtin',
-      action: 'cost',
+      type: "builtin",
+      action: "cost",
       data: {
         tokenUsage: {
           used,
           total,
-          percentage,
-        },
-        cost: {
-          input: inputCost.toFixed(4),
-          output: outputCost.toFixed(4),
-          total: totalCost.toFixed(4),
         },
+        ...(hasTokenBreakdown
+          ? {
+              tokenBreakdown: {
+                input: inputTokensRaw,
+                output: outputTokens,
+              },
+            }
+          : {}),
+        provider,
         model,
       },
     };
   },
 
-  '/status': async (args, context) => {
+  "/status": async (args, context) => {
     // Read version from package.json
-    const packageJsonPath = path.join(APP_ROOT, 'package.json');
-    let version = 'unknown';
-    let packageName = 'claude-code-ui';
+    const packageJsonPath = path.join(APP_ROOT, "package.json");
+    let version = "unknown";
+    let packageName = "claude-code-ui";
 
     try {
-      const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+      const packageJson = JSON.parse(
+        await fs.readFile(packageJsonPath, "utf8"),
+      );
       version = packageJson.version;
       packageName = packageJson.name;
     } catch (err) {
-      console.error('Error reading package.json:', err);
+      console.error("Error reading package.json:", err);
     }
 
     const uptime = process.uptime();
     const uptimeMinutes = Math.floor(uptime / 60);
     const uptimeHours = Math.floor(uptimeMinutes / 60);
-    const uptimeFormatted = uptimeHours > 0
-      ? `${uptimeHours}h ${uptimeMinutes % 60}m`
-      : `${uptimeMinutes}m`;
+    const uptimeFormatted =
+      uptimeHours > 0
+        ? `${uptimeHours}h ${uptimeMinutes % 60}m`
+        : `${uptimeMinutes}m`;
+
+    const statusProvider = readModelProvider(context?.provider);
+    const statusCatalog = (await providerModelsService.getProviderModels(statusProvider)).models;
+    const model = await resolveCommandModel(statusProvider, statusCatalog, context?.sessionId);
+    const memoryUsage = process.memoryUsage();
 
     return {
-      type: 'builtin',
-      action: 'status',
+      type: "builtin",
+      action: "status",
       data: {
         version,
         packageName,
         uptime: uptimeFormatted,
         uptimeSeconds: Math.floor(uptime),
-        model: context?.model || CLAUDE_MODELS.DEFAULT,
-        provider: context?.provider || 'claude',
+        model,
+        provider: statusProvider,
         nodeVersion: process.version,
-        platform: process.platform
-      }
+        platform: process.platform,
+        pid: process.pid,
+        memoryUsage: {
+          rssMb: Math.round(memoryUsage.rss / 1024 / 1024),
+          heapUsedMb: Math.round(memoryUsage.heapUsed / 1024 / 1024),
+          heapTotalMb: Math.round(memoryUsage.heapTotal / 1024 / 1024),
+        },
+      },
     };
   },
 
-  '/memory': async (args, context) => {
+  "/memory": async (args, context) => {
     const projectPath = context?.projectPath;
 
     if (!projectPath) {
       return {
-        type: 'builtin',
-        action: 'memory',
+        type: "builtin",
+        action: "memory",
         data: {
-          error: 'No project selected',
-          message: 'Please select a project to access its CLAUDE.md file'
-        }
+          error: "No project selected",
+          message: "Please select a project to access its CLAUDE.md file",
+        },
       };
     }
 
-    const claudeMdPath = path.join(projectPath, 'CLAUDE.md');
+    const claudeMdPath = path.join(projectPath, "CLAUDE.md");
 
     // Check if CLAUDE.md exists
     let exists = false;
@@ -356,85 +390,63 @@ Custom commands can be created in:
     }
 
     return {
-      type: 'builtin',
-      action: 'memory',
+      type: "builtin",
+      action: "memory",
       data: {
         path: claudeMdPath,
         exists,
         message: exists
           ? `Opening CLAUDE.md at ${claudeMdPath}`
-          : `CLAUDE.md not found at ${claudeMdPath}. Create it to store project-specific instructions.`
-      }
+          : `CLAUDE.md not found at ${claudeMdPath}. Create it to store project-specific instructions.`,
+      },
     };
   },
 
-  '/config': async (args, context) => {
+  "/config": async (args, context) => {
     return {
-      type: 'builtin',
-      action: 'config',
+      type: "builtin",
+      action: "config",
       data: {
-        message: 'Opening settings...'
-      }
+        message: "Opening settings...",
+      },
     };
   },
-
-  '/rewind': async (args, context) => {
-    const steps = args[0] ? parseInt(args[0]) : 1;
-
-    if (isNaN(steps) || steps < 1) {
-      return {
-        type: 'builtin',
-        action: 'rewind',
-        data: {
-          error: 'Invalid steps parameter',
-          message: 'Usage: /rewind [number] - Rewind conversation by N steps (default: 1)'
-        }
-      };
-    }
-
-    return {
-      type: 'builtin',
-      action: 'rewind',
-      data: {
-        steps,
-        message: `Rewinding conversation by ${steps} step${steps > 1 ? 's' : ''}...`
-      }
-    };
-  }
 };
 
 /**
  * POST /api/commands/list
  * List all available commands from project and user directories
  */
-router.post('/list', async (req, res) => {
+router.post("/list", async (req, res) => {
   try {
     const { projectPath } = req.body;
     const allCommands = [...builtInCommands];
 
     // Scan project-level commands (.claude/commands/)
     if (projectPath) {
-      const projectCommandsDir = path.join(projectPath, '.claude', 'commands');
+      const projectCommandsDir = path.join(projectPath, ".claude", "commands");
       const projectCommands = await scanCommandsDirectory(
         projectCommandsDir,
         projectCommandsDir,
-        'project'
+        "project",
       );
       allCommands.push(...projectCommands);
     }
 
     // Scan user-level commands (~/.claude/commands/)
     const homeDir = os.homedir();
-    const userCommandsDir = path.join(homeDir, '.claude', 'commands');
+    const userCommandsDir = path.join(homeDir, ".claude", "commands");
     const userCommands = await scanCommandsDirectory(
       userCommandsDir,
       userCommandsDir,
-      'user'
+      "user",
     );
     allCommands.push(...userCommands);
 
     // Separate built-in and custom commands
-    const customCommands = allCommands.filter(cmd => cmd.namespace !== 'builtin');
+    const customCommands = allCommands.filter(
+      (cmd) => cmd.namespace !== "builtin",
+    );
 
     // Sort commands alphabetically by name
     customCommands.sort((a, b) => a.name.localeCompare(b.name));
@@ -442,13 +454,13 @@ router.post('/list', async (req, res) => {
     res.json({
       builtIn: builtInCommands,
       custom: customCommands,
-      count: allCommands.length
+      count: allCommands.length,
     });
   } catch (error) {
-    console.error('Error listing commands:', error);
+    console.error("Error listing commands:", error);
     res.status(500).json({
-      error: 'Failed to list commands',
-      message: error.message
+      error: "Failed to list commands",
+      message: error.message,
     });
   }
 });
@@ -459,13 +471,13 @@ router.post('/list', async (req, res) => {
  * This endpoint prepares the command content but doesn't execute bash commands yet
  * (that will be handled in the command parser utility)
  */
-router.post('/execute', async (req, res) => {
+router.post("/execute", async (req, res) => {
   try {
     const { commandName, commandPath, args = [], context = {} } = req.body;
 
     if (!commandName) {
       return res.status(400).json({
-        error: 'Command name is required'
+        error: "Command name is required",
       });
     }
 
@@ -476,14 +488,17 @@ router.post('/execute', async (req, res) => {
         const result = await handler(args, context);
         return res.json({
           ...result,
-          command: commandName
+          command: commandName,
         });
       } catch (error) {
-        console.error(`Error executing built-in command ${commandName}:`, error);
+        console.error(
+          `Error executing built-in command ${commandName}:`,
+          error,
+        );
         return res.status(500).json({
-          error: 'Command execution failed',
+          error: "Command execution failed",
           message: error.message,
-          command: commandName
+          command: commandName,
         });
       }
     }
@@ -491,7 +506,7 @@ router.post('/execute', async (req, res) => {
     // Handle custom commands
     if (!commandPath) {
       return res.status(400).json({
-        error: 'Command path is required for custom commands'
+        error: "Command path is required for custom commands",
       });
     }
 
@@ -499,56 +514,62 @@ router.post('/execute', async (req, res) => {
     // Security: validate commandPath is within allowed directories
     {
       const resolvedPath = path.resolve(commandPath);
-      const userBase = path.resolve(path.join(os.homedir(), '.claude', 'commands'));
+      const userBase = path.resolve(
+        path.join(os.homedir(), ".claude", "commands"),
+      );
       const projectBase = context?.projectPath
-        ? path.resolve(path.join(context.projectPath, '.claude', 'commands'))
+        ? path.resolve(path.join(context.projectPath, ".claude", "commands"))
         : null;
       const isUnder = (base) => {
         const rel = path.relative(base, resolvedPath);
-        return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+        return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
       };
       if (!(isUnder(userBase) || (projectBase && isUnder(projectBase)))) {
         return res.status(403).json({
-          error: 'Access denied',
-          message: 'Command must be in .claude/commands directory'
+          error: "Access denied",
+          message: "Command must be in .claude/commands directory",
         });
       }
     }
-    const content = await fs.readFile(commandPath, 'utf8');
-    const { data: metadata, content: commandContent } = parseFrontMatter(content);
+    const content = await fs.readFile(commandPath, "utf8");
+    const { data: metadata, content: commandContent } =
+      parseFrontMatter(content);
     // Basic argument replacement (will be enhanced in command parser utility)
     let processedContent = commandContent;
 
     // Replace $ARGUMENTS with all arguments joined
-    const argsString = args.join(' ');
+    const argsString = args.join(" ");
     processedContent = processedContent.replace(/\$ARGUMENTS/g, argsString);
 
     // Replace $1, $2, etc. with positional arguments
     args.forEach((arg, index) => {
       const placeholder = `$${index + 1}`;
-      processedContent = processedContent.replace(new RegExp(`\\${placeholder}\\b`, 'g'), arg);
+      processedContent = processedContent.replace(
+        new RegExp(`\\${placeholder}\\b`, "g"),
+        arg,
+      );
     });
 
     res.json({
-      type: 'custom',
+      type: "custom",
       command: commandName,
       content: processedContent,
       metadata,
-      hasFileIncludes: processedContent.includes('@'),
-      hasBashCommands: processedContent.includes('!')
+      hasFileIncludes: processedContent.includes("@"),
+      hasBashCommands: processedContent.includes("!"),
     });
   } catch (error) {
-    if (error.code === 'ENOENT') {
+    if (error.code === "ENOENT") {
       return res.status(404).json({
-        error: 'Command not found',
-        message: `Command file not found: ${req.body.commandPath}`
+        error: "Command not found",
+        message: `Command file not found: ${req.body.commandPath}`,
       });
     }
 
-    console.error('Error executing command:', error);
+    console.error("Error executing command:", error);
     res.status(500).json({
-      error: 'Failed to execute command',
-      message: error.message
+      error: "Failed to execute command",
+      message: error.message,
     });
   }
 });