@cloudcli-ai/cloudcli 1.36.3 → 1.37.1

package/dist-server/server/modules/cli/tests/cli.service.test.js

@@ -0,0 +1,78 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createCliService } from '../cli.service.js';
+function createHarness() {
+    const logMessages = [];
+    const errorMessages = [];
+    const environment = {};
+    const output = {
+        log: (message = '') => logMessages.push(message),
+        error: (message = '') => errorMessages.push(message),
+    };
+    let serverStarts = 0;
+    let sandboxArguments = [];
+    const service = createCliService({
+        applicationRoot: '/application',
+        defaultDatabasePath: '/home/user/.cloudcli/auth.db',
+        homeDirectory: '/home/user',
+        packageMetadata: {
+            version: '1.2.3',
+            homepage: 'https://cloudcli.example',
+            bugsUrl: 'https://cloudcli.example/issues',
+        },
+        environment,
+        fileSystem: {
+            readTextFile: () => {
+                throw new Error('missing');
+            },
+            pathExists: () => false,
+            getFileStats: () => ({ size: 0, modifiedAt: new Date(0) }),
+        },
+        output,
+        sandboxService: {
+            execute: async (argumentsList) => {
+                sandboxArguments = argumentsList;
+                return 7;
+            },
+        },
+        getLatestPackageVersion: async () => '1.2.3',
+        updateGlobalPackage: () => undefined,
+        startServer: async () => {
+            serverStarts += 1;
+        },
+        startBrowserUseMcp: async () => undefined,
+    });
+    return {
+        service,
+        environment,
+        logMessages,
+        errorMessages,
+        getServerStarts: () => serverStarts,
+        getSandboxArguments: () => sandboxArguments,
+    };
+}
+test('applies CLI options to the injected environment before starting the server', async () => {
+    const harness = createHarness();
+    const exitCode = await harness.service.run([
+        '--port',
+        '8080',
+        '--database-path=/data/app.db',
+    ]);
+    assert.equal(exitCode, 0);
+    assert.equal(harness.environment.SERVER_PORT, '8080');
+    assert.equal(harness.environment.DATABASE_PATH, '/data/app.db');
+    assert.equal(harness.getServerStarts(), 1);
+});
+test('passes only sandbox arguments to the injected sandbox service', async () => {
+    const harness = createHarness();
+    const exitCode = await harness.service.run(['sandbox', 'ls']);
+    assert.equal(exitCode, 7);
+    assert.deepEqual(harness.getSandboxArguments(), ['ls']);
+});
+test('returns a failure code for an unknown command without exiting the process', async () => {
+    const harness = createHarness();
+    const exitCode = await harness.service.run(['unknown']);
+    assert.equal(exitCode, 1);
+    assert.match(harness.errorMessages[0], /Unknown command: unknown/);
+});
+//# sourceMappingURL=cli.service.test.js.map

package/dist-server/server/modules/cli/tests/cli.service.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.service.test.js","sourceRoot":"","sources":["../../../../../server/modules/cli/tests/cli.service.test.ts"],"names":[],"mappings":"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"}

package/dist-server/server/modules/cli/tests/sandbox.service.test.js

@@ -0,0 +1,55 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createSandboxCommandService } from '../sandbox.service.js';
+test('creates a sandbox through injected filesystem, subprocess, and clock adapters', async () => {
+    const commands = [];
+    const detachedCommands = [];
+    const waits = [];
+    const service = createSandboxCommandService({
+        homeDirectory: '/home/user',
+        fileSystem: {
+            pathExists: (candidatePath) => candidatePath === '/home/user/project',
+        },
+        output: { log: () => undefined, error: () => undefined },
+        runSandboxCommand: (argumentsList) => {
+            commands.push(argumentsList);
+            return argumentsList[0] === 'secret' ? 'anthropic' : '';
+        },
+        spawnDetachedSandbox: (argumentsList) => detachedCommands.push(argumentsList),
+        wait: async (milliseconds) => {
+            waits.push(milliseconds);
+        },
+    });
+    const exitCode = await service.execute(['~/project']);
+    assert.equal(exitCode, 0);
+    assert.deepEqual(detachedCommands, [[
+            'run',
+            '--template',
+            'docker.io/cloudcliai/sandbox:claude-code',
+            '--name',
+            'project',
+            'claude',
+            '/home/user/project',
+        ]]);
+    assert.deepEqual(waits, [5_000]);
+    assert.ok(commands.some((argumentsList) => argumentsList[0] === 'ports'));
+});
+test('does not spawn when the workspace does not exist', async () => {
+    let detachedCalls = 0;
+    const service = createSandboxCommandService({
+        homeDirectory: '/home/user',
+        fileSystem: {
+            pathExists: () => false,
+        },
+        output: { log: () => undefined, error: () => undefined },
+        runSandboxCommand: () => '',
+        spawnDetachedSandbox: () => {
+            detachedCalls += 1;
+        },
+        wait: async () => undefined,
+    });
+    const exitCode = await service.execute(['/missing']);
+    assert.equal(exitCode, 1);
+    assert.equal(detachedCalls, 0);
+});
+//# sourceMappingURL=sandbox.service.test.js.map

package/dist-server/server/modules/cli/tests/sandbox.service.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox.service.test.js","sourceRoot":"","sources":["../../../../../server/modules/cli/tests/sandbox.service.test.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,oBAAoB,CAAC;AACxC,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B,OAAO,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAC;AAEpE,IAAI,CAAC,+EAA+E,EAAE,KAAK,IAAI,EAAE;IAC/F,MAAM,QAAQ,GAAe,EAAE,CAAC;IAChC,MAAM,gBAAgB,GAAe,EAAE,CAAC;IACxC,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,MAAM,OAAO,GAAG,2BAA2B,CAAC;QAC1C,aAAa,EAAE,YAAY;QAC3B,UAAU,EAAE;YACV,UAAU,EAAE,CAAC,aAAa,EAAE,EAAE,CAAC,aAAa,KAAK,oBAAoB;SACtE;QACD,MAAM,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,SAAS,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,SAAS,EAAE;QACxD,iBAAiB,EAAE,CAAC,aAAa,EAAE,EAAE;YACnC,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YAC7B,OAAO,aAAa,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC;QAC1D,CAAC;QACD,oBAAoB,EAAE,CAAC,aAAa,EAAE,EAAE,CAAC,gBAAgB,CAAC,IAAI,CAAC,aAAa,CAAC;QAC7E,IAAI,EAAE,KAAK,EAAE,YAAY,EAAE,EAAE;YAC3B,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAC3B,CAAC;KACF,CAAC,CAAC;IAEH,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC;IAEtD,MAAM,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;IAC1B,MAAM,CAAC,SAAS,CAAC,gBAAgB,EAAE,CAAC;YAClC,KAAK;YACL,YAAY;YACZ,0CAA0C;YAC1C,QAAQ;YACR,SAAS;YACT,QAAQ;YACR,oBAAoB;SACrB,CAAC,CAAC,CAAC;IACJ,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IACjC,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,aAAa,EAAE,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC;AAC5E,CAAC,CAAC,CAAC;AAEH,IAAI,CAAC,kDAAkD,EAAE,KAAK,IAAI,EAAE;IAClE,IAAI,aAAa,GAAG,CAAC,CAAC;IACtB,MAAM,OAAO,GAAG,2BAA2B,CAAC;QAC1C,aAAa,EAAE,YAAY;QAC3B,UAAU,EAAE;YACV,UAAU,EAAE,GAAG,EAAE,CAAC,KAAK;SACxB;QACD,MAAM,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,SAAS,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,SAAS,EAAE;QACxD,iBAAiB,EAAE,GAAG,EAAE,CAAC,EAAE;QAC3B,oBAAoB,EAAE,GAAG,EAAE;YACzB,aAAa,IAAI,CAAC,CAAC;QACrB,CAAC;QACD,IAAI,EAAE,KAAK,IAAI,EAAE,CAAC,SAAS;KAC5B,CAAC,CAAC;IAEH,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;IAErD,MAAM,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;IAC1B,MAAM,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;AACjC,CAAC,CAAC,CAAC"}

package/dist-server/server/modules/commands/commands.module.js

@@ -0,0 +1,20 @@
+import * as fs from 'node:fs/promises';
+import os from 'node:os';
+import { providerModelsService } from '../../modules/providers/index.js';
+import { findApplicationRoot, getModuleDirectory } from '../../shared/utils.js';
+import { createCommandsRouter } from './commands.routes.js';
+/** Commands router assembled for the authenticated server mount. */
+export const commandsRoutes = createCommandsRouter({
+    fileSystem: fs,
+    homeDirectory: os.homedir,
+    appRoot: findApplicationRoot(getModuleDirectory(import.meta.url)),
+    models: providerModelsService,
+    runtime: {
+        uptime: process.uptime,
+        memoryUsage: process.memoryUsage,
+        version: process.version,
+        platform: process.platform,
+        pid: process.pid,
+    },
+});
+//# sourceMappingURL=commands.module.js.map

package/dist-server/server/modules/commands/commands.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.module.js","sourceRoot":"","sources":["../../../../server/modules/commands/commands.module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACvC,OAAO,EAAE,MAAM,SAAS,CAAC;AAEzB,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAE5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAE5D,oEAAoE;AACpE,MAAM,CAAC,MAAM,cAAc,GAAG,oBAAoB,CAAC;IACjD,UAAU,EAAE,EAAE;IACd,aAAa,EAAE,EAAE,CAAC,OAAO;IACzB,OAAO,EAAE,mBAAmB,CAAC,kBAAkB,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACjE,MAAM,EAAE,qBAAqB;IAC7B,OAAO,EAAE;QACP,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,WAAW,EAAE,OAAO,CAAC,WAAW;QAChC,OAAO,EAAE,OAAO,CAAC,OAAO;QACxB,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,GAAG,EAAE,OAAO,CAAC,GAAG;KACjB;CACF,CAAC,CAAC"}

package/dist-server/server/modules/commands/commands.routes.js

@@ -0,0 +1,497 @@
+// @ts-nocheck -- temporary while command handlers are extracted into the injected service.
+import path from "path";
+import express from "express";
+import { parseFrontMatter } from "../../shared/frontmatter.js";
+/** Creates Commands routes around explicit filesystem, model-catalog, and runtime adapters. */
+export function createCommandsRouter(dependencies) {
+    const fs = dependencies.fileSystem;
+    const os = { homedir: dependencies.homeDirectory };
+    const APP_ROOT = dependencies.appRoot;
+    const providerModelsService = dependencies.models;
+    const process = dependencies.runtime;
+    const router = express.Router();
+    const MODEL_PROVIDERS = ["claude", "cursor", "codex", "opencode"];
+    const MODEL_PROVIDER_LABELS = {
+        claude: "Claude",
+        cursor: "Cursor",
+        codex: "Codex",
+        opencode: "OpenCode",
+    };
+    const readModelProvider = (value) => {
+        if (typeof value !== "string") {
+            return "claude";
+        }
+        const normalized = value.trim().toLowerCase();
+        return MODEL_PROVIDERS.includes(normalized) ? normalized : "claude";
+    };
+    /**
+     * Resolves the model a command should report.
+     *
+     * `context.model` is what the composer would send right now, so it stands in
+     * for a chat that has no session row yet; the service prefers the session's own
+     * recorded model whenever there is one.
+     */
+    const resolveCommandModel = async (modelsService, provider, context) => {
+        const resolved = await modelsService.resolveSessionModel(provider, {
+            sessionId: context?.sessionId,
+            requestedModel: context?.model,
+        });
+        return resolved.model;
+    };
+    const executeModelsCommand = async (args, context, modelsService) => {
+        const currentProvider = readModelProvider(context?.provider);
+        const catalog = await modelsService.getProviderModels(currentProvider);
+        const currentModel = await resolveCommandModel(modelsService, currentProvider, context);
+        const availableModels = catalog.OPTIONS.map((option) => option.value);
+        const availableOptions = catalog.OPTIONS.map((option) => ({
+            value: option.value,
+            label: option.label,
+            description: option.description,
+            recordId: option.recordId,
+            isCustom: option.isCustom,
+        }));
+        return {
+            type: "builtin",
+            action: "models",
+            data: {
+                current: {
+                    provider: currentProvider,
+                    providerLabel: MODEL_PROVIDER_LABELS[currentProvider],
+                    model: currentModel,
+                },
+                available: {
+                    [currentProvider]: availableModels,
+                },
+                availableModels,
+                availableOptions,
+                defaultModel: catalog.DEFAULT,
+                message: `Current model: ${currentModel}`,
+            },
+        };
+    };
+    /**
+     * Recursively scan directory for command files (.md)
+     * @param {string} dir - Directory to scan
+     * @param {string} baseDir - Base directory for relative paths
+     * @param {string} namespace - Namespace for commands (e.g., 'project', 'user')
+     * @returns {Promise<Array>} Array of command objects
+     */
+    async function scanCommandsDirectory(dir, baseDir, namespace) {
+        const commands = [];
+        try {
+            // Check if directory exists
+            await fs.access(dir);
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    // Recursively scan subdirectories
+                    const subCommands = await scanCommandsDirectory(fullPath, baseDir, namespace);
+                    commands.push(...subCommands);
+                }
+                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);
+                        // 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, "/");
+                        // Extract description from frontmatter or first line of content
+                        let description = frontmatter.description || "";
+                        if (!description) {
+                            const firstLine = commandContent.trim().split("\n")[0];
+                            description = firstLine.replace(/^#+\s*/, "").trim();
+                        }
+                        commands.push({
+                            name: commandName,
+                            path: fullPath,
+                            relativePath,
+                            description,
+                            namespace,
+                            metadata: frontmatter,
+                        });
+                    }
+                    catch (err) {
+                        console.error(`Error parsing command file ${fullPath}:`, err.message);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            // Directory doesn't exist or can't be accessed - this is okay
+            if (err.code !== "ENOENT" && err.code !== "EACCES") {
+                console.error(`Error scanning directory ${dir}:`, err.message);
+            }
+        }
+        return commands;
+    }
+    /**
+     * Built-in commands that are always available
+     */
+    const builtInCommands = [
+        {
+            name: "/help",
+            description: "Show help documentation for Claude Code",
+            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 information",
+            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: "/status",
+            description: "Show system status and version information",
+            namespace: "builtin",
+            metadata: { type: "builtin" },
+        },
+    ];
+    /**
+     * Built-in command handlers
+     * Each handler returns { type: 'builtin', action: string, data: any }
+     */
+    const builtInHandlers = {
+        "/help": async (args, context) => {
+            const helpText = `# Claude Code Commands
+
+## Built-in Commands
+
+${builtInCommands
+                .map((cmd) => `### ${cmd.name}
+${cmd.description}
+`)
+                .join("\n")}
+
+## Custom Commands
+
+Custom commands can be created in:
+- Project: \`.claude/commands/\` (project-specific)
+- User: \`~/.claude/commands/\` (available in all projects)
+
+### Command Syntax
+
+- **Arguments**: Use \`$ARGUMENTS\` for all args or \`$1\`, \`$2\`, etc. for positional
+- **File Includes**: Use \`@filename\` to include file contents
+- **Bash Commands**: Use \`!command\` to execute bash commands
+
+### Examples
+
+\`\`\`markdown
+/mycommand arg1 arg2
+\`\`\`
+`;
+            return {
+                type: "builtin",
+                action: "help",
+                data: {
+                    content: helpText,
+                    format: "markdown",
+                    commands: builtInCommands.map((command) => ({
+                        name: command.name,
+                        description: command.description,
+                        namespace: command.namespace,
+                    })),
+                },
+            };
+        },
+        "/models": (args, context) => executeModelsCommand(args, context, providerModelsService),
+        "/cost": async (args, context) => {
+            const tokenUsage = context?.tokenUsage || {};
+            const provider = readModelProvider(context?.provider);
+            const model = await resolveCommandModel(providerModelsService, provider, context);
+            const reportedUsed = Number(tokenUsage.used ?? tokenUsage.totalUsed ?? tokenUsage.total_tokens ?? 0) || 0;
+            const total = Number(tokenUsage.total ??
+                tokenUsage.contextWindow ??
+                0) || 0;
+            const normalizedInputValue = tokenUsage.inputTokens ??
+                tokenUsage.input ??
+                tokenUsage.cumulativeInputTokens ??
+                tokenUsage.breakdown?.input ??
+                tokenUsage.promptTokens;
+            const directInputTokens = Number(normalizedInputValue ??
+                tokenUsage.input_tokens ??
+                0) || 0;
+            const cacheReadTokens = Number(tokenUsage.cacheReadTokens ??
+                tokenUsage.cache_read_input_tokens ??
+                tokenUsage.cacheReadInputTokens ??
+                0) || 0;
+            const cacheCreationTokens = Number(tokenUsage.cacheCreationTokens ??
+                tokenUsage.cache_creation_input_tokens ??
+                tokenUsage.cacheCreationInputTokens ??
+                0) || 0;
+            const inputTokens = normalizedInputValue == null
+                ? directInputTokens + cacheReadTokens + cacheCreationTokens
+                : directInputTokens;
+            const outputTokens = Number(tokenUsage.outputTokens ??
+                tokenUsage.output ??
+                tokenUsage.output_tokens ??
+                tokenUsage.cumulativeOutputTokens ??
+                tokenUsage.breakdown?.output ??
+                tokenUsage.completionTokens ??
+                0) || 0;
+            const computedUsed = inputTokens + outputTokens;
+            const hasTokenBreakdown = computedUsed > 0;
+            const used = Math.max(reportedUsed, computedUsed);
+            return {
+                type: "builtin",
+                action: "cost",
+                data: {
+                    tokenUsage: {
+                        used,
+                        total,
+                    },
+                    ...(hasTokenBreakdown
+                        ? {
+                            tokenBreakdown: {
+                                input: inputTokens,
+                                output: outputTokens,
+                            },
+                        }
+                        : {}),
+                    provider,
+                    model,
+                },
+            };
+        },
+        "/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";
+            try {
+                const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
+                version = packageJson.version;
+                packageName = packageJson.name;
+            }
+            catch (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 statusProvider = readModelProvider(context?.provider);
+            const model = await resolveCommandModel(providerModelsService, statusProvider, context);
+            const memoryUsage = process.memoryUsage();
+            return {
+                type: "builtin",
+                action: "status",
+                data: {
+                    version,
+                    packageName,
+                    uptime: uptimeFormatted,
+                    uptimeSeconds: Math.floor(uptime),
+                    model,
+                    provider: statusProvider,
+                    nodeVersion: process.version,
+                    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) => {
+            const projectPath = context?.projectPath;
+            if (!projectPath) {
+                return {
+                    type: "builtin",
+                    action: "memory",
+                    data: {
+                        error: "No project selected",
+                        message: "Please select a project to access its CLAUDE.md file",
+                    },
+                };
+            }
+            const claudeMdPath = path.join(projectPath, "CLAUDE.md");
+            // Check if CLAUDE.md exists
+            let exists = false;
+            try {
+                await fs.access(claudeMdPath);
+                exists = true;
+            }
+            catch (err) {
+                // File doesn't exist
+            }
+            return {
+                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.`,
+                },
+            };
+        },
+        "/config": async (args, context) => {
+            return {
+                type: "builtin",
+                action: "config",
+                data: {
+                    message: "Opening settings...",
+                },
+            };
+        },
+    };
+    /**
+     * POST /api/commands/list
+     * List all available commands from project and user directories
+     */
+    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 projectCommands = await scanCommandsDirectory(projectCommandsDir, projectCommandsDir, "project");
+                allCommands.push(...projectCommands);
+            }
+            // Scan user-level commands (~/.claude/commands/)
+            const homeDir = os.homedir();
+            const userCommandsDir = path.join(homeDir, ".claude", "commands");
+            const userCommands = await scanCommandsDirectory(userCommandsDir, userCommandsDir, "user");
+            allCommands.push(...userCommands);
+            // Separate built-in and custom commands
+            const customCommands = allCommands.filter((cmd) => cmd.namespace !== "builtin");
+            // Sort commands alphabetically by name
+            customCommands.sort((a, b) => a.name.localeCompare(b.name));
+            res.json({
+                builtIn: builtInCommands,
+                custom: customCommands,
+                count: allCommands.length,
+            });
+        }
+        catch (error) {
+            console.error("Error listing commands:", error);
+            res.status(500).json({
+                error: "Failed to list commands",
+                message: error.message,
+            });
+        }
+    });
+    /**
+     * POST /api/commands/execute
+     * Execute a command with argument replacement
+     * 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) => {
+        try {
+            const { commandName, commandPath, args = [], context = {} } = req.body;
+            if (!commandName) {
+                return res.status(400).json({
+                    error: "Command name is required",
+                });
+            }
+            // Handle built-in commands
+            const handler = builtInHandlers[commandName];
+            if (handler) {
+                try {
+                    const result = await handler(args, context);
+                    return res.json({
+                        ...result,
+                        command: commandName,
+                    });
+                }
+                catch (error) {
+                    console.error(`Error executing built-in command ${commandName}:`, error);
+                    return res.status(500).json({
+                        error: "Command execution failed",
+                        message: error.message,
+                        command: commandName,
+                    });
+                }
+            }
+            // Handle custom commands
+            if (!commandPath) {
+                return res.status(400).json({
+                    error: "Command path is required for custom commands",
+                });
+            }
+            // Load command content
+            // Security: validate commandPath is within allowed directories
+            {
+                const resolvedPath = path.resolve(commandPath);
+                const userBase = path.resolve(path.join(os.homedir(), ".claude", "commands"));
+                const projectBase = context?.projectPath
+                    ? 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);
+                };
+                if (!(isUnder(userBase) || (projectBase && isUnder(projectBase)))) {
+                    return res.status(403).json({
+                        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);
+            // Basic argument replacement (will be enhanced in command parser utility)
+            let processedContent = commandContent;
+            // Replace $ARGUMENTS with all arguments joined
+            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);
+            });
+            res.json({
+                type: "custom",
+                command: commandName,
+                content: processedContent,
+                metadata,
+                hasFileIncludes: processedContent.includes("@"),
+                hasBashCommands: processedContent.includes("!"),
+            });
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return res.status(404).json({
+                    error: "Command not found",
+                    message: `Command file not found: ${req.body.commandPath}`,
+                });
+            }
+            console.error("Error executing command:", error);
+            res.status(500).json({
+                error: "Failed to execute command",
+                message: error.message,
+            });
+        }
+    });
+    return router;
+}
+//# sourceMappingURL=commands.routes.js.map