@orbit-intelligence/orbit-agent 0.3.12

package/dist/src/core/tools/shell.js

@@ -0,0 +1,65 @@
+import { spawn } from 'node:child_process';
+import { toolError } from './types.js';
+import { defaultShell } from '../../utils/platform.js';
+/** Run a shell command and capture output. Uses the platform shell. */
+export function createShellTool(opts) {
+    const shell = opts.shell ?? defaultShell();
+    return {
+        name: 'run_shell',
+        description: 'Run a shell command in the working directory. Use for anything outside the filesystem tools: installs, test runs, git, builds, network.',
+        parameters: {
+            type: 'object',
+            properties: {
+                command: { type: 'string', description: 'The shell command to run.' },
+                cwd: { type: 'string', description: 'Working directory (default: current).' },
+                timeoutMs: { type: 'number', description: 'Timeout in ms (default 30_000).', default: 30000 },
+            },
+            required: ['command'],
+        },
+        async run(args, ctx) {
+            const command = String(args.command ?? '');
+            const cwd = String(args.cwd ?? ctx.cwd);
+            const timeoutMs = Math.min(Number(args.timeoutMs ?? 30_000), 120_000);
+            if (!command.trim())
+                return toolError('empty command');
+            return new Promise((resolve) => {
+                const child = spawn(command, { shell, cwd, env: process.env, stdio: ['ignore', 'pipe', 'pipe'] });
+                let stdout = '';
+                let stderr = '';
+                let settled = false;
+                const settle = (result) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    clearTimeout(timer);
+                    ctx.signal?.removeEventListener('abort', onAbort);
+                    resolve(result);
+                };
+                const summarize = (code, signal, timedOut) => {
+                    const out = stdout + (stderr ? `\n${stderr}` : '');
+                    const maxLen = 40_000;
+                    const truncated = out.length > maxLen ? `${out.slice(0, maxLen)}\n… [truncated]` : out;
+                    const status = timedOut
+                        ? `(timed out after ${timeoutMs}ms)`
+                        : signal ? `(killed by ${signal})` : `(exit ${code ?? 0})`;
+                    const content = `${truncated}\n${status}`.trim();
+                    const failed = timedOut || (code !== null && code !== 0);
+                    settle(failed ? { content, isError: true } : { content });
+                };
+                const timer = setTimeout(() => {
+                    child.kill('SIGKILL');
+                    summarize(null, null, true);
+                }, timeoutMs);
+                const onAbort = () => {
+                    child.kill('SIGKILL');
+                    settle({ content: `Error: command cancelled (${ctx.signal?.reason?.message ?? 'interrupted'})`, isError: true });
+                };
+                ctx.signal?.addEventListener('abort', onAbort, { once: true });
+                child.stdout?.on('data', (d) => { stdout += d.toString('utf8'); });
+                child.stderr?.on('data', (d) => { stderr += d.toString('utf8'); });
+                child.on('error', (err) => settle({ content: `Error: ${err.message}`, isError: true }));
+                child.on('close', (code, signal) => summarize(code, signal, false));
+            });
+        },
+    };
+}

package/dist/src/core/tools/types.js

@@ -0,0 +1,6 @@
+export function okToolOk(content) {
+    return { content };
+}
+export function toolError(message) {
+    return { content: `Error: ${message}`, isError: true };
+}

package/dist/src/core/types.js

@@ -0,0 +1,3 @@
+export function newMessage(id, role, content = '') {
+    return { id, role, content, createdAt: Date.now() };
+}

package/dist/src/index.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { main } from './cli/run.js';
+// orbit-agent entrypoint. Kept tiny: all logic lives in cli/run.ts.
+main(process.argv.slice(2))
+    .then((code) => {
+    process.exitCode = code;
+})
+    .catch((err) => {
+    console.error('\n\x1b[31morbital failure:\x1b[0m', err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+});

package/dist/src/session/event-log.js

@@ -0,0 +1,55 @@
+import { mkdirSync, appendFileSync, readFileSync, existsSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { sessionsDir } from '../utils/platform.js';
+function logFileFor(sessionId) {
+    return join(sessionsDir(), `${sessionId}.log`);
+}
+export function createEventLog(sessionId) {
+    try {
+        mkdirSync(sessionsDir(), { recursive: true });
+        appendFileSync(logFileFor(sessionId), '');
+    }
+    catch {
+        /* best-effort */
+    }
+}
+export function appendEvent(sessionId, entry) {
+    try {
+        const line = JSON.stringify({ ts: Date.now(), ...entry }) + '\n';
+        appendFileSync(logFileFor(sessionId), line, 'utf8');
+    }
+    catch {
+        /* never let logging break the agent */
+    }
+}
+export function readEventLog(sessionId) {
+    const p = logFileFor(sessionId);
+    if (!existsSync(p))
+        return [];
+    try {
+        const raw = readFileSync(p, 'utf8');
+        const out = [];
+        for (const line of raw.split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                out.push(JSON.parse(line));
+            }
+            catch {
+                /* skip corrupt line */
+            }
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+export function eventLogSize(sessionId) {
+    try {
+        return statSync(logFileFor(sessionId)).size;
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/src/session/store.js

@@ -0,0 +1,76 @@
+import { mkdirSync, readdirSync, readFileSync, writeFileSync, existsSync, statSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { sessionsDir } from '../utils/platform.js';
+function ensureDir() {
+    mkdirSync(sessionsDir(), { recursive: true });
+}
+function fileFor(id) {
+    return join(sessionsDir(), `${id}.json`);
+}
+export function createSession(name, cwd) {
+    ensureDir();
+    const id = `s_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+    const session = {
+        id,
+        name,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        cwd,
+        messages: [],
+    };
+    writeFileSync(fileFor(id), JSON.stringify(session, null, 2), 'utf8');
+    return session;
+}
+export function saveSession(session) {
+    ensureDir();
+    session.updatedAt = Date.now();
+    writeFileSync(fileFor(session.id), JSON.stringify(session, null, 2), 'utf8');
+}
+export function loadSession(id) {
+    try {
+        const raw = readFileSync(fileFor(id), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function listSessions() {
+    if (!existsSync(sessionsDir()))
+        return [];
+    const out = [];
+    for (const f of readdirSync(sessionsDir())) {
+        if (!f.endsWith('.json'))
+            continue;
+        try {
+            const raw = readFileSync(join(sessionsDir(), f), 'utf8');
+            out.push(JSON.parse(raw));
+        }
+        catch {
+            /* skip corrupt */
+        }
+    }
+    return out.sort((a, b) => b.updatedAt - a.updatedAt);
+}
+export function pruneSessions(max = 50) {
+    const sessions = listSessions();
+    if (sessions.length <= max)
+        return;
+    const toRemove = sessions.slice(max);
+    for (const s of toRemove) {
+        try {
+            unlinkSync(fileFor(s.id));
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+export function sessionFileModifiedMs(id) {
+    try {
+        return statSync(fileFor(id)).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/src/setup/wizard.js

@@ -0,0 +1,401 @@
+import * as term from '../tui/term.js';
+import { VTerm, composeRow } from '../tui/renderer.js';
+import { setRenderCallback, flushNow } from '../tui/scheduler.js';
+import { makeTheme, THEME_NAMES } from '../tui/themes/index.js';
+import { padRight } from '../tui/text.js';
+import { defaultConfig } from '../config/config-schema.js';
+import { PROVIDER_SPECS } from '../core/llm/index.js';
+import { modelSupportsReasoning } from '../core/llm/models.js';
+import { describeProvidersAvailable } from '../core/llm/secrets.js';
+const PERM_OPTIONS = ['ask', 'allow', 'deny'];
+const FOOTER = '[↑↓] move · [Enter] confirm · [Ctrl-C] cancel';
+export async function runWizard(cfg, _args) {
+    const state = {
+        themeIdx: Math.max(0, THEME_NAMES.indexOf(cfg.theme)),
+        providerSelected: Math.max(0, PROVIDER_SPECS.findIndex((p) => p.id === cfg.provider)),
+        orbitxUrl: cfg.orbitx.url,
+        orbitxToken: '',
+        modelSelected: 0,
+        reasoningIdx: 0,
+        permSelected: Math.max(0, PERM_OPTIONS.indexOf(cfg.permissions.mode)),
+        step: 0,
+    };
+    let theme = makeTheme(cfg.theme);
+    term.setup();
+    try {
+        const [cols, rows] = term.termSize();
+        const vterm = new VTerm(Math.max(cols, 20), Math.max(rows, 8));
+        let done = false;
+        let finalizedAt = Infinity;
+        let result = null;
+        setRenderCallback(render);
+        term.onResize(() => {
+            const [c, h] = term.termSize();
+            vterm.resize(Math.max(c, 20), Math.max(h, 8));
+            flushNow();
+        });
+        const keyUnsub = term.onKey((key) => {
+            if (key.name === 'ctrl-c') {
+                keyUnsub();
+                done = true;
+                finalizedAt = Date.now() + 250;
+                result = null;
+                flushNow();
+                return;
+            }
+            handleKey(state, key);
+            theme = makeTheme(THEME_NAMES[Math.max(0, Math.min(state.themeIdx, THEME_NAMES.length - 1))]);
+            if (state.step >= 7 && !done) {
+                keyUnsub();
+                done = true;
+                finalizedAt = Date.now() + 900;
+                result = buildConfig(state, cfg);
+            }
+            flushNow();
+        });
+        function render() {
+            if (done)
+                return;
+            const w = vterm.w;
+            const h = vterm.h;
+            vterm.fillClear(theme);
+            if (state.step >= 7) {
+                renderDone(w, h);
+                return;
+            }
+            const lines = contentLines(state, theme, w);
+            const boxW = Math.min(64, w - 4);
+            const boxX = Math.max(0, Math.floor((w - boxW) / 2));
+            const availH = h - 2;
+            const body = lines.slice(0, Math.max(1, availH - 1));
+            vterm.setRow(1, boxRow(theme, w, boxX, boxW, '', 'top'));
+            for (let i = 0; i < Math.max(1, availH - 2); i++) {
+                const line = body[i] ?? '';
+                vterm.setRow(2 + i, boxRow(theme, w, boxX, boxW, padRight(line, boxW - 2, ' '), 'body'));
+            }
+            vterm.setRow(Math.min(h - 1, 2 + Math.max(1, availH - 2)), boxRow(theme, w, boxX, boxW, '', 'bottom'));
+            term.hideCursor();
+        }
+        function renderDone(w, h) {
+            const lines = contentLines(state, theme, w);
+            const boxW = Math.min(64, w - 4);
+            const boxX = Math.max(0, Math.floor((w - boxW) / 2));
+            const body = lines.slice(0, Math.max(1, h - 4));
+            const topY = Math.max(0, Math.floor(h / 2) - 1);
+            vterm.setRow(topY, boxRow(theme, w, boxX, boxW, '', 'top'));
+            for (let i = 0; i < body.length; i++) {
+                const line = body[i] ?? '';
+                vterm.setRow(topY + 1 + i, boxRow(theme, w, boxX, boxW, padRight(line, boxW - 2, ' '), 'body'));
+            }
+            vterm.setRow(topY + 1 + body.length, boxRow(theme, w, boxX, boxW, '', 'bottom'));
+            term.hideCursor();
+        }
+        flushNow();
+        return await new Promise((resolve) => {
+            const poll = setInterval(() => {
+                if (done && Date.now() >= finalizedAt) {
+                    clearInterval(poll);
+                    resolve(result);
+                }
+            }, 30);
+            void keyUnsub;
+        });
+    }
+    finally {
+        term.teardown();
+    }
+}
+function handleKey(state, key) {
+    switch (state.step) {
+        case 0: // theme
+            if (key.name === 'up')
+                state.themeIdx = (state.themeIdx - 1 + THEME_NAMES.length) % THEME_NAMES.length;
+            else if (key.name === 'down')
+                state.themeIdx = (state.themeIdx + 1) % THEME_NAMES.length;
+            else if (key.name === 'enter')
+                state.step = 1;
+            break;
+        case 1: // provider
+            if (key.name === 'up')
+                state.providerSelected = Math.max(0, state.providerSelected - 1);
+            else if (key.name === 'down')
+                state.providerSelected = Math.min(PROVIDER_SPECS.length - 1, state.providerSelected + 1);
+            else if (key.name === 'enter') {
+                const sel = PROVIDER_SPECS[state.providerSelected];
+                state.modelSelected = 0;
+                state.reasoningIdx = 0;
+                if (sel.id === 'orbitx')
+                    state.step = 2;
+                else {
+                    state.orbitxUrl = '';
+                    state.orbitxToken = '';
+                    state.step = 4;
+                }
+            }
+            break;
+        case 2: // orbitx url
+            if (key.name === 'char' && key.value)
+                state.orbitxUrl += key.value;
+            else if (key.name === 'backspace')
+                state.orbitxUrl = state.orbitxUrl.slice(0, -1);
+            else if (key.name === 'enter')
+                state.step = 3;
+            break;
+        case 3: // orbitx token
+            if (key.name === 'char' && key.value)
+                state.orbitxToken += key.value;
+            else if (key.name === 'backspace')
+                state.orbitxToken = state.orbitxToken.slice(0, -1);
+            else if (key.name === 'enter')
+                state.step = 4;
+            break;
+        case 4: // model
+            if (key.name === 'up')
+                state.modelSelected = Math.max(0, state.modelSelected - 1);
+            else if (key.name === 'down')
+                state.modelSelected++;
+            else if (key.name === 'enter') {
+                state.reasoningIdx = defaultReasoningIdx(selectedModel(state));
+                state.step = 5;
+            }
+            break;
+        case 5: { // reasoning
+            const options = reasoningOptions(state);
+            if (key.name === 'up')
+                state.reasoningIdx = Math.max(0, state.reasoningIdx - 1);
+            else if (key.name === 'down')
+                state.reasoningIdx = Math.min(options.length - 1, state.reasoningIdx + 1);
+            else if (key.name === 'enter')
+                state.step = 6;
+            break;
+        }
+        case 6: // permissions
+            if (key.name === 'up')
+                state.permSelected = Math.max(0, state.permSelected - 1);
+            else if (key.name === 'down')
+                state.permSelected = Math.min(PERM_OPTIONS.length - 1, state.permSelected + 1);
+            else if (key.name === 'enter')
+                state.step = 7;
+            break;
+        default:
+            break;
+    }
+}
+/** The currently selected catalog model, if any. */
+function selectedModel(state) {
+    const spec = PROVIDER_SPECS[state.providerSelected];
+    if (!spec || !spec.models || spec.models.length === 0)
+        return null;
+    const m = spec.models[Math.min(state.modelSelected, spec.models.length - 1)];
+    return m ?? null;
+}
+/** Reasoning picker options for the selected model, or [] when not applicable. */
+function reasoningOptions(state) {
+    const m = selectedModel(state);
+    if (!m || !modelSupportsReasoning(m))
+        return [];
+    const efforts = m.reasoning?.efforts ?? ['low', 'medium', 'high'];
+    const leveled = efforts.filter((e) => e !== 'none');
+    if (m.reasoning?.switchable === false)
+        return leveled;
+    return ['off', ...leveled];
+}
+function defaultReasoningIdx(m) {
+    if (!m || !modelSupportsReasoning(m))
+        return 0;
+    const options = reasoningOptionsFor(m);
+    const def = m.reasoning?.default;
+    if (def && def !== 'none') {
+        const i = options.indexOf(String(def));
+        if (i >= 0)
+            return i;
+    }
+    return options.indexOf('off') >= 0 ? options.indexOf('off') + 1 : 0;
+}
+function reasoningOptionsFor(m) {
+    const efforts = m.reasoning?.efforts ?? ['low', 'medium', 'high'];
+    const leveled = efforts.filter((e) => e !== 'none');
+    if (m.reasoning?.switchable === false)
+        return leveled;
+    return ['off', ...leveled];
+}
+function currentReasoning(m, st) {
+    if (!m || !modelSupportsReasoning(m))
+        return null;
+    const options = reasoningOptionsFor(m);
+    const pick = options[st.reasoningIdx] ?? 'medium';
+    if (pick === 'off')
+        return { enabled: false, effort: 'medium' };
+    return { enabled: true, effort: pick };
+}
+function contentLines(state, theme, width) {
+    const lines = [];
+    const accentSgr = theme.table.sgr(theme.styles['accent']);
+    const dimSgr = theme.table.sgr(theme.styles['dim']);
+    const infoSgr = theme.table.sgr(theme.styles['info']);
+    const reset = '\x1b[0m';
+    switch (state.step) {
+        case 0: {
+            lines.push(`${accentSgr}◆ orbit-agent${reset} ${dimSgr}setup · theme${reset}`);
+            lines.push('');
+            THEME_NAMES.forEach((name, i) => {
+                if (i === state.themeIdx)
+                    lines.push(`${accentSgr}▸ ${name}${reset}`);
+                else
+                    lines.push(`   ${dimSgr}${name}${reset}`);
+            });
+            lines.push('');
+            break;
+        }
+        case 1: {
+            lines.push(`${accentSgr}Pick an LLM provider${reset}`);
+            lines.push('');
+            PROVIDER_SPECS.forEach((p, i) => {
+                const av = describeProvidersAvailable().some((a) => a.provider === p.id);
+                const flag = p.id === 'orbitx' ? ' free · auto-routes Groq/Gemini/OpenRouter' : av ? ' ✓ available' : ` ${dimSgr}(keys not set)${reset}`;
+                if (i === state.providerSelected)
+                    lines.push(`${accentSgr}▸ ${p.label}${reset}${dimSgr}${flag}${reset}`);
+                else
+                    lines.push(`  ${p.label}${dimSgr}${flag}${reset}`);
+            });
+            lines.push('');
+            break;
+        }
+        case 2: {
+            lines.push(`${accentSgr}Orbit X backend URL${reset}`);
+            lines.push('');
+            lines.push(`❯ ${state.orbitxUrl || `${dimSgr}(default https://orbit-x-rfj6.onrender.com)${reset}`}`);
+            lines.push('');
+            break;
+        }
+        case 3: {
+            lines.push(`${accentSgr}Orbit X token${reset}`);
+            lines.push('');
+            const masked = state.orbitxToken ? '•'.repeat(Math.min(state.orbitxToken.length, 24)) : '';
+            lines.push(`❯ ${masked || dimSgr + '(type or paste your token — kept in keys.json, never config)' + reset}`);
+            lines.push('');
+            break;
+        }
+        case 4: {
+            const provider = PROVIDER_SPECS[state.providerSelected];
+            lines.push(`${accentSgr}Pick a model · ${provider.label}${reset}`);
+            lines.push('');
+            const models = provider.models.length > 0 ? provider.models : [];
+            if (models.length === 0) {
+                lines.push(`${dimSgr}(no catalog — will be resolved by the backend)${reset}`);
+            }
+            else {
+                models.forEach((m, i) => {
+                    const display = provider.id === 'orbitx' ? m.label ?? 'auto' : m.label ?? m.id;
+                    if (i === state.modelSelected)
+                        lines.push(`${accentSgr}▸ ${display}${reset}`);
+                    else
+                        lines.push(`  ${display}`);
+                });
+            }
+            lines.push('');
+            break;
+        }
+        case 5: {
+            const m = selectedModel(state);
+            const options = reasoningOptions(state);
+            if (options.length === 0) {
+                lines.push(`${infoSgr}This model has no reasoning toggle.${reset}`);
+                lines.push('');
+                lines.push(`${dimSgr}Press Enter to continue.${reset}`);
+            }
+            else {
+                lines.push(`${accentSgr}Thinking / reasoning · ${m?.label ?? ''}${reset}`);
+                lines.push('');
+                options.forEach((opt, i) => {
+                    const display = opt === 'off' ? 'off (no thinking)' : `effort: ${opt}`;
+                    if (i === state.reasoningIdx)
+                        lines.push(`${accentSgr}▸ ${display}${reset}`);
+                    else
+                        lines.push(`  ${display}`);
+                });
+            }
+            lines.push('');
+            break;
+        }
+        case 6: {
+            lines.push(`${accentSgr}Permission mode${reset}`);
+            lines.push('');
+            PERM_OPTIONS.forEach((mode, i) => {
+                if (i === state.permSelected)
+                    lines.push(`${accentSgr}▸ ${mode}${reset}`);
+                else
+                    lines.push(`  ${mode}`);
+            });
+            lines.push('');
+            lines.push(dimSgr + 'ask = confirm risky commands  ·  allow = auto-approve  ·  deny = block all' + reset);
+            break;
+        }
+        case 7: {
+            const provider = PROVIDER_SPECS[state.providerSelected];
+            lines.push(`${accentSgr}✓ Setup complete${reset}`);
+            lines.push('');
+            lines.push(`  Theme:     ${THEME_NAMES[state.themeIdx]}`);
+            lines.push(`  Provider:  ${provider.label}`);
+            if (provider.id === 'orbitx')
+                lines.push(`  Backend:   ${state.orbitxUrl || '(default)'}`);
+            const model = selectedModel(state);
+            if (model && provider.id !== 'orbitx') {
+                lines.push(`  Model:     ${model.label ?? model.id}`);
+                const r = currentReasoning(model, state);
+                if (r)
+                    lines.push(`  Thinking:  ${r.enabled ? r.effort : 'off'}`);
+            }
+            else {
+                lines.push(`  Model:     auto (backend routes)`);
+            }
+            lines.push(`  Permissions: ${PERM_OPTIONS[state.permSelected]}`);
+            lines.push('');
+            lines.push(dimSgr + 'Keys live in environment variables or ~/.config/orbit-agent/keys.json — never config.' + reset);
+            break;
+        }
+        default:
+            lines.push('');
+    }
+    lines.push('');
+    lines.push(`${dimSgr}${FOOTER}${reset}`);
+    void width;
+    return lines;
+}
+function boxRow(theme, width, boxX, boxW, inner, kind) {
+    const border = theme.table.sgr(theme.styles['border']);
+    const reset = '\x1b[0m';
+    let content;
+    if (kind === 'top')
+        content = `${border}╭${'─'.repeat(Math.max(0, boxW - 2))}╮${reset}`;
+    else if (kind === 'bottom')
+        content = `${border}╰${'─'.repeat(Math.max(0, boxW - 2))}╯${reset}`;
+    else
+        content = `${border}│${reset}${padRight(inner, boxW - 2, ' ')}${border}│${reset}`;
+    return composeRow(theme, width, `${' '.repeat(Math.max(0, boxX))}${content}`);
+}
+function buildConfig(state, base) {
+    const spec = PROVIDER_SPECS[state.providerSelected];
+    const provider = spec.id;
+    const cfg = { ...defaultConfig(), ...base };
+    cfg.theme = THEME_NAMES[state.themeIdx];
+    cfg.provider = provider;
+    cfg.orbitx.url = state.orbitxUrl.trim() || 'https://orbit-x-rfj6.onrender.com';
+    if (state.orbitxToken.trim())
+        cfg.orbitx.token = state.orbitxToken.trim();
+    cfg.permissions.mode = PERM_OPTIONS[state.permSelected];
+    cfg.firstRunComplete = true;
+    const model = selectedModel(state);
+    if (provider !== 'orbitx' && model) {
+        cfg.model.primary = `${provider}/${model.id}`;
+        cfg.model.fallback = [];
+        const r = currentReasoning(model, state);
+        if (r)
+            cfg.reasoning = r;
+    }
+    else {
+        cfg.model.primary = 'gemini/gemini-2.5-flash';
+        cfg.model.fallback = ['openrouter/qwen/qwen-2.5-coder-32b-instruct', 'groq/llama-3.3-70b-versatile'];
+    }
+    return cfg;
+}