@bytespell/shella 0.1.3 → 0.1.4

package/dist/server/index.js

@@ -9,7 +9,13 @@ import windowsRoutes from './routes/windows.js';
 import modelStateRoutes from './routes/model-state.js';
 import logsRoutes from './routes/logs.js';
 import proxyRoutes from './routes/proxy.js';
+import sessionRoutes from './routes/session.js';
 import initRoutes from './routes/init.js';
+import statusRoutes from './routes/status.js';
+import usageRoutes from './routes/usage.js';
+import configRoutes from './routes/config.js';
+import promptRoutes from './routes/prompt.js';
+import localLlmRoutes from './routes/local-llm.js';
 import { getDatabase } from './services/database.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Runtime mode detection
@@ -20,14 +26,50 @@ if (!isProd) {
 }
 // Port: 3067 in prod, 3068 in dev (Vite uses 3067 in dev)
 const PORT = process.env.PORT || (isProd ? 3067 : 3068);
-// Config directory: ~/.config/shella/
-const CONFIG_DIR = path.join(os.homedir(), '.config', 'shella');
+// Config directory: SHELLA_DATA_DIR env var, or ~/.config/shella/ by default
+// In Docker, SHELLA_DATA_DIR is set to /projects/.shella
+const CONFIG_DIR = process.env.SHELLA_DATA_DIR
+    ? path.resolve(process.env.SHELLA_DATA_DIR)
+    : path.join(os.homedir(), '.config', 'shella');
 // Log file: ~/.config/shella/shella.log in prod, ./dev.log in dev
 const LOG_FILE = isProd
     ? path.join(CONFIG_DIR, 'shella.log')
     : path.resolve(process.cwd(), 'dev.log');
 /**
- * Parse --projects-dir from CLI args
+ * Parse --mode from CLI args
+ * 'cwd' mode: run in current directory only
+ * 'server' mode: register all subdirectories as projects
+ */
+function parseMode() {
+    const args = process.argv.slice(2);
+    const idx = args.indexOf('--mode');
+    if (idx !== -1 && args[idx + 1]) {
+        const mode = args[idx + 1];
+        if (mode === 'cwd' || mode === 'server') {
+            return mode;
+        }
+    }
+    // Fall back to env var (for dev mode)
+    if (process.env.SHELLA_MODE === 'cwd' || process.env.SHELLA_MODE === 'server') {
+        return process.env.SHELLA_MODE;
+    }
+    // Default to 'server' for backwards compatibility
+    return 'server';
+}
+/**
+ * Parse --directory from CLI args (cwd mode)
+ */
+function parseDirectory() {
+    const args = process.argv.slice(2);
+    const idx = args.indexOf('--directory');
+    if (idx !== -1 && args[idx + 1]) {
+        return path.resolve(args[idx + 1]);
+    }
+    // Default to cwd
+    return process.cwd();
+}
+/**
+ * Parse --projects-dir from CLI args (server mode)
  */
 function parseProjectsDir() {
     const args = process.argv.slice(2);
@@ -42,10 +84,14 @@ function parseProjectsDir() {
     // Default to cwd
     return process.cwd();
 }
-// Projects directory - passed from CLI or .env.local
-export const PROJECTS_DIR = parseProjectsDir();
+// Mode: 'cwd' or 'server'
+export const MODE = parseMode();
+// Directory - the single directory for cwd mode
+export const DIRECTORY = MODE === 'cwd' ? parseDirectory() : null;
+// Projects directory - passed from CLI or .env.local (server mode)
+export const PROJECTS_DIR = MODE === 'server' ? parseProjectsDir() : null;
 // Version - keep in sync with package.json
-export const VERSION = '0.1.3';
+export const VERSION = '0.1.4';
 /**
  * Ensure config directory exists
  */
@@ -65,8 +111,15 @@ app.get('/health', (_req, res) => res.json({ status: 'ok' }));
 // Mount API routes
 app.use('/__shella', windowsRoutes);
 app.use('/__shella/init', initRoutes);
+app.use('/__shella/status', statusRoutes);
+app.use('/__shella', usageRoutes);
+app.use('/__shella/config', configRoutes);
+app.use('/__shella', promptRoutes);
+app.use('/__shella/local-llm', localLlmRoutes);
 app.use('/__model-state', modelStateRoutes);
 app.use('/__logs', logsRoutes);
+// Session routes with chunking - BEFORE proxy catch-all
+app.use('/api/session', sessionRoutes);
 app.use('/api', proxyRoutes);
 // Production: serve static files from dist/web/
 if (isProd) {
@@ -102,12 +155,17 @@ async function start() {
     }
     // Initialize database before starting server
     await getDatabase();
-    // Clear/create log file on server start
+    // Ensure log directory exists
     const logDir = path.dirname(LOG_FILE);
     if (!fs.existsSync(logDir)) {
         fs.mkdirSync(logDir, { recursive: true });
     }
-    fs.writeFileSync(LOG_FILE, `--- Shella server started ${new Date().toISOString()} ---\n`);
+    // In dev mode, dev.ts orchestrator manages the log file
+    // In prod mode, initialize with JSON entry
+    if (isProd) {
+        const entry = { level: 30, time: Date.now(), source: 'express', msg: 'Server started' };
+        fs.writeFileSync(LOG_FILE, JSON.stringify(entry) + '\n');
+    }
     app.listen(PORT, () => {
         console.log(`[shella-server] Running on http://localhost:${PORT}`);
         console.log(`[shella-server] Mode: ${isProd ? 'production' : 'development'}`);

package/dist/server/lib/opencode-client.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Server-side OpenCode SDK client
+ *
+ * Creates a client that points directly to the OpenCode server,
+ * bypassing the Express proxy. Used for server-side operations
+ * that need to fetch/transform data before returning to the frontend.
+ */
+declare const OPENCODE_URL: string;
+/**
+ * Server-side OpenCode SDK client.
+ * Points directly to OpenCode server (not through Express proxy).
+ */
+export declare const opencodeClient: import("@opencode-ai/sdk/v2/client").OpencodeClient;
+export { OPENCODE_URL };

package/dist/server/lib/opencode-client.js

@@ -0,0 +1,17 @@
+/**
+ * Server-side OpenCode SDK client
+ *
+ * Creates a client that points directly to the OpenCode server,
+ * bypassing the Express proxy. Used for server-side operations
+ * that need to fetch/transform data before returning to the frontend.
+ */
+import { createOpencodeClient } from '@opencode-ai/sdk/v2/client';
+const OPENCODE_URL = process.env.OPENCODE_URL || 'http://localhost:4096';
+/**
+ * Server-side OpenCode SDK client.
+ * Points directly to OpenCode server (not through Express proxy).
+ */
+export const opencodeClient = createOpencodeClient({
+    baseUrl: OPENCODE_URL,
+});
+export { OPENCODE_URL };

package/dist/server/lib/opencode-config.d.ts

@@ -0,0 +1,14 @@
+/**
+ * OpenCode configuration loader for shella
+ *
+ * Loads plugin and model config to pass to createOpencodeServer().
+ * OpenCode auto-installs plugins from npm on first startup.
+ *
+ * Future optimization: bundle plugin via file:// protocol to skip npm install.
+ * Add plugin to package.json deps, then use `plugin: ['file://${pluginPath}']`.
+ */
+import type { Config } from '@opencode-ai/sdk';
+/**
+ * Load OpenCode config with plugin and model definitions.
+ */
+export declare function getOpencodeConfig(): Config;

package/dist/server/lib/opencode-config.js

@@ -0,0 +1,25 @@
+/**
+ * OpenCode configuration loader for shella
+ *
+ * Loads plugin and model config to pass to createOpencodeServer().
+ * OpenCode auto-installs plugins from npm on first startup.
+ *
+ * Future optimization: bundle plugin via file:// protocol to skip npm install.
+ * Add plugin to package.json deps, then use `plugin: ['file://${pluginPath}']`.
+ */
+import { readFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+let cachedConfig = null;
+/**
+ * Load OpenCode config with plugin and model definitions.
+ */
+export function getOpencodeConfig() {
+    if (cachedConfig)
+        return cachedConfig;
+    const configPath = resolve(__dirname, '../../config/openai-codex-models.json');
+    const raw = readFileSync(configPath, 'utf-8');
+    cachedConfig = JSON.parse(raw);
+    return cachedConfig;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Shella Config Routes
+ *
+ * Custom config endpoint that wraps OpenCode's provider list and injects
+ * the __auto__ provider with dynamically computed routable models.
+ *
+ * Routable models are models that:
+ * 1. Exist on a provider with usage limit support (anthropic, github-copilot, openai)
+ * 2. Can be served by at least one other usage-limit provider
+ */
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/server/routes/config.js

@@ -0,0 +1,207 @@
+/**
+ * Shella Config Routes
+ *
+ * Custom config endpoint that wraps OpenCode's provider list and injects
+ * the __auto__ provider with dynamically computed routable models.
+ *
+ * Routable models are models that:
+ * 1. Exist on a provider with usage limit support (anthropic, github-copilot, openai)
+ * 2. Can be served by at least one other usage-limit provider
+ */
+import { Router } from 'express';
+import { isRoutableModel, getUsage } from '@bytespell/model-provider-usage-limits';
+import { opencodeClient } from '../lib/opencode-client.js';
+/** Providers that support usage limits and can participate in auto-routing */
+const USAGE_LIMIT_PROVIDERS = ['anthropic', 'github-copilot', 'openai'];
+const router = Router();
+/**
+ * Filter models to prefer "(latest)" variants and clean up display names.
+ *
+ * When multiple models share the same base name (name without " (latest)"):
+ * - If any has "(latest)" in its name, keep only that one
+ * - If none have "(latest)", keep all of them
+ *
+ * All "(latest)" suffixes are stripped from final display names.
+ */
+function filterLatestModels(models) {
+    // Group models by base name (name without " (latest)")
+    const byBaseName = new Map();
+    for (const [modelId, info] of Object.entries(models)) {
+        const baseName = info.name.replace(' (latest)', '');
+        if (!byBaseName.has(baseName)) {
+            byBaseName.set(baseName, []);
+        }
+        byBaseName.get(baseName).push([modelId, info]);
+    }
+    // For each group, keep only the "(latest)" version if multiple exist
+    const result = {};
+    for (const [baseName, entries] of byBaseName) {
+        if (entries.length === 1) {
+            // Single model - keep it with cleaned name
+            const [modelId, info] = entries[0];
+            result[modelId] = { ...info, name: baseName };
+        }
+        else {
+            // Multiple models with same base name
+            const latestEntry = entries.find(([, info]) => info.name.includes('(latest)'));
+            if (latestEntry) {
+                // Keep only the "(latest)" variant with cleaned name
+                const [modelId, info] = latestEntry;
+                result[modelId] = { ...info, name: baseName };
+            }
+            else {
+                // No "(latest)" found - keep all with cleaned names
+                for (const [modelId, info] of entries) {
+                    result[modelId] = { ...info, name: baseName };
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Compute routable models from connected providers.
+ *
+ * A model is routable if:
+ * 1. It belongs to a connected provider with usage limit support
+ * 2. It can be transformed/served by at least one OTHER usage-limit provider
+ *
+ * @param providers - All available providers
+ * @param connected - IDs of connected providers
+ * @returns Map of model ID to model info for routable models
+ */
+function computeRoutableModels(providers, connected) {
+    const routableModels = {};
+    // Get connected providers that support usage limits
+    const usageProviders = connected.filter((id) => USAGE_LIMIT_PROVIDERS.includes(id));
+    // Need at least 2 usage-limit providers for routing to be meaningful
+    if (usageProviders.length < 2) {
+        console.log(`[config] Only ${usageProviders.length} usage-limit provider(s) connected, no routable models`);
+        return routableModels;
+    }
+    console.log(`[config] Computing routable models from providers: ${usageProviders.join(', ')}`);
+    // For each model in each usage-limit provider, check if it's routable
+    for (const providerId of usageProviders) {
+        const provider = providers.find((p) => p.id === providerId);
+        if (!provider?.models)
+            continue;
+        for (const [modelId, modelInfo] of Object.entries(provider.models)) {
+            // Skip if already added (may exist on multiple providers)
+            if (routableModels[modelId])
+                continue;
+            // Check if this model can be served by at least one OTHER provider
+            if (isRoutableModel(modelId, providerId)) {
+                routableModels[modelId] = {
+                    name: modelInfo.name,
+                    limit: modelInfo.limit,
+                    cost: modelInfo.cost,
+                };
+            }
+        }
+    }
+    // Filter to prefer "(latest)" variants and clean display names
+    const filteredModels = filterLatestModels(routableModels);
+    const beforeCount = Object.keys(routableModels).length;
+    const afterCount = Object.keys(filteredModels).length;
+    console.log(`[config] Found ${beforeCount} routable model(s), filtered to ${afterCount}`);
+    return filteredModels;
+}
+/**
+ * GET /
+ *
+ * Returns OpenCode's provider list with __auto__ provider injected.
+ * The __auto__ provider contains all models that can be auto-routed
+ * between providers based on usage limits.
+ */
+router.get('/', async (_req, res) => {
+    console.log('[config] GET /__shella/config');
+    try {
+        // Fetch real provider list from OpenCode using SDK
+        const providersRes = await opencodeClient.provider.list();
+        if (providersRes.error) {
+            throw new Error(`OpenCode SDK error: ${JSON.stringify(providersRes.error)}`);
+        }
+        const providers = (providersRes.data?.all ?? []);
+        const connected = providersRes.data?.connected ?? [];
+        console.log(`[config] OpenCode has ${providers.length} providers, ${connected.length} connected`);
+        // Fetch usage data for providers with usage limits (non-blocking on failure)
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let usageData = {};
+        try {
+            usageData = await getUsage({ autoDetectAuthTokens: true });
+            console.log(`[config] Fetched usage for ${Object.keys(usageData).length} provider(s)`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error('[config] Failed to fetch usage (non-fatal):', message);
+        }
+        // Normalize window labels (e.g., "monthly" -> "30d")
+        const normalizeWindowLabel = (window) => {
+            if (window === 'monthly')
+                return '30d';
+            return window;
+        };
+        // Augment providers with usage data (both primary and secondary windows)
+        const providersWithUsage = providers.map((provider) => {
+            const usage = usageData[provider.id];
+            const primary = usage?.data?.primary;
+            const secondary = usage?.data?.secondary;
+            // Build array of usage windows
+            const windows = [];
+            if (primary) {
+                windows.push({
+                    usedPercent: primary.usedPercent,
+                    window: normalizeWindowLabel(primary.window),
+                    resetsAt: primary.resetsAt,
+                });
+            }
+            if (secondary) {
+                windows.push({
+                    usedPercent: secondary.usedPercent,
+                    window: normalizeWindowLabel(secondary.window),
+                    resetsAt: secondary.resetsAt,
+                });
+            }
+            return {
+                ...provider,
+                usage: windows.length > 0 ? windows : null,
+            };
+        });
+        // Filter connected providers to only show those actually authenticated
+        const actuallyConnected = connected.filter((id) => {
+            // Special case: opencode always connected (free models)
+            if (id === 'opencode')
+                return true;
+            // Special case: OpenAI - only show as connected if we got usage data
+            // This handles the case where OpenAI has models in config (via opencode-openai-codex-auth
+            // plugin) but user hasn't completed OAuth yet. If usage data exists, auth is working.
+            // TODO: If the plugin changes how it loads models, this check may need updating
+            if (id === 'openai')
+                return usageData['openai'] !== undefined;
+            // All other providers: trust OpenCode's connected array
+            return true;
+        });
+        console.log(`[config] Filtered connected: ${connected.length} -> ${actuallyConnected.length} (${actuallyConnected.join(', ')})`);
+        // Compute routable models using actually connected providers
+        const routableModels = computeRoutableModels(providers, actuallyConnected);
+        // Create __auto__ provider (always included, even if empty)
+        const autoProvider = {
+            id: '__auto__',
+            name: 'Auto Route',
+            models: routableModels,
+            usage: null, // __auto__ doesn't have its own usage
+        };
+        // Return combined result with __auto__ first
+        // __auto__ is always "connected" so it appears in the UI
+        res.json({
+            all: [autoProvider, ...providersWithUsage],
+            connected: ['__auto__', ...actuallyConnected],
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error('[config] Error fetching config:', message);
+        res.status(500).json({ error: message });
+    }
+});
+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;