@bytespell/shella 0.1.5 → 0.1.7

package/bin/cli.js

@@ -1,370 +0,0 @@
-#!/usr/bin/env node
-import { program } from 'commander';
-import { createOpencodeServer } from '@opencode-ai/sdk';
-import { networkInterfaces, homedir } from 'os';
-import { spawn } from 'child_process';
-import { createConnection } from 'net';
-import { existsSync, readdirSync, readFileSync } from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import * as p from '@clack/prompts';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const VERSION = '0.1.4';
-// Brand color (indigo) for terminal output
-const BRAND = '\x1b[38;2;99;102;241m'; // rgb(99, 102, 241) - matches --primary
-const RESET = '\x1b[0m';
-const DIM = '\x1b[2m';
-const brand = (text) => `${BRAND}${text}${RESET}`;
-const dim = (text) => `${DIM}${text}${RESET}`;
-/**
- * Load OpenCode config with plugin and model definitions.
- */
-function getOpencodeConfig() {
-    const configPath = path.join(__dirname, '..', 'dist', 'config', 'openai-codex-models.json');
-    const raw = readFileSync(configPath, 'utf-8');
-    return JSON.parse(raw);
-}
-/**
- * Check if running inside Docker container
- */
-function isDocker() {
-    return existsSync('/.dockerenv');
-}
-/**
- * Check if a port is available
- */
-async function isPortAvailable(port) {
-    return new Promise((resolve) => {
-        const socket = createConnection({ port, host: '127.0.0.1' });
-        socket.setTimeout(1000);
-        socket.on('connect', () => {
-            socket.destroy();
-            resolve(false); // Port is in use
-        });
-        socket.on('timeout', () => {
-            socket.destroy();
-            resolve(true); // Port is available
-        });
-        socket.on('error', () => {
-            resolve(true); // Port is available (connection refused)
-        });
-    });
-}
-/**
- * Find the next available port starting from a given port
- */
-async function findAvailablePort(start, maxAttempts = 100) {
-    for (let port = start; port < start + maxAttempts; port++) {
-        if (await isPortAvailable(port)) {
-            return port;
-        }
-    }
-    return null;
-}
-/**
- * Get the LAN IP address for mobile access
- */
-function getLanIp() {
-    const interfaces = networkInterfaces();
-    for (const [name, addrs] of Object.entries(interfaces)) {
-        // Skip loopback, docker, veth, bridge interfaces
-        if (/^(lo|docker|veth|br-|virbr)/.test(name))
-            continue;
-        for (const addr of addrs || []) {
-            if (addr.family === 'IPv4' && !addr.internal) {
-                return addr.address;
-            }
-        }
-    }
-    return 'localhost';
-}
-/**
- * Register projects with OpenCode by creating a session in each directory.
- * This triggers OpenCode to discover and register the project.
- */
-async function registerProjects(opencodePort, projectsDir) {
-    const baseUrl = `http://localhost:${opencodePort}`;
-    const registered = [];
-    if (projectsDir) {
-        // Resolve to absolute path
-        const absDir = path.resolve(projectsDir);
-        if (!existsSync(absDir)) {
-            p.log.error(`projects directory not found: ${absDir}`);
-            process.exit(1);
-        }
-        // Register each subdirectory (OpenCode will determine if it's a git repo)
-        const entries = readdirSync(absDir, { withFileTypes: true });
-        const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith('.'));
-        if (dirs.length === 0) {
-            p.log.error(`no subdirectories found in ${absDir}`);
-            process.exit(1);
-        }
-        for (const entry of dirs) {
-            const dir = path.join(absDir, entry.name);
-            try {
-                // Create a session to trigger project registration
-                await fetch(`${baseUrl}/session`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'X-OpenCode-Directory': dir,
-                    },
-                    body: JSON.stringify({}),
-                });
-                registered.push(entry.name);
-            }
-            catch {
-                // Silently skip failed registrations
-            }
-        }
-    }
-    else {
-        // Register cwd
-        const dir = process.cwd();
-        try {
-            await fetch(`${baseUrl}/session`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'X-OpenCode-Directory': dir,
-                },
-                body: JSON.stringify({}),
-            });
-            registered.push(path.basename(dir));
-        }
-        catch {
-            // Silently skip
-        }
-    }
-    return { count: registered.length, names: registered };
-}
-let opencodeServer = null;
-let expressProcess = null;
-async function startCommand(options) {
-    const port = parseInt(options.port);
-    const opencodePort = parseInt(options.opencodePort);
-    const cwd = process.cwd();
-    const verbose = options.verbose;
-    // Determine mode based on --projects-dir presence
-    const mode = options.projectsDir ? 'server' : 'cwd';
-    // Docker requires --projects-dir (server mode)
-    if (isDocker() && mode === 'cwd') {
-        p.log.error('--projects-dir is required when running in Docker');
-        p.log.message('example: docker run -v ~/code:/project shella --projects-dir /project');
-        p.log.message('or in docker-compose.yml: command: ["--projects-dir", "/project"]');
-        process.exit(1);
-    }
-    // Determine the directory to pass to the server
-    const projectsDir = options.projectsDir ? path.resolve(options.projectsDir) : cwd;
-    // Check if ports are available
-    const webPortAvailable = await isPortAvailable(port);
-    if (!webPortAvailable) {
-        p.log.error(`port ${port} is already in use`);
-        p.log.message('try: shella --port 3070');
-        process.exit(1);
-    }
-    // Check OpenCode port - use fallback if in use (likely another OpenCode instance)
-    let actualOpencodePort = opencodePort;
-    const ocPortAvailable = await isPortAvailable(opencodePort);
-    if (!ocPortAvailable) {
-        const fallbackPort = await findAvailablePort(opencodePort + 1);
-        if (!fallbackPort) {
-            p.log.error(`port ${opencodePort} is in use and no fallback ports available`);
-            process.exit(1);
-        }
-        actualOpencodePort = fallbackPort;
-        p.log.warn(`port ${opencodePort} is in use (possibly another OpenCode instance)`);
-        p.log.message(`using port ${actualOpencodePort} instead`);
-    }
-    // Ensure opencode binary from node_modules/.bin is in PATH
-    // Required for: npm install -g @bytespell/shella
-    // No-op for: npx (already in PATH)
-    // Helps with: Direct execution (node bin/cli.js)
-    const binPath = path.join(__dirname, '..', 'node_modules', '.bin');
-    const pathSep = process.platform === 'win32' ? ';' : ':';
-    process.env.PATH = process.env.PATH ? `${binPath}${pathSep}${process.env.PATH}` : binPath;
-    // In verbose mode, use simple status messages instead of clack UI
-    // This prevents spinner interference with log streaming
-    const s = verbose ? null : p.spinner();
-    const log = (msg) => {
-        if (verbose) {
-            console.log(msg);
-        }
-    };
-    if (!verbose) {
-        p.intro(`${brand('shella')} ${dim(`v${VERSION}`)}`);
-    }
-    else {
-        log(`${brand('shella')} ${dim(`v${VERSION}`)}`);
-    }
-    // Start OpenCode server using the bundled binary
-    if (s)
-        s.start('Starting OpenCode...');
-    else
-        log('starting opencode...');
-    // Set XDG env vars to isolate OpenCode data to shella directories
-    // This prevents shella from polluting user's existing OpenCode installation
-    const home = homedir();
-    process.env.XDG_DATA_HOME = path.join(home, '.local', 'share', 'shella');
-    process.env.XDG_CACHE_HOME = path.join(home, '.cache', 'shella');
-    process.env.XDG_CONFIG_HOME = path.join(home, '.config', 'shella');
-    process.env.XDG_STATE_HOME = path.join(home, '.local', 'state', 'shella');
-    try {
-        const config = getOpencodeConfig();
-        opencodeServer = await createOpencodeServer({
-            port: actualOpencodePort,
-            timeout: 30000,
-            config,
-        });
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        if (s)
-            s.stop('Failed to start OpenCode', 1);
-        p.log.error(message);
-        process.exit(1);
-    }
-    // Register projects with OpenCode
-    if (s)
-        s.message('Registering directories...');
-    else
-        log('registering directories...');
-    const { names } = await registerProjects(actualOpencodePort, options.projectsDir);
-    const projectName = names.length === 1 ? names[0] : names.length > 1 ? `${names.length} projects` : undefined;
-    // Start Express server in production mode, passing mode and directory
-    if (s)
-        s.message('Starting server...');
-    else
-        log('starting server...');
-    const serverPath = path.join(__dirname, '..', 'dist', 'server', 'index.js');
-    if (verbose) {
-        console.log(`[shella] mode: ${mode}, directory: ${projectsDir}`);
-    }
-    // Pass mode and directory to server
-    const serverArgs = mode === 'server'
-        ? ['--mode', 'server', '--projects-dir', projectsDir]
-        : ['--mode', 'cwd', '--directory', projectsDir];
-    expressProcess = spawn('node', [serverPath, ...serverArgs], {
-        env: {
-            ...process.env,
-            NODE_ENV: 'production',
-            PORT: String(port),
-            OPENCODE_URL: `http://localhost:${actualOpencodePort}`,
-        },
-        stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    // Track if server is ready (for verbose mode log streaming)
-    let serverReady = false;
-    // Wait for server to be ready
-    try {
-        await new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                reject(new Error('Server startup timeout'));
-            }, 10000);
-            expressProcess.stdout?.on('data', (data) => {
-                const output = data.toString();
-                if (output.includes('Running on')) {
-                    clearTimeout(timeout);
-                    serverReady = true;
-                    resolve();
-                }
-                // In verbose mode, stream logs after server is ready
-                if (verbose && serverReady) {
-                    process.stdout.write(output);
-                }
-            });
-            expressProcess.stderr?.on('data', (data) => {
-                // In verbose mode, stream stderr after server is ready
-                if (verbose && serverReady) {
-                    process.stderr.write(data);
-                }
-            });
-            expressProcess.on('error', (err) => {
-                clearTimeout(timeout);
-                reject(new Error(`Failed to spawn server: ${err.message}`));
-            });
-            expressProcess.on('exit', (code) => {
-                if (code !== 0 && code !== null) {
-                    clearTimeout(timeout);
-                    reject(new Error(`Server exited with code ${code}`));
-                }
-            });
-        });
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        if (s)
-            s.stop('Failed', 1);
-        p.log.error(message);
-        process.exit(1);
-    }
-    // Stop spinner and show success
-    if (s) {
-        s.stop('Ready');
-    }
-    // Show access URL
-    const lanIp = getLanIp();
-    const url = `http://${lanIp}:${port}`;
-    const title = projectName ? `${projectName}` : 'access from any device';
-    if (verbose) {
-        log(`\n${brand(url)}`);
-        log(dim(title));
-        log(`\n${dim('press ctrl+c to stop')}\n`);
-    }
-    else {
-        p.log.success(`${brand(url)}`);
-        p.log.message(dim(title));
-        p.outro(dim('press ctrl+c to stop'));
-    }
-    // Open browser if requested
-    if (options.open) {
-        const localUrl = `http://localhost:${port}`;
-        const openCommand = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
-        spawn(openCommand, [localUrl], { stdio: 'ignore', detached: true }).unref();
-    }
-}
-/**
- * Graceful shutdown handler
- */
-function shutdown() {
-    console.log(''); // newline after ^C
-    console.log(dim('stopping...'));
-    if (expressProcess) {
-        expressProcess.kill('SIGTERM');
-        expressProcess = null;
-    }
-    if (opencodeServer) {
-        opencodeServer.close();
-        opencodeServer = null;
-    }
-    console.log(`${brand('shella')} ${dim('stopped')}`);
-    process.exit(0);
-}
-// Handle shutdown signals
-process.on('SIGINT', shutdown);
-process.on('SIGTERM', shutdown);
-// CLI definition
-// Default verbose to true in Docker for easier debugging
-const defaultVerbose = isDocker();
-program
-    .name('shella')
-    .description(`${brand('shella')} - Self-hosted AI coding agents. Access from your phone.
-
-Modes:
-  ${brand('shella')}                    Run in current directory (cwd mode)
-  ${brand('shella')} --projects-dir .   Register all subdirectories as projects (server mode)`)
-    .version(VERSION)
-    .option('-p, --port <port>', 'Web server port', '3067')
-    .option('--opencode-port <port>', 'OpenCode server port', '4096')
-    .option('--projects-dir <path>', 'Directory containing projects (each subdirectory becomes a project)')
-    .option('--no-open', "Don't open browser automatically")
-    .option('-v, --verbose', 'Show detailed logs during startup', defaultVerbose)
-    .option('--quiet', 'Suppress logs (opposite of --verbose)')
-    .action((options) => {
-    // --quiet overrides --verbose
-    if (options.quiet) {
-        options.verbose = false;
-    }
-    return startCommand(options);
-});
-program.parse();

package/dev/cli.tsx

@@ -1,38 +0,0 @@
-#!/usr/bin/env -S npx tsx
-/**
- * shella dev CLI - Ink-based development server orchestrator
- *
- * Usage:
- *   npx devi              Start interactive TUI (default)
- *   npx devi [command]    Run command and exit
- *
- * Commands:
- *   status, start, stop, logs, errors, clear
- *   docker:up, docker:down, docker:status, etc.
- */
-
-export {}; // Make this a module for top-level await
-
-import fs from 'fs';
-
-// Check if running inside a container - this tool won't work there
-if (fs.existsSync('/.dockerenv') || fs.existsSync('/run/.containerenv')) {
-  console.error('\x1b[31m✗ Error: Running inside a container\x1b[0m');
-  console.error(
-    '\x1b[33m  The dev tool manages host-based servers and cannot be used from containers.\x1b[0m',
-  );
-  console.error('\x1b[33m  Please run this command from your host machine instead.\x1b[0m');
-  process.exit(1);
-}
-
-const args = process.argv.slice(2);
-
-if (args.length === 0) {
-  // Interactive mode - launch Ink TUI
-  const { runInteractive } = await import('./interactive.js');
-  await runInteractive();
-} else {
-  // Non-interactive - run command and exit
-  const { runCommand } = await import('./core.js');
-  await runCommand(args);
-}

package/dist/config/openai-codex-models.json

@@ -1,205 +0,0 @@
-{
-  "$schema": "https://opencode.ai/config.json",
-  "plugin": ["opencode-openai-codex-auth"],
-  "provider": {
-    "openai": {
-      "options": {
-        "reasoningEffort": "medium",
-        "reasoningSummary": "auto",
-        "textVerbosity": "medium",
-        "include": ["reasoning.encrypted_content"],
-        "store": false
-      },
-      "models": {
-        "gpt-5.2": {
-          "name": "GPT 5.2 (OAuth)",
-          "limit": {
-            "context": 272000,
-            "output": 128000
-          },
-          "modalities": {
-            "input": ["text", "image"],
-            "output": ["text"]
-          },
-          "variants": {
-            "none": {
-              "reasoningEffort": "none",
-              "reasoningSummary": "auto",
-              "textVerbosity": "medium"
-            },
-            "low": {
-              "reasoningEffort": "low",
-              "reasoningSummary": "auto",
-              "textVerbosity": "medium"
-            },
-            "medium": {
-              "reasoningEffort": "medium",
-              "reasoningSummary": "auto",
-              "textVerbosity": "medium"
-            },
-            "high": {
-              "reasoningEffort": "high",
-              "reasoningSummary": "detailed",
-              "textVerbosity": "medium"
-            },
-            "xhigh": {
-              "reasoningEffort": "xhigh",
-              "reasoningSummary": "detailed",
-              "textVerbosity": "medium"
-            }
-          }
-        },
-        "gpt-5.2-codex": {
-          "name": "GPT 5.2 Codex (OAuth)",
-          "limit": {
-            "context": 272000,
-            "output": 128000
-          },
-          "modalities": {
-            "input": ["text", "image"],
-            "output": ["text"]
-          },
-          "variants": {
-            "low": {
-              "reasoningEffort": "low",
-              "reasoningSummary": "auto",
-              "textVerbosity": "medium"
-            },
-            "medium": {
-              "reasoningEffort": "medium",
-              "reasoningSummary": "auto",
-              "textVerbosity": "medium"
-            },
-            "high": {
-              "reasoningEffort": "high",
-              "reasoningSummary": "detailed",
-              "textVerbosity": "medium"
-            },
-            "xhigh": {
-              "reasoningEffort": "xhigh",
-              "reasoningSummary": "detailed",
-              "textVerbosity": "medium"
-            }
-          }
-        },
-        "gpt-5.1-codex-max": {
-          "name": "GPT 5.1 Codex Max (OAuth)",
-          "limit": {
-            "context": 272000,
-            "output": 128000
-          },
-          "modalities": {
-            "input": ["text", "image"],
-            "output": ["text"]
-          },
-          "variants": {
-            "low": {
-              "reasoningEffort": "low",
-              "reasoningSummary": "detailed",
-              "textVerbosity": "medium"
-            },
-            "medium": {
-              "reasoningEffort": "medium",
-              "reasoningSummary": "detailed",
-              "textVerbosity": "medium"
-            },
-            "high": {
-              "reasoningEffort": "high",
-              "reasoningSummary": "detailed",
-              "textVerbosity": "medium"
-            },
-            "xhigh": {
-              "reasoningEffort": "xhigh",
-              "reasoningSummary": "detailed",
-              "textVerbosity": "medium"
-            }
-          }
-        },
-        "gpt-5.1-codex": {
-          "name": "GPT 5.1 Codex (OAuth)",
-          "limit": {
-            "context": 272000,
-            "output": 128000
-          },
-          "modalities": {
-            "input": ["text", "image"],
-            "output": ["text"]
-          },
-          "variants": {
-            "low": {
-              "reasoningEffort": "low",
-              "reasoningSummary": "auto",
-              "textVerbosity": "medium"
-            },
-            "medium": {
-              "reasoningEffort": "medium",
-              "reasoningSummary": "auto",
-              "textVerbosity": "medium"
-            },
-            "high": {
-              "reasoningEffort": "high",
-              "reasoningSummary": "detailed",
-              "textVerbosity": "medium"
-            }
-          }
-        },
-        "gpt-5.1-codex-mini": {
-          "name": "GPT 5.1 Codex Mini (OAuth)",
-          "limit": {
-            "context": 272000,
-            "output": 128000
-          },
-          "modalities": {
-            "input": ["text", "image"],
-            "output": ["text"]
-          },
-          "variants": {
-            "medium": {
-              "reasoningEffort": "medium",
-              "reasoningSummary": "auto",
-              "textVerbosity": "medium"
-            },
-            "high": {
-              "reasoningEffort": "high",
-              "reasoningSummary": "detailed",
-              "textVerbosity": "medium"
-            }
-          }
-        },
-        "gpt-5.1": {
-          "name": "GPT 5.1 (OAuth)",
-          "limit": {
-            "context": 272000,
-            "output": 128000
-          },
-          "modalities": {
-            "input": ["text", "image"],
-            "output": ["text"]
-          },
-          "variants": {
-            "none": {
-              "reasoningEffort": "none",
-              "reasoningSummary": "auto",
-              "textVerbosity": "medium"
-            },
-            "low": {
-              "reasoningEffort": "low",
-              "reasoningSummary": "auto",
-              "textVerbosity": "low"
-            },
-            "medium": {
-              "reasoningEffort": "medium",
-              "reasoningSummary": "auto",
-              "textVerbosity": "medium"
-            },
-            "high": {
-              "reasoningEffort": "high",
-              "reasoningSummary": "detailed",
-              "textVerbosity": "high"
-            }
-          }
-        }
-      }
-    }
-  }
-}

package/dist/server/index.d.ts

@@ -1,6 +0,0 @@
-declare const CONFIG_DIR: string;
-export declare const MODE: "cwd" | "server";
-export declare const DIRECTORY: string | null;
-export declare const PROJECTS_DIR: string | null;
-export declare const VERSION = "0.1.4";
-export { CONFIG_DIR };