@bytespell/shella 0.1.2 → 0.1.4

package/README.md

@@ -1,4 +1,4 @@
-# Shella
+# shella
 
 Self-hosted AI coding agents. Access from your phone.
 
@@ -6,29 +6,39 @@ Run multiple AI agents in parallel, persist sessions across devices, and manage
 
 ## Install
 
-### npx (Developers)
+### Quick Start (npx)
 
 ```bash
-# From your project directory
 cd ~/myproject
 npx @bytespell/shella
 ```
 
 Opens at `http://localhost:3067`. Access from your phone using the LAN IP shown.
 
-For multiple projects:
+### Permanent Install
 
 ```bash
-npx @bytespell/shella --projects-dir ~/code
+npm install -g @bytespell/shella
+shella
 ```
 
-### Docker (Homelab)
+Now you can run `shella` from any directory.
+
+### Multiple Projects
+
+```bash
+shella --projects-dir ~/code
+```
+
+Registers all subdirectories of `~/code` as available projects.
+
+### Docker
 
 ```yaml
 # docker-compose.yml
 services:
   shella:
-    image: ghcr.io/bytespell/shella
+    image: ghcr.io/bytespell-oss/shella
     ports:
       - '3067:3067'
     volumes:
@@ -70,6 +80,9 @@ shella --help                       # Show help
 # Install dependencies
 npm install
 
+# Create .env.local with your projects directory
+echo "SHELLA_PROJECTS_DIR=/path/to/your/projects" > .env.local
+
 # Start dev servers (Vite + Express + OpenCode)
 npm run start:dev
 

package/bin/cli.js

@@ -4,11 +4,26 @@ import { createOpencodeServer } from '@opencode-ai/sdk';
 import { networkInterfaces } from 'os';
 import { spawn } from 'child_process';
 import { createConnection } from 'net';
-import { existsSync, readdirSync } from 'fs';
+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.2';
+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
  */
@@ -53,51 +68,42 @@ function getLanIp() {
     return 'localhost';
 }
 /**
- * Print a nice boxed message with the access URL
- */
-function printAccessBox(lanIp, port) {
-    const url = `http://${lanIp}:${port}`;
-    const urlLine = `    ${url}`;
-    const width = Math.max(44, urlLine.length + 4);
-    const border = '-'.repeat(width);
-    const pad = (s) => s + ' '.repeat(width - s.length);
-    console.log(`
-+${border}+
-|${pad('')}|
-|${pad('  Access from any device:')}|
-|${pad('')}|
-|${pad(urlLine)}|
-|${pad('')}|
-+${border}+
-`);
-}
-/**
- * Register projects with OpenCode
+ * 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)) {
-            console.error(`Error: Projects directory not found: ${absDir}`);
+            p.log.error(`projects directory not found: ${absDir}`);
             process.exit(1);
         }
-        // Register each subdirectory
+        // 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) {
-            console.error(`Error: No project directories found in ${absDir}`);
+            p.log.error(`no subdirectories found in ${absDir}`);
             process.exit(1);
         }
         for (const entry of dirs) {
             const dir = path.join(absDir, entry.name);
             try {
-                await fetch(`${baseUrl}/project?directory=${encodeURIComponent(dir)}`);
-                console.log(`  Registered: ${entry.name}`);
+                // 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 (err) {
-                console.error(`  Failed to register ${entry.name}: ${err}`);
+            catch {
+                // Silently skip failed registrations
             }
         }
     }
@@ -105,72 +111,115 @@ async function registerProjects(opencodePort, projectsDir) {
         // Register cwd
         const dir = process.cwd();
         try {
-            await fetch(`${baseUrl}/project?directory=${encodeURIComponent(dir)}`);
-            console.log(`  Registered: ${path.basename(dir)}`);
+            await fetch(`${baseUrl}/session`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-OpenCode-Directory': dir,
+                },
+                body: JSON.stringify({}),
+            });
+            registered.push(path.basename(dir));
         }
-        catch (err) {
-            console.error(`  Failed to register ${path.basename(dir)}: ${err}`);
+        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);
-    console.log(`Shella v${VERSION}\n`);
-    // Docker requires --projects-dir
-    if (isDocker() && !options.projectsDir) {
-        console.error('Error: --projects-dir is required when running in Docker.\n');
-        console.error('Example:');
-        console.error('  docker run -v ~/code:/project shella --projects-dir /project\n');
-        console.error('Or in docker-compose.yml:');
-        console.error('  command: ["--projects-dir", "/project"]');
+    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);
     const ocPortAvailable = await isPortAvailable(opencodePort);
     if (!webPortAvailable) {
-        console.error(`Error: Port ${port} is already in use.`);
-        console.error(`\nTry one of these:`);
-        console.error(`  - Stop the process using port ${port}`);
-        console.error(`  - Use a different port: shella --port 3070`);
+        p.log.error(`port ${port} is already in use`);
+        p.log.message('try: shella --port 3070');
         process.exit(1);
     }
     if (!ocPortAvailable) {
-        console.error(`Error: Port ${opencodePort} is already in use (OpenCode port).`);
-        console.error(`\nThis usually means OpenCode is already running.`);
-        console.error(`\nTry one of these:`);
-        console.error(`  - Kill the existing OpenCode: pkill -f "opencode serve"`);
-        console.error(`  - Use a different port: shella --opencode-port 4097`);
+        p.log.error(`port ${opencodePort} is already in use (opencode)`);
+        p.log.message('try: pkill -f "opencode serve" or shella --opencode-port 4097');
         process.exit(1);
     }
+    // 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
-    console.log('Starting OpenCode...');
+    if (s)
+        s.start('Starting OpenCode...');
+    else
+        log('starting opencode...');
     try {
+        const config = getOpencodeConfig();
         opencodeServer = await createOpencodeServer({
             port: opencodePort,
             timeout: 30000,
+            config,
         });
-        console.log(`  OpenCode ready (port ${opencodePort})`);
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        console.error(`\nFailed to start OpenCode: ${message}`);
-        if (message.includes('port')) {
-            console.error(`\nThe port ${opencodePort} may be in use. Try:`);
-            console.error(`  shella --opencode-port 4097`);
-        }
+        if (s)
+            s.stop('Failed to start OpenCode', 1);
+        p.log.error(message);
         process.exit(1);
     }
     // Register projects with OpenCode
-    console.log('Registering projects...');
-    await registerProjects(opencodePort, options.projectsDir);
-    // Start Express server in production mode
-    console.log('Starting Shella server...');
+    if (s)
+        s.message('Registering directories...');
+    else
+        log('registering directories...');
+    const { names } = await registerProjects(opencodePort, 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');
-    expressProcess = spawn('node', [serverPath], {
+    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',
@@ -178,51 +227,82 @@ async function startCommand(options) {
         },
         stdio: ['ignore', 'pipe', 'pipe'],
     });
+    // Track if server is ready (for verbose mode log streaming)
+    let serverReady = false;
     // Wait for server to be ready
-    await new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-            reject(new Error('Server startup timeout (10s). Check logs for errors.'));
-        }, 10000);
-        expressProcess.stdout?.on('data', (data) => {
-            const output = data.toString();
-            if (output.includes('Running on')) {
-                clearTimeout(timeout);
-                resolve();
-            }
-            // Forward output but strip the prefix since we add our own
-            process.stdout.write(output.replace(/\[shella-server\] /g, '  '));
-        });
-        expressProcess.stderr?.on('data', (data) => {
-            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) {
+    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(`Server exited with code ${code}`));
-            }
+                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}`));
+                }
+            });
         });
-    });
-    console.log(`  Shella ready (port ${port})`);
-    // Print access box
+    }
+    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();
-    printAccessBox(lanIp, port);
-    console.log('Press Ctrl+C to stop\n');
+    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 url = `http://localhost:${port}`;
+        const localUrl = `http://localhost:${port}`;
         const openCommand = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
-        spawn(openCommand, [url], { stdio: 'ignore', detached: true }).unref();
+        spawn(openCommand, [localUrl], { stdio: 'ignore', detached: true }).unref();
     }
 }
 /**
  * Graceful shutdown handler
  */
 function shutdown() {
-    console.log('\nShutting down...');
+    console.log(''); // newline after ^C
+    console.log(dim('stopping...'));
     if (expressProcess) {
         expressProcess.kill('SIGTERM');
         expressProcess = null;
@@ -231,23 +311,34 @@ function shutdown() {
         opencodeServer.close();
         opencodeServer = null;
     }
-    console.log('Goodbye!');
+    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('Self-hosted AI coding agents. Access from your phone.')
-    .version(VERSION);
-program
-    .command('start', { isDefault: true })
-    .description('Start 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")
-    .action(startCommand);
+    .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

@@ -0,0 +1,26 @@
+#!/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
+
+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);
+}