@aitherium/shell-cli 1.1.0

package/dist/session-store.d.ts

@@ -0,0 +1,35 @@
+/**
+ * SessionStore — Save/resume CLI conversations.
+ *
+ * Sessions stored in ~/.aither/sessions/ as JSON.
+ */
+export interface SessionEntry {
+    sessionId: string;
+    agent: string;
+    messages: Array<{
+        role: string;
+        content: string;
+        timestamp?: string;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare function saveSession(session: SessionEntry): void;
+export declare function loadSession(id: string): SessionEntry | null;
+export declare function listSessions(limit?: number): Array<{
+    sessionId: string;
+    agent: string;
+    messageCount: number;
+    updatedAt: string;
+}>;
+export declare function deleteSession(id: string): boolean;
+export declare function configureRemoteSync(genesisUrl: string, authToken: string | null): void;
+export declare function syncSessionToRemote(session: SessionEntry): Promise<void>;
+export declare function loadRemoteSession(sessionId: string): Promise<SessionEntry | null>;
+export declare function listRemoteSessions(limit?: number): Promise<Array<{
+    sessionId: string;
+    agent: string;
+    messageCount: number;
+    updatedAt: string;
+    clientType: string;
+}>>;

package/dist/session-store.js

@@ -0,0 +1,153 @@
+/**
+ * SessionStore — Save/resume CLI conversations.
+ *
+ * Sessions stored in ~/.aither/sessions/ as JSON.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, unlinkSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const SESSION_DIR = join(homedir(), '.aither', 'sessions');
+function ensureDir() {
+    if (!existsSync(SESSION_DIR)) {
+        mkdirSync(SESSION_DIR, { recursive: true });
+    }
+}
+function sessionPath(id) {
+    return join(SESSION_DIR, `${id.replace(/[^a-zA-Z0-9_-]/g, '_')}.json`);
+}
+export function saveSession(session) {
+    ensureDir();
+    session.updatedAt = new Date().toISOString();
+    writeFileSync(sessionPath(session.sessionId), JSON.stringify(session, null, 2));
+}
+export function loadSession(id) {
+    const path = sessionPath(id);
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function listSessions(limit = 20) {
+    ensureDir();
+    const files = readdirSync(SESSION_DIR)
+        .filter(f => f.endsWith('.json'))
+        .map(f => ({ name: f, mtime: statSync(join(SESSION_DIR, f)).mtimeMs }))
+        .sort((a, b) => b.mtime - a.mtime)
+        .slice(0, limit);
+    return files.map(f => {
+        try {
+            const data = JSON.parse(readFileSync(join(SESSION_DIR, f.name), 'utf-8'));
+            return {
+                sessionId: data.sessionId,
+                agent: data.agent || 'aither',
+                messageCount: data.messages?.length || 0,
+                updatedAt: data.updatedAt || new Date(f.mtime).toISOString(),
+            };
+        }
+        catch {
+            return {
+                sessionId: f.name.replace('.json', ''),
+                agent: 'unknown',
+                messageCount: 0,
+                updatedAt: new Date(f.mtime).toISOString(),
+            };
+        }
+    });
+}
+export function deleteSession(id) {
+    const path = sessionPath(id);
+    if (existsSync(path)) {
+        unlinkSync(path);
+        return true;
+    }
+    return false;
+}
+// ── Remote Sync — push/pull sessions via Genesis /session/sync/* ─────
+let _genesisUrl = null;
+let _authToken = null;
+export function configureRemoteSync(genesisUrl, authToken) {
+    _genesisUrl = genesisUrl;
+    _authToken = authToken;
+}
+export async function syncSessionToRemote(session) {
+    if (!_genesisUrl)
+        return;
+    try {
+        const headers = { 'Content-Type': 'application/json' };
+        if (_authToken)
+            headers['Authorization'] = `Bearer ${_authToken}`;
+        await fetch(`${_genesisUrl}/session/sync/save`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                session_id: session.sessionId,
+                agent: session.agent,
+                messages: session.messages,
+                client_type: 'cli',
+            }),
+            signal: AbortSignal.timeout(5000),
+        }).catch(() => { }); // fire-and-forget, don't block shell
+    }
+    catch { /* silent */ }
+}
+export async function loadRemoteSession(sessionId) {
+    if (!_genesisUrl)
+        return null;
+    try {
+        const headers = { 'Content-Type': 'application/json' };
+        if (_authToken)
+            headers['Authorization'] = `Bearer ${_authToken}`;
+        const res = await fetch(`${_genesisUrl}/session/sync/load`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({ session_id: sessionId }),
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        const s = data.session;
+        if (!s)
+            return null;
+        return {
+            sessionId: s.session_id,
+            agent: s.agent || 'aither',
+            messages: s.messages || [],
+            createdAt: s.created_at || '',
+            updatedAt: s.updated_at || '',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function listRemoteSessions(limit = 20) {
+    if (!_genesisUrl)
+        return [];
+    try {
+        const headers = {};
+        if (_authToken)
+            headers['Authorization'] = `Bearer ${_authToken}`;
+        const res = await fetch(`${_genesisUrl}/session/sync/list?limit=${limit}`, {
+            headers,
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!res.ok)
+            return [];
+        const data = await res.json();
+        return (data.sessions || []).map((s) => ({
+            sessionId: s.session_id,
+            agent: s.agent || 'aither',
+            messageCount: s.message_count || 0,
+            updatedAt: s.updated_at || '',
+            clientType: s.client_type || 'unknown',
+        }));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/tunnel.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Cloudflare Tunnel + DNS CLI commands.
+ *
+ * Usage:
+ *   aither tunnel list                         List all ingress routes
+ *   aither tunnel add <subdomain> [service]    Add route (default: veil-lb:3000)
+ *   aither tunnel remove <subdomain>           Remove route
+ *   aither tunnel status                       Show tunnel health
+ *   aither dns add <subdomain>                 Create CNAME
+ *   aither dns remove <subdomain>              Delete CNAME
+ */
+export declare function handleTunnelCommand(args: string[]): Promise<void>;
+export declare function handleDnsCommand(args: string[]): Promise<void>;

package/dist/tunnel.js

@@ -0,0 +1,169 @@
+/**
+ * Cloudflare Tunnel + DNS CLI commands.
+ *
+ * Usage:
+ *   aither tunnel list                         List all ingress routes
+ *   aither tunnel add <subdomain> [service]    Add route (default: veil-lb:3000)
+ *   aither tunnel remove <subdomain>           Remove route
+ *   aither tunnel status                       Show tunnel health
+ *   aither dns add <subdomain>                 Create CNAME
+ *   aither dns remove <subdomain>              Delete CNAME
+ */
+function getGenesisUrl() {
+    return process.env.GENESIS_URL || 'http://localhost:8001';
+}
+async function genesisGet(path) {
+    const res = await fetch(`${getGenesisUrl()}${path}`, { headers: { Accept: 'application/json' } });
+    if (!res.ok)
+        throw new Error(`${res.status} ${res.statusText}`);
+    return res.json();
+}
+async function genesisPost(path, body = {}) {
+    const res = await fetch(`${getGenesisUrl()}${path}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok)
+        throw new Error(`${res.status} ${res.statusText}`);
+    return res.json();
+}
+async function genesisDelete(path) {
+    const res = await fetch(`${getGenesisUrl()}${path}`, { method: 'DELETE', headers: { Accept: 'application/json' } });
+    if (!res.ok)
+        throw new Error(`${res.status} ${res.statusText}`);
+    return res.json();
+}
+// ── Tunnel commands ──────────────────────────────────────────────────────
+async function tunnelList() {
+    try {
+        const data = await genesisGet('/cloudflare/tunnel/routes');
+        console.log(`\x1b[36mTunnel Ingress Routes\x1b[0m (${data.count || data.routes?.length || 0})\n`);
+        for (const r of data.routes || []) {
+            const host = r.hostname || '* (catch-all)';
+            console.log(`  ${host.padEnd(35)} → ${r.service}`);
+        }
+    }
+    catch (e) {
+        console.error(`\x1b[31mError:\x1b[0m ${e.message}`);
+    }
+}
+async function tunnelAdd(args) {
+    const subdomain = args[0];
+    if (!subdomain) {
+        console.log('\x1b[33mUsage:\x1b[0m aither tunnel add <subdomain> [service]');
+        return;
+    }
+    const hostname = subdomain.includes('.') ? subdomain : `${subdomain}.aitherium.com`;
+    const service = args[1] || 'http://aitheros-veil-lb:3000';
+    console.log(`\x1b[2mAdding route: ${hostname} → ${service}...\x1b[0m`);
+    try {
+        const data = await genesisPost('/cloudflare/tunnel/add', { hostname, service });
+        if (data.action === 'exists') {
+            console.log(`\x1b[33m!\x1b[0m Route already exists: ${hostname} → ${data.service}`);
+        }
+        else {
+            console.log(`\x1b[32m✓\x1b[0m Route added: ${hostname} → ${service} (${data.total_rules} total)`);
+        }
+    }
+    catch (e) {
+        console.error(`\x1b[31mError:\x1b[0m ${e.message}`);
+    }
+}
+async function tunnelRemove(args) {
+    const subdomain = args[0];
+    if (!subdomain) {
+        console.log('\x1b[33mUsage:\x1b[0m aither tunnel remove <subdomain>');
+        return;
+    }
+    const hostname = subdomain.includes('.') ? subdomain : `${subdomain}.aitherium.com`;
+    try {
+        const data = await genesisDelete(`/cloudflare/tunnel/${hostname}`);
+        if (data.action === 'not_found') {
+            console.log(`\x1b[33m!\x1b[0m No route found for ${hostname}`);
+        }
+        else {
+            console.log(`\x1b[32m✓\x1b[0m Removed: ${hostname}`);
+        }
+    }
+    catch (e) {
+        console.error(`\x1b[31mError:\x1b[0m ${e.message}`);
+    }
+}
+async function tunnelStatus() {
+    try {
+        const data = await genesisGet('/cloudflare/tunnel/status');
+        console.log(`\x1b[36mTunnel Status\x1b[0m`);
+        console.log(`  Name:    ${data.name}`);
+        console.log(`  Status:  ${data.status}`);
+        console.log(`  ID:      ${data.id}`);
+        if (data.connections?.length) {
+            console.log(`  Connections:`);
+            for (const c of data.connections) {
+                console.log(`    ${c.colo_name || c.id} (${c.is_pending_reconnect ? 'reconnecting' : 'active'})`);
+            }
+        }
+    }
+    catch (e) {
+        console.error(`\x1b[31mError:\x1b[0m ${e.message}`);
+    }
+}
+export async function handleTunnelCommand(args) {
+    const sub = args[0] || 'help';
+    switch (sub) {
+        case 'list':
+        case 'ls': return tunnelList();
+        case 'add': return tunnelAdd(args.slice(1));
+        case 'remove':
+        case 'rm': return tunnelRemove(args.slice(1));
+        case 'status': return tunnelStatus();
+        default:
+            console.log(`\x1b[36mTunnel Management\x1b[0m\n`);
+            console.log('  aither tunnel list                      List ingress routes');
+            console.log('  aither tunnel add <sub> [service]       Add route');
+            console.log('  aither tunnel remove <sub>              Remove route');
+            console.log('  aither tunnel status                    Show health');
+    }
+}
+// ── DNS commands ─────────────────────────────────────────────────────────
+async function dnsAdd(args) {
+    const subdomain = args[0];
+    if (!subdomain) {
+        console.log('\x1b[33mUsage:\x1b[0m aither dns add <subdomain>');
+        return;
+    }
+    console.log(`\x1b[2mCreating CNAME: ${subdomain}.aitherium.com...\x1b[0m`);
+    try {
+        const data = await genesisPost('/cloudflare/dns/add', { subdomain });
+        console.log(`\x1b[32m✓\x1b[0m DNS ${data.action}: ${subdomain}.aitherium.com`);
+    }
+    catch (e) {
+        console.error(`\x1b[31mError:\x1b[0m ${e.message}`);
+    }
+}
+async function dnsRemove(args) {
+    const subdomain = args[0];
+    if (!subdomain) {
+        console.log('\x1b[33mUsage:\x1b[0m aither dns remove <subdomain>');
+        return;
+    }
+    try {
+        const data = await genesisDelete(`/cloudflare/dns/${subdomain}`);
+        console.log(`\x1b[32m✓\x1b[0m DNS ${data.action}: ${subdomain}.aitherium.com`);
+    }
+    catch (e) {
+        console.error(`\x1b[31mError:\x1b[0m ${e.message}`);
+    }
+}
+export async function handleDnsCommand(args) {
+    const sub = args[0] || 'help';
+    switch (sub) {
+        case 'add': return dnsAdd(args.slice(1));
+        case 'remove':
+        case 'rm': return dnsRemove(args.slice(1));
+        default:
+            console.log(`\x1b[36mDNS Management\x1b[0m\n`);
+            console.log('  aither dns add <subdomain>        Create CNAME');
+            console.log('  aither dns remove <subdomain>     Delete CNAME');
+    }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@aitherium/shell-cli",
+  "version": "1.1.0",
+  "description": "Interactive terminal for AitherOS and ADK agents",
+  "type": "module",
+  "bin": {
+    "aither": "./dist/main.js",
+    "aither-shell": "./dist/main.js"
+  },
+  "files": [
+    "dist/",
+    "package.json",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "tsx src/main.ts",
+    "build": "tsc",
+    "build:standalone": "bun build --compile src/main.ts --outfile dist/aither-shell",
+    "start": "node dist/main.js"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.3.2",
+    "chalk": "^5.4.0",
+    "marked": "^15.0.0",
+    "marked-terminal": "^7.3.0",
+    "ora": "^8.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.8.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}