@bytespell/shella 0.1.0

package/dist/server/routes/windows.js

@@ -0,0 +1,125 @@
+import { Router } from 'express';
+import { eq } from 'drizzle-orm';
+import { getDatabase } 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,
+            activeSessionId: body.activeSessionId ?? 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();
+        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.activeSessionId !== undefined)
+            updates.activeSessionId = body.activeSessionId;
+        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();
+        }
+        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();
+        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;

package/dist/server/schema.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Windows table schema (inlined for server build).
+ * This is a copy of src/lib/db/schema.ts for the server build.
+ * Keep in sync with the frontend schema.
+ */
+export declare const windows: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "windows";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "windows";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        directoryId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "directory_id";
+            tableName: "windows";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        rootSessionId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "root_session_id";
+            tableName: "windows";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        activeSessionId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "active_session_id";
+            tableName: "windows";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        lastActiveAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "last_active_at";
+            tableName: "windows";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        agent: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "agent";
+            tableName: "windows";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        modelProvider: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "model_provider";
+            tableName: "windows";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        modelId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "model_id";
+            tableName: "windows";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        label: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "label";
+            tableName: "windows";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "windows";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+export type Window = typeof windows.$inferSelect;
+export type NewWindow = typeof windows.$inferInsert;

package/dist/server/schema.js

@@ -0,0 +1,18 @@
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
+/**
+ * Windows table schema (inlined for server build).
+ * This is a copy of src/lib/db/schema.ts for the server build.
+ * Keep in sync with the frontend schema.
+ */
+export const windows = sqliteTable('windows', {
+    id: text('id').primaryKey(),
+    directoryId: text('directory_id').notNull(),
+    rootSessionId: text('root_session_id'), // The topmost session (never a subagent)
+    activeSessionId: text('active_session_id'), // Currently viewed session (root or subagent)
+    lastActiveAt: text('last_active_at'), // Timestamp for cross-device active window sync
+    agent: text('agent'),
+    modelProvider: text('model_provider'),
+    modelId: text('model_id'),
+    label: text('label'),
+    createdAt: text('created_at').notNull(),
+});

package/dist/server/services/database.d.ts

@@ -0,0 +1,5 @@
+declare const CONFIG_DIR: string;
+declare const STATE_DIR: string;
+export declare function getDatabase(): Promise<import("drizzle-orm/sql-js").SQLJsDatabase<Record<string, unknown>>>;
+export declare function getDatabaseSync(): import("drizzle-orm/sql-js").SQLJsDatabase<Record<string, unknown>>;
+export { STATE_DIR, CONFIG_DIR };

package/dist/server/services/database.js

@@ -0,0 +1,110 @@
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import initSqlJs from 'sql.js';
+import { drizzle } from 'drizzle-orm/sql-js';
+import { windows } from '../schema.js';
+// Database location: ~/.config/shella/ (both dev and prod)
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'shella');
+const STATE_DIR = CONFIG_DIR;
+const DB_FILE = path.join(STATE_DIR, 'shella.db');
+// Singleton database instance
+let db = null;
+let sqlite = null;
+// Persistence interval (5 seconds)
+const SAVE_INTERVAL_MS = 5000;
+let saveInterval = null;
+function ensureStateDir() {
+    if (!fs.existsSync(STATE_DIR)) {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+    }
+}
+/**
+ * Save the in-memory database to disk.
+ * sql.js is in-memory, so we need to manually persist.
+ */
+function saveDatabase() {
+    if (!sqlite)
+        return;
+    try {
+        const data = sqlite.export();
+        fs.writeFileSync(DB_FILE, Buffer.from(data));
+    }
+    catch (err) {
+        console.error('[database] Failed to save:', err);
+    }
+}
+/**
+ * Set up periodic saves and exit handlers
+ */
+function setupPersistence() {
+    // Periodic save every 5 seconds
+    saveInterval = setInterval(saveDatabase, SAVE_INTERVAL_MS);
+    // Save on exit
+    const exitHandler = () => {
+        console.log('[database] Saving before exit...');
+        saveDatabase();
+        if (saveInterval)
+            clearInterval(saveInterval);
+    };
+    process.on('SIGINT', () => {
+        exitHandler();
+        process.exit();
+    });
+    process.on('SIGTERM', () => {
+        exitHandler();
+        process.exit();
+    });
+    process.on('exit', exitHandler);
+}
+async function initDatabase() {
+    ensureStateDir();
+    // Initialize sql.js (loads WebAssembly)
+    const SQL = await initSqlJs();
+    // Load existing database or create new one
+    const fileBuffer = fs.existsSync(DB_FILE) ? fs.readFileSync(DB_FILE) : undefined;
+    sqlite = new SQL.Database(fileBuffer);
+    // Create table if not exists
+    sqlite.run(`
+    CREATE TABLE IF NOT EXISTS windows (
+      id TEXT PRIMARY KEY,
+      directory_id TEXT NOT NULL,
+      root_session_id TEXT,
+      active_session_id TEXT,
+      last_active_at TEXT,
+      agent TEXT,
+      model_provider TEXT,
+      model_id TEXT,
+      label TEXT,
+      created_at TEXT NOT NULL
+    )
+  `);
+    // Set up periodic persistence
+    setupPersistence();
+    // Save immediately
+    saveDatabase();
+    return drizzle(sqlite, { schema: { windows } });
+}
+// Promise to track initialization
+let initPromise = null;
+export async function getDatabase() {
+    if (!db) {
+        if (!initPromise) {
+            initPromise = initDatabase().then((database) => {
+                db = database;
+                console.log('[database] Initialized at', DB_FILE);
+                return database;
+            });
+        }
+        await initPromise;
+    }
+    return db;
+}
+// Synchronous getter for compatibility (throws if not initialized)
+export function getDatabaseSync() {
+    if (!db) {
+        throw new Error('Database not initialized. Call getDatabase() first.');
+    }
+    return db;
+}
+export { STATE_DIR, CONFIG_DIR };

package/dist/server/services/sse-manager.d.ts

@@ -0,0 +1,16 @@
+import type { Response } from 'express';
+export interface SSEClient {
+    res: Response;
+    clientId?: string;
+}
+/**
+ * Set up SSE headers and return a client object
+ */
+export declare function setupSSE(res: Response, clientId?: string): SSEClient;
+/**
+ * Send an SSE message to a client
+ */
+export declare function sendSSE(client: SSEClient, data: unknown): boolean;
+export declare function addWindowClient(client: SSEClient): void;
+export declare function removeWindowClient(client: SSEClient): void;
+export declare function broadcastWindowEvent(message: unknown, excludeClientId?: string | null): void;

package/dist/server/services/sse-manager.js

@@ -0,0 +1,44 @@
+// Separate client sets for different SSE streams
+const windowClients = new Set();
+/**
+ * Set up SSE headers and return a client object
+ */
+export function setupSSE(res, clientId) {
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.flushHeaders();
+    return { res, clientId };
+}
+/**
+ * Send an SSE message to a client
+ */
+export function sendSSE(client, data) {
+    try {
+        client.res.write(`data: ${JSON.stringify(data)}\n\n`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ===== Window SSE management =====
+export function addWindowClient(client) {
+    windowClients.add(client);
+    console.log(`[sse] Window client connected (${windowClients.size} total)`);
+}
+export function removeWindowClient(client) {
+    windowClients.delete(client);
+    console.log(`[sse] Window client disconnected (${windowClients.size} total)`);
+}
+export function broadcastWindowEvent(message, excludeClientId) {
+    for (const client of windowClients) {
+        // Don't echo back to the source client
+        if (excludeClientId && client.clientId === excludeClientId) {
+            continue;
+        }
+        if (!sendSSE(client, message)) {
+            windowClients.delete(client);
+        }
+    }
+}