@aitherium/shell-cli 1.1.0 → 1.11.0

package/dist/main.js

@@ -30,11 +30,56 @@ else {
 import chalk from 'chalk';
 import { readFileSync } from 'fs';
 import { extname } from 'path';
-import { loadConfig } from './config.js';
+import { loadConfig, setActiveConfig } from './config.js';
 import { GenesisClient } from './client.js';
 import { renderBanner, createStreamRenderer } from './renderer.js';
+import { buildProbes, probeHealth, pickServingModel } from './status-banner.js';
 import { startRepl } from './repl.js';
-const VERSION = '1.1.0';
+import { installCrashReporter } from './crash-reporter.js';
+import { configureRemoteSync, recordTurn, loadSession, loadRemoteSession, mostRecentSessionId, buildContextSummary, } from './session-store.js';
+/** Read piped stdin as text (headless prompt body). Empty if attached to a TTY. */
+async function readStdin() {
+    if (process.stdin.isTTY)
+        return '';
+    return new Promise((resolve) => {
+        let data = '';
+        let done = false;
+        const finish = () => { if (!done) {
+            done = true;
+            resolve(data.trim());
+        } };
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (c) => { data += c; });
+        process.stdin.on('end', finish);
+        process.stdin.on('error', finish);
+        // Safety: a non-TTY stdin that never closes (some pipes) must not hang the
+        // process — if no EOF arrives quickly, resolve with whatever we have.
+        setTimeout(finish, 1500);
+    });
+}
+/** Resolve a --continue/--resume/--session target into a session id + transcript. */
+async function resolveResume(client, config, mode, id) {
+    let sid = mode === 'continue' ? mostRecentSessionId() : (id || null);
+    if (!sid)
+        return null;
+    let entry = loadSession(sid);
+    if (!entry) {
+        try {
+            entry = await loadRemoteSession(sid);
+        }
+        catch {
+            entry = null;
+        }
+    }
+    config.sessionId = sid;
+    config.resumeSessionId = sid;
+    config.resumed = true;
+    return { sessionId: sid, summary: entry ? buildContextSummary(entry.messages) : '' };
+}
+// Install global crash reporter — catches uncaught exceptions/rejections,
+// prompts user to send error report, creates GitHub issue automatically.
+installCrashReporter();
+const VERSION = '1.10.0'; // keep in sync with package.json
 async function main() {
     const args = process.argv.slice(2);
     if (args.includes('--help') || args.includes('-h')) {
@@ -46,6 +91,7 @@ async function main() {
         return;
     }
     const config = loadConfig();
+    setActiveConfig(config);
     const client = new GenesisClient(config.genesisUrl);
     // Wire auth token from config to client
     if (config.authToken) {
@@ -74,6 +120,7 @@ async function main() {
     }
     // Parse creative flags (--will, --safety, --private, --effort) early
     // so they apply to both runOneShot and positional one-shot chat.
+    let printPrompt = ''; // prompt captured from `-p <prompt>`
     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];
@@ -103,6 +150,44 @@ async function main() {
                 process.exit(1);
             }
         }
+        else if (args[i] === '--print' || args[i] === '-p') {
+            config.printMode = true;
+            if (args[i + 1] && !args[i + 1].startsWith('-'))
+                printPrompt = args[++i];
+        }
+        else if (args[i] === '--output-format' && args[i + 1]) {
+            const f = args[++i];
+            config.outputFormat = (f === 'json' || f === 'stream-json') ? f : 'text';
+        }
+        else if (args[i] === '--json') {
+            config.outputFormat = 'json';
+            config.printMode = true;
+        }
+        else if (args[i] === '--continue' || args[i] === '-C') {
+            config.resumeSessionId = '__continue__'; // sentinel → most-recent session
+        }
+        else if ((args[i] === '--resume' || args[i] === '--session') && args[i + 1]) {
+            config.resumeSessionId = args[++i];
+        }
+        else if (args[i] === '--gateway') {
+            // Portable thin-client mode: point inference + tools at the public gateway.
+            // Accepts an optional URL (default mcp.aitherium.com). Forces raw inference
+            // unless --inference-mode overrides it later in the loop.
+            const url = (args[i + 1] && !args[i + 1].startsWith('-'))
+                ? args[++i].replace(/\/+$/, '')
+                : 'https://mcp.aitherium.com';
+            config.genesisUrl = url;
+            config.mcpUrl = config.mcpUrl || `${url}/mcp`;
+            config.llmUrl = config.llmUrl || `${url}/v1`;
+            if (config.inferenceMode === 'auto')
+                config.inferenceMode = 'raw';
+            client.setBaseUrl(url); // repoint the already-constructed client
+        }
+        else if (args[i] === '--inference-mode' && args[i + 1]) {
+            const m = args[++i].toLowerCase();
+            if (m === 'auto' || m === 'genesis' || m === 'raw')
+                config.inferenceMode = m;
+        }
     }
     // If invoked as "aither-install" (binary name contains "install"), run install flow directly
     const binaryName = process.argv[1] ? basename(process.argv[1]).toLowerCase() : '';
@@ -114,10 +199,61 @@ async function main() {
             process.exit(0);
         }
     }
+    // ── Explicit auth subcommands ──────────────────────────────────────────
+    // `aither login [--browser]`, `aither logout`, `aither whoami`. Without these,
+    // "login" fell through to positional one-shot chat → POSTed to the gateway's
+    // /chat/stream (which the OpenAI-compat gateway doesn't serve) → 404, surfaced
+    // as a confusing "Error: not_found". Device login always uses the IDENTITY URL.
+    if (args[0] === 'login') {
+        await ensureDeviceLogin(client, config);
+        process.exit(0);
+    }
+    if (args[0] === 'logout') {
+        const { clearProfile } = await import('./auth.js');
+        clearProfile('local');
+        console.log(chalk.green('  ✓ Signed out (cleared local profile).'));
+        process.exit(0);
+    }
+    if (args[0] === 'whoami') {
+        const u = config.authUser;
+        console.log(u
+            ? `  ${chalk.bold(u.display_name || u.username)} <${u.email}>`
+            : chalk.yellow('  Not signed in. Run `aither login`.'));
+        process.exit(0);
+    }
+    // ── Explicit one-shot subcommands that must NOT fall through to chat ──
+    // e.g. `aither node ls`, `aither node enroll --tenant acme`. Without this,
+    // "node ls" became a positional chat prompt → intent-classified as a query.
+    const ONESHOT_CMDS = new Set(['node', 'nodes']);
+    if (args[0] && ONESHOT_CMDS.has(args[0].toLowerCase())) {
+        const { getCommand } = await import('./commands.js');
+        const cmd = getCommand(args[0].toLowerCase());
+        if (cmd) {
+            await cmd.handler(client, args.slice(1).join(' '), config);
+            // Return (don't process.exit) so libuv drains the fetch keep-alive socket
+            // cleanly — a bare process.exit() here races teardown → UV_HANDLE_CLOSING
+            // assert on Windows. undici idle sockets are unref'd, so the loop ends.
+            process.exitCode = 0;
+            return;
+        }
+    }
     // Try non-interactive (flag-based) execution first
     const handled = await runOneShot(client, config);
     if (handled)
         process.exit(0);
+    // Enable remote session sync, then resolve any --continue/--resume/--session.
+    configureRemoteSync(config.genesisUrl, config.authToken);
+    let resumeSummary = '';
+    if (config.resumeSessionId === '__continue__') {
+        const r = await resolveResume(client, config, 'continue');
+        resumeSummary = r?.summary || '';
+        if (!r)
+            console.error(chalk.yellow('No previous session to continue.'));
+    }
+    else if (config.resumeSessionId) {
+        const r = await resolveResume(client, config, 'id', config.resumeSessionId);
+        resumeSummary = r?.summary || '';
+    }
     // Collect positional args (everything before first -- flag)
     const positional = [];
     for (const arg of args) {
@@ -125,15 +261,138 @@ async function main() {
             break;
         positional.push(arg);
     }
-    if (positional.length > 0) {
-        await oneShotChat(client, config, positional.join(' '));
+    const wantsHeadless = positional.length > 0 || config.printMode;
+    if (wantsHeadless) {
+        let prompt = positional.join(' ') || printPrompt;
+        if (config.printMode) {
+            const piped = await readStdin();
+            prompt = [prompt, piped].filter(Boolean).join('\n\n');
+        }
+        if (!prompt.trim()) {
+            console.error(chalk.red('No prompt provided (positional argument or piped stdin).'));
+            process.exit(1);
+        }
+        const ok = await oneShotChat(client, config, prompt, resumeSummary);
+        process.exit(ok ? 0 : 1);
     }
     else {
+        // Remote endpoints force a real sign-in before the shell opens.
+        if (config.requireAuth && !config.authToken) {
+            await ensureDeviceLogin(client, config);
+        }
         await showBanner(client, config);
         await startRepl(client, config);
     }
 }
 /* ── Banner with live status ────────────────────────────────── */
+// probeHealth / buildProbes / pickServingModel moved to ./status-banner.ts
+// (shared with the in-TUI live status header).
+/** Force a device-flow login when the endpoint requires auth and no valid
+ *  token exists. Reuses the existing device-code helpers; prints the
+ *  server-provided verification URL (portal.aitherium.com/link) + user code,
+ *  then polls until the user approves in the browser. */
+async function ensureDeviceLogin(client, config) {
+    const { requestDeviceCode, pollDeviceToken, buildProfile, setProfile } = await import('./auth.js');
+    console.log();
+    console.log(chalk.bold('  🔐 This endpoint requires sign-in (no local root).'));
+    try {
+        const dc = await requestDeviceCode(config.identityUrl, 'AitherShell');
+        console.log();
+        console.log('  Open this URL in your browser and approve the device:');
+        console.log('  ' + chalk.cyan(dc.verification_uri_complete || dc.verification_uri));
+        if (dc.user_code) {
+            console.log();
+            console.log('  Code: ' + chalk.bold.yellow(dc.user_code));
+        }
+        console.log();
+        process.stdout.write(chalk.dim('  Waiting for authorization'));
+        const deadline = Date.now() + (dc.expires_in || 900) * 1000;
+        const interval = Math.max(2, dc.interval || 5) * 1000;
+        while (Date.now() < deadline) {
+            await new Promise((r) => setTimeout(r, interval));
+            try {
+                const result = await pollDeviceToken(config.identityUrl, dc.device_code);
+                if ((result.status === 'complete' || result.status === 'authorized') && result.access_token) {
+                    const profile = buildProfile(config.identityUrl, config.genesisUrl, result);
+                    setProfile('local', profile);
+                    config.authToken = profile.access_token;
+                    config.authUser = profile.user;
+                    client.setAuthToken(profile.access_token, profile.user.tenant_id || null, profile.user.id || null);
+                    console.log();
+                    console.log(chalk.green(`  ✓ Signed in as ${chalk.bold(profile.user.display_name || profile.user.username)} (${profile.user.email})`));
+                    // Register this endpoint/agent with the mesh under the signed-in user.
+                    await registerRemoteEndpoint(config);
+                    console.log();
+                    return;
+                }
+            }
+            catch (err) {
+                if (String(err?.message || '').includes('expired')) {
+                    console.log();
+                    console.log(chalk.red('  Device code expired — re-run `aither` to retry.'));
+                    return;
+                }
+                // authorization_pending — keep polling
+            }
+            process.stdout.write(chalk.dim('.'));
+        }
+        console.log();
+        console.log(chalk.yellow('  Sign-in timed out. Run `/login --browser` from the shell to retry.'));
+    }
+    catch (err) {
+        console.log();
+        console.log(chalk.red(`  Could not start sign-in: ${err.message}`));
+        console.log(chalk.dim('  Run `/login` from the shell to try another method.'));
+    }
+}
+/** Best-effort: register this workspace as a mesh node/agent under the
+ *  signed-in user via the public gateway (POST /v1/mesh/join). Ties the
+ *  endpoint/agent registration to the authenticated identity. Never throws. */
+async function registerRemoteEndpoint(config) {
+    if (!config.authToken)
+        return;
+    const base = config.genesisUrl.replace(/\/+$/, '');
+    const who = config.authUser?.username || config.authUser?.email || 'agent';
+    const nodeName = `devws-${who}-${(process.env.HOSTNAME || '').slice(0, 12)}`.replace(/[^a-zA-Z0-9_-]/g, '-').slice(0, 60);
+    try {
+        const r = await fetch(`${base}/v1/mesh/join`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${config.authToken}` },
+            body: JSON.stringify({
+                node_name: nodeName,
+                capabilities: ['dev-workspace', 'aither-cli'],
+                endpoint: process.env.AITHER_MESH_IP || '',
+            }),
+            signal: AbortSignal.timeout(10000),
+        });
+        if (r.ok)
+            console.log(chalk.dim('  ✓ Endpoint registered with AitherMesh.'));
+    }
+    catch { /* best-effort — registration is also done server-side at spawn */ }
+}
+// _BACKEND_WHERE / pickServingModel moved to ./status-banner.ts.
+/** Warm the orchestrator model on connect so the first real turn isn't cold.
+ *  Visible (the user asked to SEE it) and best-effort — never blocks for long
+ *  and never throws. Also fires a non-awaited Genesis context nudge so the
+ *  code/knowledge-graph gather is warm by the first message too. */
+async function warmOnConnect(client, config, model) {
+    if (process.env.AITHER_NO_WARMUP)
+        return;
+    const target = model || config.model || 'aither-orchestrator';
+    process.stdout.write(chalk.dim(`  ⚡ Warming ${target}… `));
+    // Fire-and-forget context warm (don't block the prompt on the heavy pipeline).
+    void fetch(`${config.genesisUrl.replace(/\/+$/, '')}/status`, {
+        signal: AbortSignal.timeout(8000),
+    }).catch(() => { });
+    const res = await client.warmupModel(target).catch(() => null);
+    if (res) {
+        console.log(chalk.green(`✓ warm (${(res.ms / 1000).toFixed(1)}s)`));
+    }
+    else {
+        console.log(chalk.yellow('skipped (cold start may add a few seconds to the first reply)'));
+    }
+    console.log();
+}
 async function showBanner(client, config) {
     const backend = await client.detectBackend();
     // Propagate detected backend into config for downstream use
@@ -142,28 +401,54 @@ async function showBanner(client, config) {
     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)';
+    // ── Always probe key services independently ────────────────
+    // These run regardless of Genesis status so the banner never
+    // shows "no services detected" when services ARE actually up.
+    // The probe set adapts to the configured endpoints: a remote endpoint
+    // probes the PUBLIC authenticated edges it actually talks to, not 127.0.0.1.
+    const probes = buildProbes(config);
+    const probeResults = await Promise.all(probes.map(async (p) => ({ name: p.name, up: await probeHealth(p.url) })));
+    for (const r of probeResults) {
+        serviceLines.push(r);
+    }
+    // ── Loaded model + where (from the MicroScheduler backend snapshot) ──
+    // Shows the ACTUAL serving model and its location (vLLM/DGX/cloud) instead of
+    // a vague "LLM ready", so the banner answers "what model is loaded and where".
+    let warmModel;
+    const snapshot = await client.getBackendSnapshot().catch(() => null);
+    if (snapshot?.backends) {
+        const pick = pickServingModel(snapshot.backends);
+        if (pick) {
+            llm = `${pick.model} @ ${pick.where}`;
+            warmModel = pick.model;
         }
-        else if (backend.generationReady === true) {
-            llm = backend.slotsAvailable != null ? `LLM ready (${backend.slotsAvailable} slots)` : 'LLM ready';
+    }
+    // ── Genesis-enriched status (supplements direct probes) ────
+    if (!llm) {
+        if (backend.type === 'genesis') {
+            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.llmBackend) {
-            llm = backend.llmBackend;
+        else if (backend.type === 'adk') {
+            llm = backend.llmBackend || undefined;
         }
     }
-    else if (backend.type === 'adk') {
-        llm = backend.llmBackend || undefined;
+    // If we still have no LLM info, try MicroScheduler /health directly
+    if (!llm) {
+        try {
+            const llmData = await client.getLLMStatus();
+            if (llmData?.model || llmData?.default_model) {
+                llm = llmData.model || llmData.default_model;
+            }
+        }
+        catch { }
     }
     const host = (() => {
         try {
@@ -173,11 +458,12 @@ async function showBanner(client, config) {
             return config.genesisUrl;
         }
     })();
+    const upCount = serviceLines.filter(s => s.up).length;
     const authUser = config.authUser?.display_name || config.authUser?.username;
     renderBanner({
         genesis: host,
         genesisOnline,
-        services: backend.services,
+        services: backend.services ?? (upCount > 0 ? upCount : undefined),
         agents: backend.agents,
         llm,
         user: authUser,
@@ -185,6 +471,10 @@ async function showBanner(client, config) {
         backendType: backend.type,
         backendName: backend.name,
     });
+    // Warm the orchestrator so the first real turn isn't cold (the "first blip").
+    if (genesisOnline) {
+        await warmOnConnect(client, config, warmModel);
+    }
 }
 /* ── Non-interactive mode (flag-based) ────────────────────── */
 async function runOneShot(client, config) {
@@ -281,28 +571,89 @@ async function runOneShot(client, config) {
     return true;
 }
 /* ── One-shot chat (positional args) ─────────────────────── */
-async function oneShotChat(client, config, message) {
-    const renderer = createStreamRenderer();
-    let failed = false;
+async function oneShotChat(client, config, message, resumeSummary = '') {
+    const fmt = config.outputFormat || 'text';
+    const sessionContext = resumeSummary
+        ? { summary: resumeSummary, tools_used: [], model: config.model || '', errors: [] }
+        : undefined;
+    const opts = {
+        agent: config.defaultAgent, sessionId: config.sessionId, model: config.model,
+        effort: config.effort, safetyLevel: config.safetyLevel, privateMode: config.privateMode,
+        attachments: config.imageAttachments, sessionContext,
+    };
+    // Collect answer/model/tools/tokens for recording + JSON output.
+    let answer = '';
+    let model = config.model || '';
+    let agent = config.defaultAgent;
+    const tools = [];
+    let tokens = 0;
+    const errors = [];
+    const renderer = (fmt === 'text') ? createStreamRenderer() : null;
     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();
+        for await (const event of client.streamChat(message, opts)) {
+            if (renderer)
+                renderer.onEvent(event);
+            if (fmt === 'stream-json')
+                process.stdout.write(JSON.stringify(event) + '\n');
+            const d = event.data || {};
+            switch (event.type) {
+                case 'session_start':
+                    if (d.agent)
+                        agent = d.agent;
+                    break;
+                case 'token':
+                    answer += (d.t || d.token || '');
+                    break;
+                case 'message':
+                    if (!answer)
+                        answer = String(d.content || d.message || '');
+                    break;
+                // Terminal answer events are AUTHORITATIVE — overwrite the token
+                // accumulation (eager streaming emits TWO segments worth of tokens, so
+                // the concatenation would otherwise double the answer).
+                case 'answer':
+                case 'final_answer': {
+                    const t = d.answer || d.content || d.message;
+                    if (t)
+                        answer = String(t);
+                    break;
+                }
+                case 'tool_call':
+                    for (const t of (d.tools || d.tool_calls || []))
+                        tools.push(t.name || t.function?.name || 'tool');
+                    break;
+                case 'llm_done':
+                case 'llm_end':
+                    if (d.model_used || d.model)
+                        model = d.model_used || d.model;
+                    tokens += Number(d.tokens_used || d.tokens || 0);
+                    break;
+                case 'complete':
+                case 'done':
+                    if (d.model)
+                        model = d.model;
+                    if (d.content)
+                        answer = String(d.content);
+                    break;
+                case 'error':
+                case 'llm_error':
+                    errors.push(String(d.message || d.error || 'error'));
+                    break;
+            }
+        }
+        if (renderer)
+            renderer.finish();
+        if (renderer && answer === '')
+            answer = renderer.getContent();
     }
     catch (err) {
         if (err.name === 'AbortError')
-            return;
-        failed = true;
+            return false;
         const msg = err.message || 'unknown error';
+        if (fmt === 'json') {
+            process.stdout.write(JSON.stringify({ ok: false, error: msg, session_id: config.sessionId }) + '\n');
+            return false;
+        }
         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'));
@@ -315,8 +666,21 @@ async function oneShotChat(client, config, message) {
         else {
             console.error(chalk.red(`Error: ${msg}`));
         }
-        process.exit(1);
+        return false;
+    }
+    // Persist the turn (local transcript + remote sync) so --continue/--resume work.
+    try {
+        recordTurn(config.sessionId, agent, message, answer, { model, tools, tokens });
+    }
+    catch { /* */ }
+    if (fmt === 'json') {
+        process.stdout.write(JSON.stringify({
+            ok: errors.length === 0, answer, model, agent,
+            session_id: config.sessionId, tools, tokens,
+            errors: errors.length ? errors : undefined,
+        }) + '\n');
     }
+    return errors.length === 0;
 }
 /* ── Help ───────────────────────────────────────────────────── */
 function printUsage() {
@@ -341,6 +705,40 @@ ${chalk.bold('One-shot flags:')}
       --private                   Private mode (prompt hidden from logs/training)
   -i, --image <path>              Attach image for vision analysis (repeatable)
 
+${chalk.bold('Portable gateway mode (run anywhere with internet + an aither_sk_live_* key):')}
+      --gateway [url]             Point inference + MCP tools at the public gateway
+                                  (default https://mcp.aitherium.com); forces raw inference
+      --inference-mode <mode>     auto (default) | genesis (orchestrated pipeline) |
+                                  raw (bypass Genesis → model direct via gateway/MicroScheduler)
+                                  Env: AITHER_GATEWAY_URL, AITHER_INFERENCE_MODE, AITHER_MCP_URL,
+                                  AITHER_LLM_URL. Auth via your aither_sk_live_* key (aither login).
+
+${chalk.bold('Headless / scripting:')}
+  -p, --print [prompt]            Headless: read prompt from arg and/or piped stdin, print, exit
+      --output-format <fmt>       text (default) | json | stream-json
+      --json                      Shorthand for -p --output-format json
+  Exit code 0 on success, 1 on error.  Examples:
+    aither -p "summarize" < notes.md
+    cat error.log | aither -p "what failed?" --output-format json
+    git diff | aither -p "review this diff" --json
+
+${chalk.bold('Sessions (persistent transcripts in ~/.aither/sessions):')}
+      --continue, -C              Resume the most recent conversation
+      --resume <id>               Resume a specific session id (replays context)
+      --session <id>              Alias for --resume
+  In-shell: /chats [resume|delete <id>] · /export [path] [--json] · /copy · /tokens · /rewind [N] · /compact
+
+${chalk.bold('Auth:')}
+      --login                     Device-flow sign-in (portal.aitherium.com/link)
+      --key <token>               Authenticate with an API key
+  In-shell: /login · /whoami · /logout   (remote endpoints require sign-in)
+
+${chalk.bold('TUI:')}
+  Interactive mode defaults to the blessed 3-pane TUI: seamless answer pane (left) +
+  collapsible per-turn trace threads (right; Ctrl+E expand/collapse, click a header to toggle).
+  AITHER_TUI=0 falls back to the native readline shell (line editing, history, paste).
+  AITHER_STEER=1 enables the fixed bottom steering bar (limits terminal scrollback).
+
 ${chalk.bold('Quick actions:')}
   aither -c gaming                Toggle gaming mode (free VRAM for games)
   aither -c "gaming on"           Activate gaming mode

package/dist/mcp-client.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Minimal MCP StreamableHTTP client.
+ *
+ * Talks JSON-RPC to a remote MCP gateway (e.g. https://mcp.aitherium.com/mcp)
+ * using the MCP "Streamable HTTP" transport: each request is a POST whose
+ * response is either a single `application/json` body or a `text/event-stream`
+ * carrying the JSON-RPC reply. No external deps — mirrors client.ts's thin SSE
+ * style so the bundle still compiles via `bun build --compile`.
+ *
+ * Why this exists: the shell's chat backend (genesisUrl) speaks a REST
+ * `/tools/call`, but the cloud gateway (config.mcpUrl) speaks the MCP protocol
+ * at `/mcp`. When mcpUrl is set we route tool discovery + invocation here so
+ * AitherNode's tools work in-REPL against the cloud workspace.
+ */
+import type { ShellConfig } from './config.js';
+export interface McpToolDef {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, any>;
+}
+export interface McpCallResult {
+    content?: Array<{
+        type: string;
+        text?: string;
+        [k: string]: any;
+    }>;
+    isError?: boolean;
+    [k: string]: any;
+}
+export declare class McpHttpClient {
+    readonly url: string;
+    private token;
+    private sessionId;
+    private nextId;
+    private initialized;
+    private initInFlight;
+    constructor(url: string, token?: string | null);
+    /** Send a JSON-RPC request (or notification) and return its `result`. */
+    private rpc;
+    /** Read an SSE response body and return the JSON-RPC message matching `id`. */
+    private readSseForId;
+    /** Initialize the MCP session (idempotent, single-flight). */
+    connect(): Promise<void>;
+    /** List the tools the authenticated caller is entitled to. */
+    listTools(): Promise<McpToolDef[]>;
+    /** Invoke a tool by name. Returns the MCP `{content, isError}` result. */
+    callTool(name: string, args?: Record<string, any>): Promise<McpCallResult>;
+    /** Cheap reachability + auth check. */
+    ping(): Promise<boolean>;
+}
+/**
+ * Return a remote MCP client for the active config, or null when no MCP
+ * gateway URL is configured (local/Genesis mode uses the chat backend's
+ * REST /tools/call instead).
+ */
+export declare function getRemoteMcpClient(config: ShellConfig | null | undefined): McpHttpClient | null;
+/** Drop the cached client (e.g. after logout/endpoint change). */
+export declare function resetRemoteMcpClient(): void;