@bytespell/shella 0.1.3 → 0.1.4

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;

package/dist/server/routes/session.js

@@ -0,0 +1,63 @@
+/**
+ * Session Routes
+ *
+ * Intercepts OpenCode session endpoints to apply shella-specific transformations.
+ * Currently handles message chunking on compaction boundaries.
+ */
+import { Router } from 'express';
+import { opencodeClient } from '../lib/opencode-client.js';
+const router = Router();
+/**
+ * GET /session/:sessionId/message
+ *
+ * Fetches messages for a session and applies compaction chunking.
+ * Only returns messages from the last compaction boundary onwards,
+ * reducing payload size and frontend memory for long-running sessions.
+ */
+router.get('/:sessionId/message', async (req, res) => {
+    const { sessionId } = req.params;
+    const directory = req.query.directory;
+    if (!directory) {
+        res.status(400).json({ error: 'directory query parameter is required' });
+        return;
+    }
+    try {
+        const response = await opencodeClient.session.messages({
+            sessionID: sessionId,
+            directory,
+        });
+        const allMessages = (response.data ?? []);
+        // Find the last message with a compaction part
+        let lastCompactionIndex = -1;
+        for (let i = allMessages.length - 1; i >= 0; i--) {
+            const msg = allMessages[i];
+            if (msg.parts?.some((p) => p.type === 'compaction')) {
+                lastCompactionIndex = i;
+                break;
+            }
+        }
+        // If compaction found, return only messages from compaction onwards
+        if (lastCompactionIndex >= 0) {
+            const chunkedResponse = {
+                data: allMessages.slice(lastCompactionIndex),
+                hasEarlierChunks: lastCompactionIndex > 0,
+                chunkBoundaryMessageId: allMessages[lastCompactionIndex].info.id,
+            };
+            console.log(`[session] GET /${sessionId}/message - chunked: ${allMessages.length} -> ${chunkedResponse.data.length} messages`);
+            res.json(chunkedResponse);
+            return;
+        }
+        // No compaction - return all messages
+        const fullResponse = {
+            data: allMessages,
+            hasEarlierChunks: false,
+        };
+        console.log(`[session] GET /${sessionId}/message - no compaction: ${allMessages.length} messages`);
+        res.json(fullResponse);
+    }
+    catch (error) {
+        console.error(`[session] GET /${sessionId}/message error:`, error);
+        res.status(502).json({ error: 'Failed to fetch messages from OpenCode' });
+    }
+});
+export default router;

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

@@ -0,0 +1,9 @@
+/**
+ * Status endpoint - checks if the server has been configured (onboarding complete).
+ *
+ * This is used by the frontend to determine whether to show the welcome screen.
+ * Unlike localStorage-based checks, this is server-side so it works correctly
+ * when the same browser connects to different shella servers.
+ */
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/server/routes/status.js

@@ -0,0 +1,54 @@
+/**
+ * Status endpoint - checks if the server has been configured (onboarding complete).
+ *
+ * This is used by the frontend to determine whether to show the welcome screen.
+ * Unlike localStorage-based checks, this is server-side so it works correctly
+ * when the same browser connects to different shella servers.
+ */
+import { Router } from 'express';
+import { eq } from 'drizzle-orm';
+import { getDatabase, saveDatabase } from '../services/database.js';
+import { settings } from '../schema.js';
+const router = Router();
+const CONFIGURED_KEY = 'configured';
+/**
+ * GET /__shella/status
+ * Returns the server configuration status.
+ */
+router.get('/', async (_req, res) => {
+    try {
+        const db = await getDatabase();
+        const result = await db.select().from(settings).where(eq(settings.key, CONFIGURED_KEY));
+        const configured = result.length > 0 && result[0].value === 'true';
+        res.json({ configured });
+    }
+    catch (err) {
+        console.error('[status] Failed to get status:', err);
+        res.status(500).json({ error: 'Failed to get status' });
+    }
+});
+/**
+ * POST /__shella/status/configured
+ * Marks the server as configured (onboarding complete).
+ */
+router.post('/configured', async (_req, res) => {
+    try {
+        const db = await getDatabase();
+        // Upsert the configured setting
+        await db
+            .insert(settings)
+            .values({ key: CONFIGURED_KEY, value: 'true' })
+            .onConflictDoUpdate({
+            target: settings.key,
+            set: { value: 'true' },
+        });
+        // Persist immediately
+        saveDatabase();
+        res.json({ success: true });
+    }
+    catch (err) {
+        console.error('[status] Failed to set configured:', err);
+        res.status(500).json({ error: 'Failed to set configured' });
+    }
+});
+export default router;

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

@@ -0,0 +1,12 @@
+/**
+ * Usage Limits API Routes
+ *
+ * Fetches AI provider usage data.
+ * Uses @bytespell/model-provider-usage-limits for the heavy lifting.
+ *
+ * Note: Routing is now handled server-side in prompt.ts.
+ * Usage data is also included in the config response.
+ * This endpoint is kept for debugging/manual refresh.
+ */
+declare const router: import("express-serve-static-core").Router;
+export default router;