@bytespell/shella 0.1.5 → 0.1.7

package/dist/server/routes/proxy.js

@@ -1,122 +0,0 @@
-import { Router } from 'express';
-const OPENCODE_URL = process.env.OPENCODE_URL || 'http://localhost:4096';
-const router = Router();
-// Routes that should return 202 immediately without waiting for OpenCode response.
-// These are "fire-and-forget" - the browser doesn't need the response body,
-// and waiting would cause the UI to hang while OpenCode processes the request.
-const FIRE_AND_FORGET_PATTERNS = [
-    { method: 'POST', pattern: /^\/session\/[^/]+\/shell$/ },
-    { method: 'POST', pattern: /^\/session\/[^/]+\/command$/ },
-    { method: 'POST', pattern: /^\/session\/[^/]+\/abort$/ },
-    { method: 'POST', pattern: /^\/session\/[^/]+\/revert$/ },
-    { method: 'POST', pattern: /^\/session\/[^/]+\/unrevert$/ },
-    { method: 'POST', pattern: /^\/session\/[^/]+\/summarize$/ },
-    // Permission endpoints (old and new SDK versions)
-    { method: 'POST', pattern: /^\/session\/[^/]+\/permissions\/[^/]+$/ },
-    { method: 'POST', pattern: /^\/permission\/[^/]+\/reply$/ },
-];
-const isFireAndForget = (method, path) => {
-    // Strip query string for matching
-    const pathWithoutQuery = path.split('?')[0];
-    return FIRE_AND_FORGET_PATTERNS.some((route) => route.method === method && route.pattern.test(pathWithoutQuery));
-};
-const buildTargetUrl = (req) => {
-    const url = new URL(req.url, OPENCODE_URL);
-    return url;
-};
-const buildHeaders = (req, includeBody) => {
-    const headers = {};
-    if (typeof req.headers['accept'] === 'string') {
-        headers['accept'] = req.headers['accept'];
-    }
-    if (includeBody) {
-        headers['content-type'] = 'application/json';
-    }
-    return headers;
-};
-const hasBody = (method) => {
-    return ['POST', 'PUT', 'PATCH'].includes(method);
-};
-// Fire-and-forget: send request to OpenCode but return 202 immediately
-const fireAndForget = (req, label) => {
-    const url = buildTargetUrl(req);
-    const headers = buildHeaders(req, hasBody(req.method));
-    fetch(url, {
-        method: req.method,
-        headers,
-        body: hasBody(req.method) ? JSON.stringify(req.body ?? {}) : undefined,
-    }).catch((error) => {
-        console.error(`[proxy] ${label} fire-and-forget error:`, error);
-    });
-};
-// Stream proxy: forward request and stream response back
-const streamProxy = async (req, res) => {
-    const url = buildTargetUrl(req);
-    const headers = buildHeaders(req, hasBody(req.method));
-    try {
-        const response = await fetch(url, {
-            method: req.method,
-            headers,
-            body: hasBody(req.method) ? JSON.stringify(req.body ?? {}) : undefined,
-        });
-        // Forward status
-        res.status(response.status);
-        // Forward headers (except content-length which may be wrong after buffering)
-        response.headers.forEach((value, key) => {
-            if (key.toLowerCase() !== 'content-length') {
-                res.setHeader(key, value);
-            }
-        });
-        // Handle 204 No Content
-        if (response.status === 204 || !response.body) {
-            res.end();
-            return;
-        }
-        // Check if this is SSE
-        const contentType = response.headers.get('content-type') ?? '';
-        const isSSE = contentType.includes('text/event-stream');
-        if (isSSE) {
-            // SSE: stream chunks as they arrive
-            res.setHeader('Cache-Control', 'no-cache');
-            res.setHeader('Connection', 'keep-alive');
-            const reader = response.body.getReader();
-            try {
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done)
-                        break;
-                    res.write(value);
-                }
-            }
-            finally {
-                reader.releaseLock();
-            }
-            res.end();
-        }
-        else {
-            // Non-SSE: buffer and send
-            const buffer = Buffer.from(await response.arrayBuffer());
-            res.send(buffer);
-        }
-    }
-    catch (error) {
-        console.error(`[proxy] ${req.method} ${req.url} error:`, error);
-        res.status(502).json({ error: 'Failed to proxy request to OpenCode' });
-    }
-};
-// Log all proxied requests
-router.use((req, _res, next) => {
-    console.log(`[proxy] ${req.method} ${req.url}`);
-    next();
-});
-// Main proxy handler
-router.use('/', async (req, res) => {
-    if (isFireAndForget(req.method, req.url)) {
-        const label = req.url.split('?')[0];
-        fireAndForget(req, label);
-        res.status(202).end();
-        return;
-    }
-    await streamProxy(req, res);
-});
-export default router;

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

@@ -1,8 +0,0 @@
-/**
- * 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

@@ -1,63 +0,0 @@
-/**
- * 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

@@ -1,9 +0,0 @@
-/**
- * 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

@@ -1,54 +0,0 @@
-/**
- * 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

@@ -1,12 +0,0 @@
-/**
- * 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;

package/dist/server/routes/usage.js

@@ -1,60 +0,0 @@
-/**
- * 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.
- */
-import { Router } from 'express';
-import { getUsage, detectAuthTokens } from '@bytespell/model-provider-usage-limits';
-const router = Router();
-/**
- * GET /usage
- *
- * Fetch usage data for all authenticated providers.
- * Auto-detects tokens from OpenCode's auth.json.
- *
- * Query params:
- *   - bypass_cache: "true" to skip cache
- */
-router.get('/usage', async (req, res) => {
-    const bypassCache = req.query.bypass_cache === 'true';
-    console.log(`[usage] GET /usage (bypass_cache=${bypassCache})`);
-    try {
-        // Check what tokens are available (for logging)
-        const tokens = detectAuthTokens();
-        const tokenProviders = Object.keys(tokens);
-        console.log(`[usage] Detected tokens for: ${tokenProviders.join(', ') || 'none'}`);
-        if (tokenProviders.length === 0) {
-            console.log(`[usage] No provider tokens available`);
-            res.json({ providers: {}, message: 'No authenticated providers found' });
-            return;
-        }
-        const results = await getUsage({
-            autoDetectAuthTokens: true,
-            bypassCache,
-        });
-        const providerCount = Object.keys(results).length;
-        console.log(`[usage] Fetched usage for ${providerCount} provider(s)`);
-        // Log summary for each provider
-        for (const [provider, result] of Object.entries(results)) {
-            if (result?.data?.primary) {
-                const { usedPercent, paceDelta, window } = result.data.primary;
-                console.log(`[usage]   ${provider}: ${usedPercent.toFixed(1)}% used (${window}), pace: ${paceDelta ?? 'n/a'}%`);
-            }
-            else if (result?.error) {
-                console.log(`[usage]   ${provider}: error - ${result.error.message}`);
-            }
-        }
-        res.json({ providers: results });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`[usage] Error fetching usage:`, message);
-        res.status(500).json({ error: message });
-    }
-});
-export default router;

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

@@ -1,2 +0,0 @@
-declare const router: import("express-serve-static-core").Router;
-export default router;

package/dist/server/routes/windows.js

@@ -1,125 +0,0 @@
-import { Router } from 'express';
-import { eq } from 'drizzle-orm';
-import { getDatabase, saveDatabase } from '../services/database.js';
-import { windows } from '../schema.js';
-import { setupSSE, sendSSE, addWindowClient, removeWindowClient, broadcastWindowEvent, } from '../services/sse-manager.js';
-const router = Router();
-// SSE endpoint for window sync
-router.get('/events', (req, res) => {
-    const clientId = req.headers['x-client-id'];
-    const client = setupSSE(res, clientId);
-    sendSSE(client, { type: 'connected' });
-    addWindowClient(client);
-    req.on('close', () => removeWindowClient(client));
-});
-// List all windows
-router.get('/windows', async (_req, res) => {
-    try {
-        const db = await getDatabase();
-        const allWindows = db.select().from(windows).orderBy(windows.createdAt).all();
-        res.json(allWindows);
-    }
-    catch (err) {
-        console.error('[windows] Failed to list windows:', err);
-        res.status(500).json({ error: 'Failed to list windows' });
-    }
-});
-// Create a new window
-router.post('/windows', async (req, res) => {
-    try {
-        const db = await getDatabase();
-        const clientId = req.headers['x-client-id'];
-        const body = req.body;
-        if (!body.id || !body.directoryId || !body.createdAt) {
-            res.status(400).json({ error: 'Missing required fields: id, directoryId, createdAt' });
-            return;
-        }
-        const newWindow = {
-            id: body.id,
-            directoryId: body.directoryId,
-            rootSessionId: body.rootSessionId ?? null,
-            lastActiveAt: body.lastActiveAt ?? body.createdAt, // Default to createdAt
-            agent: body.agent ?? null,
-            modelProvider: body.modelProvider ?? null,
-            modelId: body.modelId ?? null,
-            label: body.label ?? null,
-            createdAt: body.createdAt,
-        };
-        db.insert(windows).values(newWindow).run();
-        saveDatabase(); // Persist immediately to avoid data loss on restart
-        const created = db.select().from(windows).where(eq(windows.id, body.id)).get();
-        broadcastWindowEvent({ type: 'window:created', window: created, sourceClientId: clientId });
-        res.json(created);
-    }
-    catch (err) {
-        console.error('[windows] Failed to create window:', err);
-        res.status(500).json({ error: 'Failed to create window' });
-    }
-});
-// Update a window
-router.patch('/windows/:id', async (req, res) => {
-    try {
-        const db = await getDatabase();
-        const clientId = req.headers['x-client-id'];
-        const windowId = req.params.id;
-        const body = req.body;
-        // Check if window exists
-        const existing = db.select().from(windows).where(eq(windows.id, windowId)).get();
-        if (!existing) {
-            res.status(404).json({ error: 'Window not found' });
-            return;
-        }
-        // directoryId is immutable - reject any attempt to change it
-        if (body.directoryId !== undefined) {
-            res.status(400).json({ error: 'directoryId cannot be changed after window creation' });
-            return;
-        }
-        // Build update object (only include provided fields)
-        const updates = {};
-        if (body.rootSessionId !== undefined)
-            updates.rootSessionId = body.rootSessionId;
-        if (body.lastActiveAt !== undefined)
-            updates.lastActiveAt = body.lastActiveAt;
-        if (body.agent !== undefined)
-            updates.agent = body.agent;
-        if (body.modelProvider !== undefined)
-            updates.modelProvider = body.modelProvider;
-        if (body.modelId !== undefined)
-            updates.modelId = body.modelId;
-        if (body.label !== undefined)
-            updates.label = body.label;
-        if (Object.keys(updates).length > 0) {
-            db.update(windows).set(updates).where(eq(windows.id, windowId)).run();
-            saveDatabase(); // Persist immediately to avoid data loss on restart
-        }
-        const updated = db.select().from(windows).where(eq(windows.id, windowId)).get();
-        broadcastWindowEvent({ type: 'window:updated', window: updated, sourceClientId: clientId });
-        res.json(updated);
-    }
-    catch (err) {
-        console.error('[windows] Failed to update window:', err);
-        res.status(500).json({ error: 'Failed to update window' });
-    }
-});
-// Delete a window
-router.delete('/windows/:id', async (req, res) => {
-    try {
-        const db = await getDatabase();
-        const clientId = req.headers['x-client-id'];
-        const windowId = req.params.id;
-        const existing = db.select().from(windows).where(eq(windows.id, windowId)).get();
-        if (!existing) {
-            res.status(404).json({ error: 'Window not found' });
-            return;
-        }
-        db.delete(windows).where(eq(windows.id, windowId)).run();
-        saveDatabase(); // Persist immediately to avoid data loss on restart
-        broadcastWindowEvent({ type: 'window:deleted', windowId, sourceClientId: clientId });
-        res.json({ ok: true });
-    }
-    catch (err) {
-        console.error('[windows] Failed to delete window:', err);
-        res.status(500).json({ error: 'Failed to delete window' });
-    }
-});
-export default router;