@aitherium/shell-cli 1.1.0 → 1.11.0

package/dist/auth.d.ts

@@ -35,11 +35,20 @@ export declare function getActiveUser(): AuthUser | null;
 export declare function setProfile(name: string, profile: AuthProfile): void;
 export declare function clearProfile(name: string): void;
 /**
- * Ensure a root profile exists for local sessions.
- * If no auth.json exists or token is expired, provision root.
- * Like Linux auto-login as root on the console.
+ * Local-root auto-provisioning is allowed UNLESS AITHER_REQUIRE_AUTH is set.
+ * Parity with the Python ADK (aither-adk/adk/shell/auth.py:_is_root_provisioning_allowed).
+ * Remote endpoints (e.g. the dev-workspace) set AITHER_REQUIRE_AUTH=1 to force a
+ * real device-flow login as the user instead of silently becoming root.
  */
-export declare function ensureRootProfile(): AuthProfile;
+export declare function isRootProvisioningAllowed(): boolean;
+/**
+ * Ensure a profile exists for local sessions.
+ * If a valid token already exists, return its profile.
+ * Otherwise auto-provision the built-in root profile (like Linux console
+ * auto-login) — UNLESS AITHER_REQUIRE_AUTH is set, in which case return null
+ * so the caller forces device-flow login.
+ */
+export declare function ensureRootProfile(): AuthProfile | null;
 export declare function loginWithPassword(endpoint: string, username: string, password: string): Promise<any>;
 export declare function verify2FA(endpoint: string, tempToken: string, code: string): Promise<any>;
 export declare function register(endpoint: string, username: string, password: string, email: string, inviteCode?: string): Promise<any>;

package/dist/auth.js

@@ -99,15 +99,30 @@ const ROOT_PROFILE = {
     },
 };
 /**
- * Ensure a root profile exists for local sessions.
- * If no auth.json exists or token is expired, provision root.
- * Like Linux auto-login as root on the console.
+ * Local-root auto-provisioning is allowed UNLESS AITHER_REQUIRE_AUTH is set.
+ * Parity with the Python ADK (aither-adk/adk/shell/auth.py:_is_root_provisioning_allowed).
+ * Remote endpoints (e.g. the dev-workspace) set AITHER_REQUIRE_AUTH=1 to force a
+ * real device-flow login as the user instead of silently becoming root.
+ */
+export function isRootProvisioningAllowed() {
+    const v = (process.env.AITHER_REQUIRE_AUTH || '').toLowerCase();
+    return !['1', 'true', 'yes', 'on'].includes(v);
+}
+/**
+ * Ensure a profile exists for local sessions.
+ * If a valid token already exists, return its profile.
+ * Otherwise auto-provision the built-in root profile (like Linux console
+ * auto-login) — UNLESS AITHER_REQUIRE_AUTH is set, in which case return null
+ * so the caller forces device-flow login.
  */
 export function ensureRootProfile() {
     const token = getActiveToken();
     if (token) {
         return getActiveProfile();
     }
+    if (!isRootProvisioningAllowed()) {
+        return null; // require-auth — no silent root; caller triggers `aither login`
+    }
     // No valid session — provision root
     setProfile('local', ROOT_PROFILE);
     return ROOT_PROFILE;

package/dist/client.d.ts

@@ -62,12 +62,15 @@ export interface BackendInfo {
     agents?: number;
 }
 export declare class GenesisClient {
-    readonly baseUrl: string;
+    baseUrl: string;
     private _authToken;
     private _tenantId;
     private _userId;
     private _backend;
     constructor(baseUrl: string);
+    /** Repoint the client (e.g. when --gateway changes the endpoint after
+     *  construction). Clears the cached backend so the next call re-detects. */
+    setBaseUrl(url: string): void;
     /** Probe the backend and detect its type (Genesis vs ADK vs unknown). */
     detectBackend(): Promise<BackendInfo>;
     /** Get cached backend info (call detectBackend first). */
@@ -94,6 +97,19 @@ export declare class GenesisClient {
     }): Promise<any>;
     getLogs(limit?: number, level?: string, service?: string): Promise<any>;
     getLLMStatus(): Promise<any>;
+    /** Resolve the MicroScheduler base URL the same way getLLMStatus does. */
+    private _msCandidates;
+    /** O(1) cached snapshot of which LLM backends are up and what models they
+     *  serve (no live inference) — used for the banner's "model @ where" line. */
+    getBackendSnapshot(): Promise<any>;
+    /** Warm the orchestrator model with a tiny non-thinking generation so the
+     *  first REAL turn isn't cold (the cold model intermittently streams zero
+     *  tokens → the eager first pass falls through to the slow grounded path).
+     *  Returns the model id + round-trip ms, or null on failure (never throws). */
+    warmupModel(model: string): Promise<{
+        model: string;
+        ms: number;
+    } | null>;
     getGpuStatus(): Promise<{
         zone: string;
         active: boolean;
@@ -113,4 +129,8 @@ export declare class GenesisClient {
      */
     private readSSE;
     private parseBlock;
+    /** Stream chat from an OpenAI-compatible backend, translated to native SSEEvents. */
+    private _streamOpenAI;
+    /** Parse an OpenAI delta SSE stream into native token/complete events. */
+    private _readOpenAISSE;
 }

package/dist/client.js

@@ -11,6 +11,7 @@
  * This client is a thin SSE consumer — no trivial intercept,
  * no fallback chains, no Veil dependency.
  */
+import { getActiveConfig } from './config.js';
 export class GenesisClient {
     baseUrl;
     _authToken = null;
@@ -20,6 +21,12 @@ export class GenesisClient {
     constructor(baseUrl) {
         this.baseUrl = baseUrl.replace(/\/+$/, '');
     }
+    /** Repoint the client (e.g. when --gateway changes the endpoint after
+     *  construction). Clears the cached backend so the next call re-detects. */
+    setBaseUrl(url) {
+        this.baseUrl = url.replace(/\/+$/, '');
+        this._backend = null;
+    }
     /** Probe the backend and detect its type (Genesis vs ADK vs unknown). */
     async detectBackend() {
         if (this._backend)
@@ -35,9 +42,13 @@ export class GenesisClient {
                 return info;
             }
             const data = await r.json();
-            // Genesis health returns generation_ready, vllm_slots_available, tracked_services
-            // ADK health returns agent, llm_backend, version
-            if (data.generation_ready !== undefined || data.tracked_services !== undefined) {
+            // Genesis health may return generation_ready/tracked_services (rich mode)
+            // OR just { status, service: "AitherGenesis", uptime_sec } (minimal mode).
+            // ADK health returns agent, llm_backend, version.
+            const isGenesis = data.generation_ready !== undefined
+                || data.tracked_services !== undefined
+                || data.service === 'AitherGenesis';
+            if (isGenesis) {
                 info.type = 'genesis';
                 info.name = 'Genesis';
                 info.generationReady = data.generation_ready;
@@ -65,6 +76,15 @@ export class GenesisClient {
                 }
                 catch { }
             }
+            else if (typeof data.service === 'string' && /gateway/i.test(data.service)) {
+                // AitherOS edge gateway (gateway.aitherium.com) — OpenAI-compatible
+                // inference at /v1/chat/completions. Reuse the 'adk' code path (which
+                // posts there) and default the model to the orchestrator.
+                info.type = 'adk';
+                info.name = 'AitherGateway';
+                info.agent = 'aither-orchestrator';
+                info.llmBackend = 'aither-orchestrator';
+            }
             else if (data.agent !== undefined || data.llm_backend !== undefined) {
                 info.type = 'adk';
                 info.name = data.agent || 'agent';
@@ -121,6 +141,25 @@ export class GenesisClient {
     }
     /* ── Streaming chat — POST /chat/stream (SSE) ───────────── */
     async *streamChat(message, opts = {}) {
+        // Genesis serves native SSE at /chat/stream; AitherNode/ADK/gateway serve the
+        // OpenAI-compatible /v1/chat/completions. Branch so `aither` works against
+        // both. detectBackend() is cached (showBanner already warmed it).
+        //
+        // Inference-mode toggle: 'raw' forces the OpenAI path (bypass Genesis → hit
+        // the model directly via the gateway/MicroScheduler) even if Genesis is
+        // reachable; 'genesis' forces the orchestrated pipeline; 'auto' picks by
+        // detected backend. The raw path is what makes the shell portable — it runs
+        // anywhere with internet + an aither_sk_live_* key to the gateway.
+        const mode = getActiveConfig()?.inferenceMode || 'auto';
+        if (mode === 'raw') {
+            yield* this._streamOpenAI(message, opts);
+            return;
+        }
+        const backend = await this.detectBackend();
+        if (mode === 'auto' && backend.type === 'adk') {
+            yield* this._streamOpenAI(message, opts);
+            return;
+        }
         const body = {
             message,
             persona: opts.agent || 'aither',
@@ -241,6 +280,10 @@ export class GenesisClient {
         return this.get('/agents');
     }
     async forgeDispatch(task, opts = {}) {
+        // Forge is a Genesis-only subsystem (ADK/Node have no /forge endpoints).
+        if (this._backend?.type === 'adk') {
+            return { error: 'Forge requires the Genesis backend — this endpoint is ADK/Node (chat only).' };
+        }
         const res = await fetch(`${this.baseUrl}/forge/dispatch/sync`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json', ...this.authHeaders() },
@@ -279,6 +322,55 @@ export class GenesisClient {
             return null;
         }
     }
+    /** Resolve the MicroScheduler base URL the same way getLLMStatus does. */
+    _msCandidates() {
+        return [process.env.AITHER_LLM_URL, 'https://localhost:8150', 'http://localhost:8150']
+            .filter(Boolean);
+    }
+    /** O(1) cached snapshot of which LLM backends are up and what models they
+     *  serve (no live inference) — used for the banner's "model @ where" line. */
+    async getBackendSnapshot() {
+        for (const base of this._msCandidates()) {
+            try {
+                const r = await fetch(`${base}/llm/backends/snapshot`, { signal: AbortSignal.timeout(3000) });
+                if (r.ok)
+                    return r.json();
+            }
+            catch { }
+        }
+        return null;
+    }
+    /** Warm the orchestrator model with a tiny non-thinking generation so the
+     *  first REAL turn isn't cold (the cold model intermittently streams zero
+     *  tokens → the eager first pass falls through to the slow grounded path).
+     *  Returns the model id + round-trip ms, or null on failure (never throws). */
+    async warmupModel(model) {
+        const payload = {
+            model,
+            messages: [{ role: 'user', content: 'ok' }],
+            max_tokens: 1,
+            temperature: 0,
+            stream: false,
+            metadata: { enable_thinking: false, effort: 1, source: 'shell_warmup', priority: 'background' },
+        };
+        for (const base of this._msCandidates()) {
+            const t0 = Date.now();
+            try {
+                const r = await fetch(`${base}/v1/chat/completions`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(payload),
+                    signal: AbortSignal.timeout(30000),
+                });
+                if (r.ok) {
+                    await r.text().catch(() => ''); // drain
+                    return { model, ms: Date.now() - t0 };
+                }
+            }
+            catch { }
+        }
+        return null;
+    }
     async getGpuStatus() {
         try {
             const candidates = [process.env.AITHER_LLM_URL, 'https://localhost:8150', 'http://localhost:8150'].filter(Boolean);
@@ -327,7 +419,11 @@ export class GenesisClient {
     async getDetailed(path) {
         try {
             const r = await fetch(`${this.baseUrl}${path}`, {
-                headers: { ...this.authHeaders() },
+                // X-Caller-Type: PLATFORM — consistent with post/put/patch/delete below.
+                // Without it, GETs resolved as anonymous, so /agents was filtered to []
+                // by AgentCatalog (public/anonymous → no agents) and the banner showed
+                // "0 agents" even though 53 identities are deployable.
+                headers: { 'X-Caller-Type': 'PLATFORM', ...this.authHeaders() },
                 signal: AbortSignal.timeout(5000),
             });
             if (!r.ok)
@@ -450,7 +546,15 @@ export class GenesisClient {
                 // Race reader.read() against a timeout so the client never hangs
                 // if the backend stalls (e.g. reasoning model cold-start, 404 retry loop).
                 const readPromise = reader.read();
-                const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('SSE chunk timeout')), CHUNK_TIMEOUT_MS));
+                // IMPORTANT: keep a handle to the timeout timer and clear it once the
+                // chunk arrives. Otherwise every chunk (hundreds per streamed turn) leaks
+                // a live 120s timer; the swarm of late, post-settle rejections keeps the
+                // event loop hot and is a class of stray-rejection the crash reporter
+                // used to turn into process.exit(1).
+                let chunkTimer = null;
+                const timeoutPromise = new Promise((_, reject) => {
+                    chunkTimer = setTimeout(() => reject(new Error('SSE chunk timeout')), CHUNK_TIMEOUT_MS);
+                });
                 // Intermediate warning if no data for 60s
                 let warnTimer = null;
                 if (!warningSent) {
@@ -461,16 +565,40 @@ export class GenesisClient {
                 let result;
                 try {
                     result = await Promise.race([readPromise, timeoutPromise]);
+                    if (chunkTimer)
+                        clearTimeout(chunkTimer);
                     if (warnTimer)
                         clearTimeout(warnTimer);
                 }
-                catch {
+                catch (err) {
+                    if (chunkTimer)
+                        clearTimeout(chunkTimer);
                     if (warnTimer)
                         clearTimeout(warnTimer);
-                    // Timeout — emit a typed timeout event (not a hard error) so the
-                    // renderer and REPL can check if the agent is still processing.
+                    // A user abort (Ctrl+C) must surface as AbortError to the caller —
+                    // swallowing it here made Ctrl+C look like a silent timeout.
+                    if (err?.name === 'AbortError')
+                        throw err;
                     const silentMs = Date.now() - lastChunkAt;
-                    yield { type: 'stream_timeout', data: { type: 'stream_timeout', timeout_ms: CHUNK_TIMEOUT_MS, silent_ms: silentMs } };
+                    if (err?.message === 'SSE chunk timeout') {
+                        // Timeout — emit a typed timeout event (not a hard error) so the
+                        // renderer and REPL can check if the agent is still processing.
+                        yield { type: 'stream_timeout', data: { type: 'stream_timeout', timeout_ms: CHUNK_TIMEOUT_MS, silent_ms: silentMs } };
+                    }
+                    else {
+                        // Mid-stream transport failure (connection reset — e.g. Genesis or
+                        // the LB restarted under the turn). This used to be mislabeled as
+                        // stream_timeout and rendered as NOTHING: the turn looked done and
+                        // the grounded answer was silently thrown away. Surface it.
+                        yield {
+                            type: 'stream_interrupted',
+                            data: {
+                                type: 'stream_interrupted',
+                                error: String(err?.cause?.message || err?.message || err || 'connection lost'),
+                                silent_ms: silentMs,
+                            },
+                        };
+                    }
                     break;
                 }
                 lastChunkAt = Date.now();
@@ -525,4 +653,80 @@ export class GenesisClient {
             data: eventData,
         };
     }
+    /* ── ADK / AitherNode chat — OpenAI /v1/chat/completions → native events ── */
+    /** Stream chat from an OpenAI-compatible backend, translated to native SSEEvents. */
+    async *_streamOpenAI(message, opts) {
+        const messages = [];
+        if (opts.sessionContext?.summary) {
+            messages.push({ role: 'system', content: `Conversation so far:\n${opts.sessionContext.summary}` });
+        }
+        messages.push({ role: 'user', content: message });
+        const model = opts.model || this._backend?.agent || this._backend?.name || 'aither-orchestrator';
+        const body = { model, messages, stream: true };
+        // Prefer the configured raw-inference endpoint (gateway /v1 or MicroScheduler)
+        // so 'raw' mode reaches the model even when baseUrl points at Genesis.
+        const llmUrl = (getActiveConfig()?.llmUrl || '').replace(/\/+$/, '');
+        const completionsUrl = llmUrl
+            ? `${llmUrl}/chat/completions`
+            : `${this.baseUrl}/v1/chat/completions`;
+        let response;
+        try {
+            response = await fetch(completionsUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'X-Caller-Type': 'PLATFORM', ...this.authHeaders() },
+                body: JSON.stringify(body),
+                signal: opts.signal,
+            });
+        }
+        catch (err) {
+            throw new Error(`Cannot connect to inference endpoint (${completionsUrl}): ${err.message}`);
+        }
+        if (!response.ok) {
+            const text = await response.text().catch(() => '');
+            throw new Error(`Inference failed: HTTP ${response.status} ${text.slice(0, 200)}`);
+        }
+        yield { type: 'session_start', data: { type: 'session_start', agent: this._backend?.agent || opts.agent || 'agent', model } };
+        yield* this._readOpenAISSE(response, model);
+    }
+    /** Parse an OpenAI delta SSE stream into native token/complete events. */
+    async *_readOpenAISSE(response, model) {
+        const stream = response.body;
+        if (!stream)
+            throw new Error('No response body');
+        const reader = stream.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        const started = Date.now();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                buffer = buffer.replace(/\r\n/g, '\n');
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    const l = line.trim();
+                    if (!l.startsWith('data:'))
+                        continue;
+                    const payload = l.slice(5).trim();
+                    if (payload === '[DONE]')
+                        continue;
+                    try {
+                        const json = JSON.parse(payload);
+                        const choice = json.choices?.[0];
+                        const delta = choice?.delta?.content ?? choice?.message?.content;
+                        if (delta)
+                            yield { type: 'token', data: { type: 'token', t: delta } };
+                    }
+                    catch { /* skip keep-alives / non-JSON */ }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        yield { type: 'complete', data: { type: 'complete', model, duration_ms: Date.now() - started, eager: false } };
+    }
 }

package/dist/command-registry.d.ts

@@ -46,7 +46,7 @@ export declare class CommandRegistry {
      * Merges discovered commands into the registry without overwriting
      * existing handlers. Call once at REPL startup.
      */
-    loadDynamicCommands(client: GenesisClient): Promise<number>;
+    loadDynamicCommands(client: GenesisClient, config?: ShellConfig): Promise<number>;
     /** Get all discovered MCP tools. */
     getMcpTools(): DynamicCommandEntry[];
     /** Check if an MCP tool exists by name. */

package/dist/command-registry.js

@@ -14,6 +14,7 @@
 import { readFileSync } from 'node:fs';
 import { resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { getRemoteMcpClient } from './mcp-client.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // ── Tokenizer ────────────────────────────────────────────────────────
 const STOP_WORDS = new Set([
@@ -64,7 +65,7 @@ export class CommandRegistry {
      * Merges discovered commands into the registry without overwriting
      * existing handlers. Call once at REPL startup.
      */
-    async loadDynamicCommands(client) {
+    async loadDynamicCommands(client, config) {
         let added = 0;
         try {
             const result = await client.get('/shell/commands');
@@ -109,7 +110,8 @@ export class CommandRegistry {
         catch {
             // Genesis unreachable — use static commands only
         }
-        // Also fetch MCP tools (async, non-blocking)
+        // Also fetch MCP tools from the chat backend (Genesis exposes these via
+        // /shell/commands/mcp). Non-fatal — the gateway has no such endpoint.
         try {
             const mcpResult = await client.get('/shell/commands/mcp');
             const mcpCommands = mcpResult?.commands || [];
@@ -122,6 +124,30 @@ export class CommandRegistry {
         catch {
             // MCP discovery failed — non-fatal
         }
+        // Remote MCP gateway (config.mcpUrl, e.g. mcp.aitherium.com/mcp): list the
+        // tenant-scoped tool catalog over the MCP protocol. This is how AitherNode
+        // tools become available in-REPL when pointed at a cloud workspace.
+        const remote = getRemoteMcpClient(config);
+        if (remote) {
+            try {
+                const tools = await remote.listTools();
+                for (const tool of tools) {
+                    if (!tool.name)
+                        continue;
+                    this.mcpTools.set(tool.name, {
+                        name: tool.name,
+                        category: 'mcp',
+                        description: tool.description || '',
+                        aliases: [],
+                        source: 'remote-mcp',
+                        params: tool.inputSchema ? [tool.inputSchema] : [],
+                    });
+                }
+            }
+            catch {
+                // Remote MCP unreachable / unauthenticated — non-fatal.
+            }
+        }
         return added;
     }
     /** Get all discovered MCP tools. */

package/dist/commands.d.ts

@@ -9,6 +9,14 @@ interface Command {
     usage?: string;
     handler: CommandHandler;
 }
+/**
+ * Invoke an MCP tool, routing to the right transport:
+ *   - remote MCP gateway (config.mcpUrl, MCP protocol) when configured —
+ *     so AitherNode tools work against a cloud workspace; else
+ *   - the chat backend's REST /tools/call (local Genesis).
+ * Returns the parsed tool output, or `{ error, status }` on failure.
+ */
+export declare function invokeMcpTool(client: GenesisClient, tool: string, params: Record<string, any>): Promise<any>;
 export declare function getCommand(name: string): Command | undefined;
 export declare function getCommandNames(): string[];
 export {};