@bytespell/shella 0.1.3 → 0.1.5

package/dist/server/routes/directory.js

@@ -0,0 +1,84 @@
+/**
+ * Directory API Routes
+ *
+ * Provides aggregated directory metadata by calling OpenCode SDK server-side.
+ * Returns directory information including VCS branch, diffs, file counts, etc.
+ */
+import { Router } from 'express';
+import { opencodeClient } from '../lib/opencode-client.js';
+const router = Router();
+/**
+ * GET /directory/:directoryId
+ *
+ * Returns aggregated directory information:
+ * - path (from window directoryMap lookup)
+ * - branch (from OpenCode VCS API)
+ * - diff (STUB - null for now)
+ * - fileCount (STUB - null for now)
+ * - lastModified (STUB - null for now)
+ */
+router.get('/directory/:directoryId', async (req, res) => {
+    try {
+        const { directoryId } = req.params;
+        if (!directoryId) {
+            res.status(400).json({ error: 'directoryId is required' });
+            return;
+        }
+        // Get directory path from windows table
+        // Find any window with this directoryId and extract the directory from it
+        // Note: We need to query project.current or project.list from OpenCode SDK
+        // For now, we'll use a simpler approach: query OpenCode SDK for project list
+        // Get all projects from OpenCode
+        const projectsResponse = await opencodeClient.project.list();
+        const projects = projectsResponse.data || [];
+        let directoryPath = null;
+        // Match project by directoryId (which is the worktree path)
+        if (projects.length > 0) {
+            const matchingProject = projects.find((p) => p.worktree === directoryId);
+            if (matchingProject) {
+                directoryPath = matchingProject.worktree;
+            }
+        }
+        // Fallback: use directoryId as path (works in simple cases)
+        if (!directoryPath) {
+            directoryPath = directoryId;
+        }
+        // Fetch VCS info from OpenCode SDK
+        let branch = null;
+        try {
+            const vcsResponse = await opencodeClient.vcs.get({
+                directory: directoryPath,
+            });
+            branch = vcsResponse.data?.branch || null;
+        }
+        catch (err) {
+            // VCS call failed - might not be a git repo, or path doesn't exist
+            console.warn(`[directory] VCS fetch failed for ${directoryPath}:`, err);
+            branch = null;
+        }
+        // TODO: Fetch diff stats (git status)
+        // const diffResponse = await opencodeClient.file.status({ directory: directoryPath });
+        const diff = null; // STUB
+        // TODO: Fetch file count
+        // const filesResponse = await opencodeClient.file.list({ directory: directoryPath });
+        const fileCount = null; // STUB
+        // TODO: Fetch last modified time
+        // Could use fs.stat on the directory or git log
+        const lastModified = null; // STUB
+        // Return aggregated data
+        res.json({
+            path: directoryPath,
+            branch,
+            diff,
+            fileCount,
+            lastModified,
+        });
+    }
+    catch (error) {
+        console.error('[directory] API error:', error);
+        res.status(500).json({
+            error: error instanceof Error ? error.message : 'Internal server error',
+        });
+    }
+});
+export default router;

package/dist/server/routes/init.d.ts

@@ -1,5 +1,5 @@
 /**
- * Shella initialization endpoint
+ * shella initialization endpoint
  *
  * TODO: Consolidate more startup data here to reduce round-trips:
  * - windows (currently /__shella/windows)
@@ -8,8 +8,9 @@
  * - agents, config, providers (currently /api/* via OpenCode proxy)
  * - permissions (currently /api/permission via OpenCode proxy)
  *
- * For now, this just provides the projects directory info that the CLI
- * passes to the server, so the frontend knows where Shella was started.
+ * Returns mode-specific information:
+ * - cwd mode: directory info for the single working directory
+ * - server mode: projectsDir info for multi-project setup
  */
 declare const router: import("express-serve-static-core").Router;
 export default router;

package/dist/server/routes/init.js

@@ -1,5 +1,5 @@
 /**
- * Shella initialization endpoint
+ * shella initialization endpoint
  *
  * TODO: Consolidate more startup data here to reduce round-trips:
  * - windows (currently /__shella/windows)
@@ -8,18 +8,32 @@
  * - agents, config, providers (currently /api/* via OpenCode proxy)
  * - permissions (currently /api/permission via OpenCode proxy)
  *
- * For now, this just provides the projects directory info that the CLI
- * passes to the server, so the frontend knows where Shella was started.
+ * Returns mode-specific information:
+ * - cwd mode: directory info for the single working directory
+ * - server mode: projectsDir info for multi-project setup
  */
 import { Router } from 'express';
 import path from 'path';
-import { PROJECTS_DIR, VERSION } from '../index.js';
+import { MODE, DIRECTORY, PROJECTS_DIR, VERSION } from '../index.js';
 const router = Router();
 router.get('/', (_req, res) => {
-    res.json({
-        projectsDir: PROJECTS_DIR,
-        projectsDirName: path.basename(PROJECTS_DIR),
-        version: VERSION,
-    });
+    if (MODE === 'cwd') {
+        // cwd mode: single directory
+        res.json({
+            mode: 'cwd',
+            directory: DIRECTORY,
+            directoryName: DIRECTORY ? path.basename(DIRECTORY) : null,
+            version: VERSION,
+        });
+    }
+    else {
+        // server mode: multi-project
+        res.json({
+            mode: 'server',
+            projectsDir: PROJECTS_DIR,
+            projectsDirName: PROJECTS_DIR ? path.basename(PROJECTS_DIR) : null,
+            version: VERSION,
+        });
+    }
 });
 export default router;

package/dist/server/routes/local-llm.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Local LLM Routes
+ *
+ * Endpoints for validating and adding OpenAI-compatible local LLM providers
+ * (LM Studio, Ollama, llama.cpp, etc.) to the global OpenCode config.
+ */
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/server/routes/local-llm.js

@@ -0,0 +1,255 @@
+/**
+ * Local LLM Routes
+ *
+ * Endpoints for validating and adding OpenAI-compatible local LLM providers
+ * (LM Studio, Ollama, llama.cpp, etc.) to the global OpenCode config.
+ */
+import { Router } from 'express';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { opencodeClient } from '../lib/opencode-client.js';
+const router = Router();
+/** Global OpenCode config path */
+const OPENCODE_CONFIG_DIR = join(homedir(), '.config', 'opencode');
+const OPENCODE_CONFIG_PATH = join(OPENCODE_CONFIG_DIR, 'opencode.json');
+/** Timeout for validation requests (5 seconds) */
+const VALIDATION_TIMEOUT_MS = 5000;
+/**
+ * Sanitize provider name to create a valid provider ID.
+ * "LM Studio" -> "lm-studio"
+ * "My Custom Provider!" -> "my-custom-provider"
+ */
+function sanitizeProviderId(name) {
+    return name
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9]+/g, '-') // Replace non-alphanumeric with hyphens
+        .replace(/^-+|-+$/g, '') // Remove leading/trailing hyphens
+        .substring(0, 50); // Limit length
+}
+/**
+ * Read the global OpenCode config file.
+ * Returns empty config structure if file doesn't exist.
+ */
+function readOpencodeConfig() {
+    try {
+        if (existsSync(OPENCODE_CONFIG_PATH)) {
+            const content = readFileSync(OPENCODE_CONFIG_PATH, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch (err) {
+        console.error('[local-llm] Failed to read opencode.json:', err);
+    }
+    // Return default config structure
+    return {
+        $schema: 'https://opencode.ai/config.json',
+        provider: {},
+    };
+}
+/**
+ * Write the global OpenCode config file.
+ */
+function writeOpencodeConfig(config) {
+    // Ensure config directory exists
+    if (!existsSync(OPENCODE_CONFIG_DIR)) {
+        mkdirSync(OPENCODE_CONFIG_DIR, { recursive: true });
+    }
+    const content = JSON.stringify(config, null, 2);
+    writeFileSync(OPENCODE_CONFIG_PATH, content, 'utf-8');
+    console.log(`[local-llm] Wrote config to ${OPENCODE_CONFIG_PATH}`);
+}
+/**
+ * POST /validate
+ *
+ * Validates a local LLM server by fetching its /models endpoint.
+ * Returns the list of available models if successful.
+ *
+ * Request body: { baseUrl: string }
+ * Response: { success: true, models: [...] } or { success: false, error: "..." }
+ */
+router.post('/validate', async (req, res) => {
+    const { baseUrl } = req.body;
+    if (!baseUrl || typeof baseUrl !== 'string') {
+        res.status(400).json({ success: false, error: 'baseUrl is required' });
+        return;
+    }
+    // Normalize URL - remove trailing slash
+    const normalizedUrl = baseUrl.replace(/\/+$/, '');
+    // Construct models endpoint
+    const modelsUrl = normalizedUrl.endsWith('/v1')
+        ? `${normalizedUrl}/models`
+        : `${normalizedUrl}/v1/models`;
+    console.log(`[local-llm] Validating: ${modelsUrl}`);
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), VALIDATION_TIMEOUT_MS);
+        const response = await fetch(modelsUrl, {
+            method: 'GET',
+            headers: {
+                Accept: 'application/json',
+            },
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            const text = await response.text().catch(() => '');
+            res.json({
+                success: false,
+                error: `Server returned ${response.status}: ${text || response.statusText}`,
+            });
+            return;
+        }
+        const data = (await response.json());
+        if (!data.data || !Array.isArray(data.data)) {
+            res.json({
+                success: false,
+                error: 'Invalid response format: expected { data: [...] }',
+            });
+            return;
+        }
+        // Extract model info
+        const models = data.data.map((model) => ({
+            id: model.id,
+            name: model.id, // Use ID as name by default
+            owned_by: model.owned_by,
+        }));
+        console.log(`[local-llm] Found ${models.length} model(s)`);
+        res.json({ success: true, models });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const errorCode = err?.code;
+        console.log(`[local-llm] Validation failed: ${message} (code: ${errorCode})`);
+        // Provide user-friendly error messages
+        let userError = message;
+        if (errorCode === 'ECONNREFUSED' || message.includes('ECONNREFUSED')) {
+            userError = 'Connection refused. Is the server running?';
+        }
+        else if (errorCode === 'ENOTFOUND' || message.includes('ENOTFOUND')) {
+            userError = 'Host not found. Check the URL.';
+        }
+        else if (errorCode === 'ETIMEDOUT' ||
+            message.includes('abort') ||
+            message.includes('timeout')) {
+            userError = 'Connection timed out after 5 seconds';
+        }
+        else if (message === 'fetch failed' || message.includes('fetch')) {
+            userError = 'Connection failed. Is the server running at this address?';
+        }
+        res.json({ success: false, error: userError });
+    }
+});
+/**
+ * POST /add
+ *
+ * Adds a local LLM provider to the global OpenCode config.
+ *
+ * Request body: { name: string, baseUrl: string, models: { id: string, name: string }[] }
+ * Response: { success: true, providerId: "..." } or { success: false, error: "..." }
+ */
+router.post('/add', async (req, res) => {
+    const { name, baseUrl, models } = req.body;
+    if (!name || typeof name !== 'string') {
+        res.status(400).json({ success: false, error: 'name is required' });
+        return;
+    }
+    if (!baseUrl || typeof baseUrl !== 'string') {
+        res.status(400).json({ success: false, error: 'baseUrl is required' });
+        return;
+    }
+    if (!models || !Array.isArray(models) || models.length === 0) {
+        res.status(400).json({ success: false, error: 'At least one model is required' });
+        return;
+    }
+    const providerId = sanitizeProviderId(name);
+    if (!providerId) {
+        res.status(400).json({ success: false, error: 'Invalid provider name' });
+        return;
+    }
+    // Read existing config
+    const config = readOpencodeConfig();
+    // Check if provider already exists
+    if (config.provider?.[providerId]) {
+        res.status(409).json({
+            success: false,
+            error: `Provider "${providerId}" already exists`,
+        });
+        return;
+    }
+    // Normalize URL - ensure it ends with /v1
+    let normalizedUrl = baseUrl.replace(/\/+$/, '');
+    if (!normalizedUrl.endsWith('/v1')) {
+        normalizedUrl = `${normalizedUrl}/v1`;
+    }
+    // Build models config
+    const modelsConfig = {};
+    for (const model of models) {
+        modelsConfig[model.id] = { name: model.name };
+    }
+    // Create provider config
+    const providerConfig = {
+        npm: '@ai-sdk/openai-compatible',
+        name: name.trim(),
+        options: {
+            baseURL: normalizedUrl,
+        },
+        models: modelsConfig,
+    };
+    // Merge into config
+    if (!config.provider) {
+        config.provider = {};
+    }
+    config.provider[providerId] = providerConfig;
+    try {
+        // Write config
+        writeOpencodeConfig(config);
+        // Force OpenCode to reload by disposing the current instance
+        // This will cause the next request to pick up the new config
+        try {
+            await opencodeClient.global.dispose();
+            console.log('[local-llm] Disposed OpenCode instance to reload config');
+        }
+        catch {
+            // Non-fatal - OpenCode may not be running yet
+            console.log('[local-llm] Could not dispose OpenCode instance (may not be running)');
+        }
+        res.json({ success: true, providerId });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error('[local-llm] Failed to write config:', message);
+        res.status(500).json({ success: false, error: 'Failed to save configuration' });
+    }
+});
+/**
+ * GET /list
+ *
+ * Lists all local LLM providers from the global OpenCode config.
+ *
+ * Response: { providers: [{ id: string, name: string, baseUrl: string, models: [...] }] }
+ */
+router.get('/list', (_req, res) => {
+    const config = readOpencodeConfig();
+    const providers = [];
+    if (config.provider) {
+        for (const [id, providerConfig] of Object.entries(config.provider)) {
+            // Only include local LLM providers (those using @ai-sdk/openai-compatible)
+            if (providerConfig.npm === '@ai-sdk/openai-compatible') {
+                const models = Object.entries(providerConfig.models || {}).map(([modelId, modelInfo]) => ({
+                    id: modelId,
+                    name: modelInfo.name,
+                }));
+                providers.push({
+                    id,
+                    name: providerConfig.name,
+                    baseUrl: providerConfig.options?.baseURL || '',
+                    models,
+                });
+            }
+        }
+    }
+    res.json({ providers });
+});
+export default router;

package/dist/server/routes/logs.js

@@ -3,26 +3,50 @@ import fs from 'fs';
 import path from 'path';
 const LOG_FILE = path.resolve(process.cwd(), 'dev.log');
 const router = Router();
-// POST /__logs - receive browser console logs
+// Pino log levels
+const LEVEL_MAP = {
+    error: 50,
+    warn: 40,
+    info: 30,
+    log: 30,
+    debug: 20,
+};
+// POST /__logs - receive browser console logs (JSON format for pino compatibility)
 router.post('/', (req, res) => {
     try {
         const { level, args } = req.body;
-        const prefix = level === 'error' ? '🔴' : level === 'warn' ? '🟡' : '🌐';
-        const timestamp = new Date().toISOString().slice(11, 23); // HH:MM:SS.mmm
+        const pinoLevel = LEVEL_MAP[level] ?? 30;
         const message = args
             .map((a) => (typeof a === 'object' ? JSON.stringify(a) : String(a)))
             .join(' ');
-        const line = `${timestamp} ${prefix} ${message}`;
-        // Log to terminal
-        console.log(line);
-        // Append to file
-        fs.appendFileSync(LOG_FILE, line + '\n');
+        // JSON log entry compatible with pino format
+        const entry = {
+            level: pinoLevel,
+            time: Date.now(),
+            source: 'browser',
+            msg: message,
+        };
+        // Pretty print to terminal
+        const prefix = level === 'error'
+            ? '\x1b[31m●\x1b[0m'
+            : level === 'warn'
+                ? '\x1b[33m●\x1b[0m'
+                : '\x1b[36m●\x1b[0m';
+        const timestamp = new Date().toISOString().slice(11, 23);
+        console.log(`${timestamp} ${prefix} [browser] ${message}`);
+        // Append JSON to file
+        fs.appendFileSync(LOG_FILE, JSON.stringify(entry) + '\n');
         res.sendStatus(200);
     }
     catch {
-        const fallback = `${new Date().toISOString().slice(11, 23)} 🌐 [parse error] ${JSON.stringify(req.body)}`;
-        console.log(fallback);
-        fs.appendFileSync(LOG_FILE, fallback + '\n');
+        const entry = {
+            level: 40,
+            time: Date.now(),
+            source: 'browser',
+            msg: `[parse error] ${JSON.stringify(req.body)}`,
+        };
+        console.log(`\x1b[33m●\x1b[0m [browser] ${entry.msg}`);
+        fs.appendFileSync(LOG_FILE, JSON.stringify(entry) + '\n');
         res.sendStatus(200);
     }
 });

package/dist/server/routes/prompt.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shella Prompt Routes
+ *
+ * Handles prompt, command, and shell execution with integrated auto-routing.
+ * All __auto__ model resolution happens server-side - no extra HTTP calls needed.
+ *
+ * Endpoints:
+ *   POST /prompt  - Submit a prompt (message)
+ *   POST /command - Execute a slash command
+ *   POST /shell   - Execute a shell command
+ *
+ * All endpoints return 202 immediately with routing info.
+ * The actual OpenCode SDK call is fire-and-forget.
+ */
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/server/routes/prompt.js

@@ -0,0 +1,173 @@
+/**
+ * Shella Prompt Routes
+ *
+ * Handles prompt, command, and shell execution with integrated auto-routing.
+ * All __auto__ model resolution happens server-side - no extra HTTP calls needed.
+ *
+ * Endpoints:
+ *   POST /prompt  - Submit a prompt (message)
+ *   POST /command - Execute a slash command
+ *   POST /shell   - Execute a shell command
+ *
+ * All endpoints return 202 immediately with routing info.
+ * The actual OpenCode SDK call is fire-and-forget.
+ */
+import { Router } from 'express';
+import { pickBestProvider, getUsage, } from '@bytespell/model-provider-usage-limits';
+import { opencodeClient } from '../lib/opencode-client.js';
+const router = Router();
+// =============================================================================
+// Auto-Route Resolution
+// =============================================================================
+/**
+ * Infer default provider from model name pattern.
+ * Used as fallback when routing fails.
+ */
+function inferDefaultProvider(modelID) {
+    // GPT models, o-series (o1, o3, etc.), and codex -> openai
+    if (modelID.startsWith('gpt') || /^o\d/.test(modelID) || modelID.startsWith('codex')) {
+        return 'openai';
+    }
+    // Everything else (claude, etc.) -> anthropic
+    return 'anthropic';
+}
+/**
+ * Server-side auto-route resolution.
+ * No HTTP call needed - direct function call to usage-limits library.
+ */
+async function resolveModel(model) {
+    // Not an auto model - return as-is
+    if (model.providerID !== '__auto__') {
+        return { resolved: model, routed: false };
+    }
+    const defaultProvider = inferDefaultProvider(model.modelID);
+    try {
+        const usageData = await getUsage({ autoDetectAuthTokens: true });
+        const result = pickBestProvider({ providerID: defaultProvider, modelID: model.modelID }, usageData);
+        if (result) {
+            return {
+                resolved: { providerID: result.providerID, modelID: result.modelID },
+                routed: true,
+                reason: result.reason,
+            };
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error('[prompt] Routing error:', message);
+    }
+    // Fallback to default provider
+    return {
+        resolved: { providerID: defaultProvider, modelID: model.modelID },
+        routed: true,
+        reason: 'Fallback to default provider',
+        fallback: true,
+    };
+}
+// =============================================================================
+// Routes
+// =============================================================================
+/**
+ * POST /prompt
+ *
+ * Submit a prompt with auto-routing support.
+ * Returns 202 immediately with routing info, fires request to OpenCode async.
+ */
+router.post('/prompt', async (req, res) => {
+    const { sessionID, directory, messageID, parts, model, agent } = req.body;
+    if (!sessionID || !directory || !model) {
+        res.status(400).json({ error: 'Missing required fields: sessionID, directory, model' });
+        return;
+    }
+    // Resolve model (handles __auto__)
+    const routeResult = await resolveModel(model);
+    console.log(`[prompt] ${model.providerID}/${model.modelID} → ${routeResult.resolved.providerID}/${routeResult.resolved.modelID}`);
+    // Fire-and-forget to OpenCode
+    opencodeClient.session
+        .promptAsync({
+        sessionID,
+        directory,
+        messageID,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        parts: parts, // Parts are validated by the SDK
+        model: routeResult.resolved,
+        agent,
+    })
+        .catch((err) => {
+        console.error('[prompt] SDK error:', err);
+    });
+    // Return immediately with routing info
+    res.status(202).json({
+        accepted: true,
+        ...routeResult,
+    });
+});
+/**
+ * POST /command
+ *
+ * Execute a slash command with auto-routing support.
+ */
+router.post('/command', async (req, res) => {
+    const { sessionID, directory, command, args, model, agent } = req.body;
+    if (!sessionID || !directory || !command || !model) {
+        res
+            .status(400)
+            .json({ error: 'Missing required fields: sessionID, directory, command, model' });
+        return;
+    }
+    const routeResult = await resolveModel(model);
+    console.log(`[command] /${command} → ${routeResult.resolved.providerID}/${routeResult.resolved.modelID}`);
+    // Fire-and-forget to OpenCode
+    // Note: SDK command() expects model as string "{providerID}/{modelID}"
+    const modelString = `${routeResult.resolved.providerID}/${routeResult.resolved.modelID}`;
+    opencodeClient.session
+        .command({
+        sessionID,
+        directory,
+        command,
+        arguments: args,
+        model: modelString,
+        agent,
+    })
+        .catch((err) => {
+        console.error('[command] SDK error:', err);
+    });
+    res.status(202).json({
+        accepted: true,
+        ...routeResult,
+    });
+});
+/**
+ * POST /shell
+ *
+ * Execute a shell command with auto-routing support.
+ */
+router.post('/shell', async (req, res) => {
+    const { sessionID, directory, command, model, agent } = req.body;
+    if (!sessionID || !directory || !command || !model) {
+        res
+            .status(400)
+            .json({ error: 'Missing required fields: sessionID, directory, command, model' });
+        return;
+    }
+    const routeResult = await resolveModel(model);
+    const truncatedCmd = command.length > 30 ? `${command.slice(0, 30)}...` : command;
+    console.log(`[shell] !${truncatedCmd} → ${routeResult.resolved.providerID}/${routeResult.resolved.modelID}`);
+    // Fire-and-forget to OpenCode
+    opencodeClient.session
+        .shell({
+        sessionID,
+        directory,
+        command,
+        model: routeResult.resolved,
+        agent,
+    })
+        .catch((err) => {
+        console.error('[shell] SDK error:', err);
+    });
+    res.status(202).json({
+        accepted: true,
+        ...routeResult,
+    });
+});
+export default router;

package/dist/server/routes/session.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Session Routes
+ *
+ * Intercepts OpenCode session endpoints to apply shella-specific transformations.
+ * Currently handles message chunking on compaction boundaries.
+ */
+declare const router: import("express-serve-static-core").Router;
+export default router;