@aitherium/shell-cli 1.1.0

package/dist/main.js

@@ -0,0 +1,389 @@
+#!/usr/bin/env node
+// Trust AitherOS self-signed TLS certs without disabling all verification.
+// Prefer NODE_EXTRA_CA_CERTS (adds our CA to the trust chain) if available;
+// only fall back to NODE_TLS_REJECT_UNAUTHORIZED=0 when no CA chain exists.
+import { existsSync } from 'fs';
+import { join, basename } from 'path';
+const _caChainPaths = [
+    join(process.env.HOME || process.env.USERPROFILE || '', '.aither', 'tls', 'ca-chain.pem'),
+    join(process.env.AITHEROS_ROOT || '', 'Library', 'Data', 'tls', 'ca-chain.pem'),
+    '/app/AitherOS/Library/Data/tls/ca-chain.pem',
+];
+const _caChain = _caChainPaths.find(p => p && existsSync(p));
+if (_caChain) {
+    process.env.NODE_EXTRA_CA_CERTS = _caChain;
+}
+else {
+    // No CA chain found — disable verification as last resort (suppress warning via env)
+    process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+}
+/**
+ * AitherShell CLI — interactive terminal for AitherOS.
+ *
+ * Usage:
+ *   aither-shell                     Interactive REPL
+ *   aither-shell "question"          One-shot mode
+ *   aither-shell -c status           Execute slash command and exit
+ *   aither-shell -f "task"           Forge dispatch and exit
+ *   aither-shell --help              Show help
+ */
+import chalk from 'chalk';
+import { readFileSync } from 'fs';
+import { extname } from 'path';
+import { loadConfig } from './config.js';
+import { GenesisClient } from './client.js';
+import { renderBanner, createStreamRenderer } from './renderer.js';
+import { startRepl } from './repl.js';
+const VERSION = '1.1.0';
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.includes('--help') || args.includes('-h')) {
+        printUsage();
+        return;
+    }
+    if (args.includes('--version') || args.includes('-v')) {
+        console.log(`aither-shell ${VERSION}`);
+        return;
+    }
+    const config = loadConfig();
+    const client = new GenesisClient(config.genesisUrl);
+    // Wire auth token from config to client
+    if (config.authToken) {
+        client.setAuthToken(config.authToken, config.authUser?.tenant_id ?? null, config.authUser?.id ?? null);
+    }
+    // Handle --login and --key flags for non-interactive auth
+    const loginIdx = args.indexOf('--login');
+    const keyIdx = args.indexOf('--key');
+    if (keyIdx >= 0 && args[keyIdx + 1]) {
+        const { validateToken: valToken, buildProfile, setProfile } = await import('./auth.js');
+        const token = args[keyIdx + 1];
+        const user = await valToken(config.identityUrl, token);
+        if (user) {
+            const profile = buildProfile(config.identityUrl, config.genesisUrl, {
+                access_token: token, token_type: 'api_key', user,
+            });
+            setProfile('local', profile);
+            config.authToken = token;
+            config.authUser = profile.user;
+            client.setAuthToken(token, profile.user.tenant_id || null, profile.user.id || null);
+        }
+        else {
+            console.error(chalk.red('Invalid API key'));
+            process.exit(1);
+        }
+    }
+    // Parse creative flags (--will, --safety, --private, --effort) early
+    // so they apply to both runOneShot and positional one-shot chat.
+    for (let i = 0; i < args.length; i++) {
+        if ((args[i] === '--will' || args[i] === '--agent' || args[i] === '-a') && args[i + 1]) {
+            config.defaultAgent = args[i + 1];
+        }
+        else if ((args[i] === '--effort' || args[i] === '-e') && args[i + 1]) {
+            config.effort = Number(args[i + 1]);
+        }
+        else if ((args[i] === '--safety' || args[i] === '-s') && args[i + 1]) {
+            config.safetyLevel = args[i + 1];
+        }
+        else if (args[i] === '--private') {
+            config.privateMode = true;
+        }
+        else if ((args[i] === '--image' || args[i] === '-i') && args[i + 1]) {
+            const imgPath = args[++i];
+            try {
+                const buf = readFileSync(imgPath);
+                const ext = extname(imgPath).toLowerCase().replace('.', '');
+                const mimeMap = { jpg: 'jpeg', jpeg: 'jpeg', png: 'png', gif: 'gif', webp: 'webp', bmp: 'bmp' };
+                const mime = mimeMap[ext] || 'png';
+                const dataUrl = `data:image/${mime};base64,${buf.toString('base64')}`;
+                config.imageAttachments = config.imageAttachments || [];
+                config.imageAttachments.push(dataUrl);
+            }
+            catch (err) {
+                console.error(chalk.red(`Cannot read image: ${imgPath} — ${err.message}`));
+                process.exit(1);
+            }
+        }
+    }
+    // If invoked as "aither-install" (binary name contains "install"), run install flow directly
+    const binaryName = process.argv[1] ? basename(process.argv[1]).toLowerCase() : '';
+    if (binaryName.includes('install') && !args.includes('-c') && !args.includes('--command')) {
+        const { getCommand } = await import('./commands.js');
+        const installCmd = getCommand('install');
+        if (installCmd) {
+            await installCmd.handler(client, args.join(' '), config);
+            process.exit(0);
+        }
+    }
+    // Try non-interactive (flag-based) execution first
+    const handled = await runOneShot(client, config);
+    if (handled)
+        process.exit(0);
+    // Collect positional args (everything before first -- flag)
+    const positional = [];
+    for (const arg of args) {
+        if (arg.startsWith('-'))
+            break;
+        positional.push(arg);
+    }
+    if (positional.length > 0) {
+        await oneShotChat(client, config, positional.join(' '));
+    }
+    else {
+        await showBanner(client, config);
+        await startRepl(client, config);
+    }
+}
+/* ── Banner with live status ────────────────────────────────── */
+async function showBanner(client, config) {
+    const backend = await client.detectBackend();
+    // Propagate detected backend into config for downstream use
+    config.backendType = backend.type;
+    config.backendName = backend.name;
+    const genesisOnline = backend.type !== 'unknown';
+    let llm;
+    const serviceLines = [];
+    if (backend.type === 'genesis') {
+        // Genesis-specific status enrichment
+        try {
+            const statusData = await client.getStatus().catch(() => null);
+            const pain = statusData?.children_in_pain || [];
+            if (statusData) {
+                serviceLines.push({ name: 'Node', up: !pain.includes('Node') && !pain.includes('AitherNode') });
+            }
+        }
+        catch { }
+        if (backend.generationReady === false) {
+            llm = 'BUSY (no slots)';
+        }
+        else if (backend.generationReady === true) {
+            llm = backend.slotsAvailable != null ? `LLM ready (${backend.slotsAvailable} slots)` : 'LLM ready';
+        }
+        else if (backend.llmBackend) {
+            llm = backend.llmBackend;
+        }
+    }
+    else if (backend.type === 'adk') {
+        llm = backend.llmBackend || undefined;
+    }
+    const host = (() => {
+        try {
+            return new URL(config.genesisUrl).host;
+        }
+        catch {
+            return config.genesisUrl;
+        }
+    })();
+    const authUser = config.authUser?.display_name || config.authUser?.username;
+    renderBanner({
+        genesis: host,
+        genesisOnline,
+        services: backend.services,
+        agents: backend.agents,
+        llm,
+        user: authUser,
+        serviceLines,
+        backendType: backend.type,
+        backendName: backend.name,
+    });
+}
+/* ── Non-interactive mode (flag-based) ────────────────────── */
+async function runOneShot(client, config) {
+    const args = process.argv.slice(2);
+    // Parse flags
+    let command;
+    let forgeTask;
+    let agent;
+    let effort;
+    let safetyLevel;
+    let privateMode = false;
+    let chatMessage;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if ((arg === '--command' || arg === '-c') && args[i + 1]) {
+            // Collect command name + everything after it until next flag as args
+            // e.g. -c "run list scale" → command="run list scale"
+            //      -c run list scale   → command="run list scale"
+            const next = args[++i];
+            // If the next arg is already quoted (contains spaces), use it as-is
+            // Otherwise collect remaining non-flag args
+            if (next.includes(' ')) {
+                command = next;
+            }
+            else {
+                const cmdParts = [next];
+                while (i + 1 < args.length && !args[i + 1].startsWith('-')) {
+                    cmdParts.push(args[++i]);
+                }
+                command = cmdParts.join(' ');
+            }
+        }
+        else if ((arg === '--forge' || arg === '-f') && args[i + 1]) {
+            forgeTask = args[++i];
+        }
+        else if ((arg === '--agent' || arg === '-a' || arg === '--will') && args[i + 1]) {
+            agent = args[++i];
+        }
+        else if ((arg === '--effort' || arg === '-e') && args[i + 1]) {
+            effort = Number(args[++i]);
+        }
+        else if ((arg === '--safety' || arg === '-s') && args[i + 1]) {
+            safetyLevel = args[++i];
+        }
+        else if (arg === '--private') {
+            privateMode = true;
+        }
+    }
+    // No flag-based one-shot arguments — return false to fall through
+    if (!command && !forgeTask)
+        return false;
+    // Override config agent if --agent was provided
+    if (agent)
+        config.defaultAgent = agent;
+    try {
+        if (command) {
+            // Execute slash command — split "run list scale" into name="run" cmdArgs="list scale"
+            const { getCommand } = await import('./commands.js');
+            const spaceIdx = command.indexOf(' ');
+            const cmdName = spaceIdx === -1 ? command : command.slice(0, spaceIdx);
+            const cmdArgs = spaceIdx === -1 ? '' : command.slice(spaceIdx + 1);
+            const cmd = getCommand(cmdName);
+            if (cmd) {
+                await cmd.handler(client, cmdArgs, config);
+            }
+            else {
+                console.error(chalk.red(`Unknown command: ${cmdName}`));
+                process.exit(1);
+            }
+        }
+        else if (forgeTask) {
+            // Dispatch via forge
+            const result = await client.forgeDispatch(forgeTask, {
+                agent: agent || config.defaultAgent,
+                effort,
+            });
+            const output = result?.response || result?.result || result?.output;
+            if (output) {
+                console.log(output);
+            }
+            else if (result?.error) {
+                console.error(chalk.red(`Error: ${result.error}`));
+                process.exit(1);
+            }
+            else {
+                console.log(JSON.stringify(result, null, 2));
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+    }
+    return true;
+}
+/* ── One-shot chat (positional args) ─────────────────────── */
+async function oneShotChat(client, config, message) {
+    const renderer = createStreamRenderer();
+    let failed = false;
+    try {
+        for await (const event of client.streamChat(message, {
+            agent: config.defaultAgent,
+            sessionId: config.sessionId,
+            model: config.model,
+            effort: config.effort,
+            safetyLevel: config.safetyLevel,
+            privateMode: config.privateMode,
+            attachments: config.imageAttachments,
+        })) {
+            renderer.onEvent(event);
+        }
+        renderer.finish();
+    }
+    catch (err) {
+        if (err.name === 'AbortError')
+            return;
+        failed = true;
+        const msg = err.message || 'unknown error';
+        if (msg.includes('took too long')) {
+            console.error(chalk.yellow(msg));
+            console.error(chalk.dim('Try: docker compose -f docker-compose.aitheros.yml --profile chat-full up -d'));
+        }
+        else if (msg.includes('Cannot connect') || msg.includes('ECONNREFUSED') || msg.includes('fetch failed')) {
+            console.error(chalk.red(`Backend not reachable at ${config.genesisUrl}`));
+            console.error(chalk.dim('Start Genesis: docker compose -f docker-compose.aitheros.yml --profile chat-minimal up -d'));
+            console.error(chalk.dim('  Or ADK:    adk serve --identity <agent>'));
+        }
+        else {
+            console.error(chalk.red(`Error: ${msg}`));
+        }
+        process.exit(1);
+    }
+}
+/* ── Help ───────────────────────────────────────────────────── */
+function printUsage() {
+    console.log(`
+${chalk.bold('aither')} \u2014 AitherOS interactive terminal
+
+${chalk.bold('Usage:')}
+  aither                          Start interactive REPL
+  aither "message"                One-shot: send, print, exit
+  aither -c <command>             Execute a slash command and exit
+  aither -f <task>                Forge dispatch and exit
+  aither --help                   Show this help
+  aither --version                Show version
+
+${chalk.bold('One-shot flags:')}
+  -c, --command <cmd>             Execute slash command (status, agents, services, gaming, apps, etc.)
+  -f, --forge <task>              Dispatch task via Forge
+  -a, --agent <name>              Agent for chat/forge (default: aither)
+      --will <name>               Alias for --agent (e.g. --will iris)
+  -e, --effort <N>                Effort level 1-10 (higher = deeper/quality)
+  -s, --safety <level>            Safety: unrestricted, casual, professional
+      --private                   Private mode (prompt hidden from logs/training)
+  -i, --image <path>              Attach image for vision analysis (repeatable)
+
+${chalk.bold('Quick actions:')}
+  aither -c gaming                Toggle gaming mode (free VRAM for games)
+  aither -c "gaming on"           Activate gaming mode
+  aither -c apps                  Show all AitherOS app statuses
+  aither -c "apps install desktop"  Install AitherDesktop
+  aither -c "apps start veil"    Start AitherVeil dashboard
+
+${chalk.bold('Examples:')}
+  aither -c status                Print system status and exit
+  aither -c agents                List agents and exit
+  aither -f "refactor auth module" -a demiurge -e 7
+  aither "What services are running?"
+  aither --will iris "draw a cyberpunk cityscape"
+  aither --will iris -e 8 "masterpiece portrait, 8k"
+  aither --will iris --safety unrestricted --private "private prompt"
+  aither --will saga "tell me about the ancient ruins"
+  aither --image screenshot.png "what's in this image?"
+  aither -i photo.jpg -i diagram.png "compare these two"
+
+${chalk.bold('Environment variables:')}
+  AITHER_API_URL                  Backend URL (Genesis or ADK server)
+  AITHER_GENESIS_URL              Legacy alias for AITHER_API_URL
+  AITHER_AGENT                    Default agent (default: aither)
+  AITHER_MODEL                    LLM model override
+
+${chalk.bold('Config file:')}
+  ~/.aither/shell.yaml            Optional (api_url, default_agent, model)
+
+${chalk.bold('Interactive commands:')}
+  /help        Show all commands       /agents      List agents
+  /status      System status           /services    List services
+  /forge       Dispatch to Forge       /logs        View logs
+  /gaming      Toggle gaming mode      /apps        Manage AitherOS apps
+  /sessions    List recent sessions    /resume      Resume a session
+  /model       Show/set model          /clear       Clear screen
+  exit         Quit
+
+${chalk.bold('Routing:')}
+  @agent_name message             Route to specific agent
+  message                         Route to default agent
+`);
+}
+main().catch((err) => {
+    console.error(chalk.red(`Fatal: ${err.message}`));
+    process.exit(1);
+});

package/dist/notebooks.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Agent Notebook interactive TUI for AitherShell CLI.
+ *
+ * Provides a proper interactive notebook experience in the terminal:
+ *   /nb list           — Browse notebooks with status/effort/tags
+ *   /nb open <id>      — Open interactive session (cell-by-cell execution)
+ *   /nb run <id>       — Execute entire notebook (streaming output)
+ *   /nb plan <prompt>  — Create notebook from natural language
+ *   /nb create <name>  — Create empty notebook
+ *   /nb templates      — List available templates
+ *   /nb sessions       — List active sessions
+ *
+ * The interactive session (/nb open) renders cells with box-drawing
+ * characters, colored output, and supports Shift+Enter / Enter to
+ * execute cells one at a time.
+ */
+import type { GenesisClient } from './client.js';
+import type { ShellConfig } from './config.js';
+export declare function handleNotebook(client: GenesisClient, args: string, _config: ShellConfig): Promise<void>;