@matterailab/orbcode 0.2.2 → 0.2.4

package/dist/ui/components/McpPicker.js

@@ -0,0 +1,262 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { COLORS } from "../../branding.js";
+import { McpAuthScreen } from "./McpAuthScreen.js";
+const VISIBLE_ROWS = 8;
+function statusColor(state) {
+    switch (state.status) {
+        case "connected":
+            return COLORS.success;
+        case "connecting":
+            return COLORS.warning;
+        case "failed":
+            return COLORS.error;
+        case "needs-auth":
+            return COLORS.warning;
+        case "disabled":
+            return COLORS.dim;
+    }
+}
+function statusIcon(state) {
+    switch (state.status) {
+        case "connected":
+            return "✓";
+        case "connecting":
+            return "⋯";
+        case "failed":
+            return "✗";
+        case "needs-auth":
+            return "△";
+        case "disabled":
+            return "○";
+    }
+}
+/** Build the action list for a server based on its current state. */
+function buildActions(state) {
+    const actions = [];
+    if (state.status === "needs-auth")
+        actions.push("Authenticate");
+    if (state.disabled || state.status === "disabled")
+        actions.push("Enable");
+    else
+        actions.push("Disable");
+    actions.push("Reconnect");
+    return actions;
+}
+/**
+ * Interactive MCP server manager, opened by the `/mcp` command.
+ *
+ * Two-level navigation (arrow keys + enter only, no shorthand keys):
+ *   - Server list: ↑/↓ to select a server, enter to open its action menu.
+ *   - Action menu: ↑/↓ to select an action, enter to execute, esc to go back.
+ *
+ * Actions adapt to the server's state: Authenticate (needs-auth), Enable
+ * (disabled), Disable (connected/failed), Reconnect (always).
+ */
+export function McpPicker({ manager, onChanged, onCancel }) {
+    const [snapshot, setSnapshot] = useState(() => manager.snapshot());
+    const [selected, setSelected] = useState(0);
+    const [busy, setBusy] = useState(false);
+    const [busyMessage, setBusyMessage] = useState("");
+    const [authingServer, setAuthingServer] = useState(null);
+    const [authUrl, setAuthUrl] = useState("");
+    const [actionMode, setActionMode] = useState(false);
+    const [actionSelected, setActionSelected] = useState(0);
+    const codeResolveRef = useRef(null);
+    const codeRejectRef = useRef(null);
+    const servers = snapshot.servers;
+    const count = servers.length;
+    const current = servers[selected];
+    const actions = current ? buildActions(current) : [];
+    useInput((_input, key) => {
+        if (authingServer || busy)
+            return;
+        if (actionMode) {
+            if (key.escape) {
+                setActionMode(false);
+                return;
+            }
+            if (key.upArrow) {
+                setActionSelected((s) => (s - 1 + actions.length) % actions.length);
+                return;
+            }
+            if (key.downArrow || key.tab) {
+                setActionSelected((s) => (s + 1) % actions.length);
+                return;
+            }
+            if (key.return) {
+                void executeAction(actions[actionSelected]);
+                return;
+            }
+            return;
+        }
+        // Server list navigation.
+        if (key.escape) {
+            onCancel();
+            return;
+        }
+        if (key.upArrow) {
+            setSelected((s) => (s - 1 + count) % count);
+            return;
+        }
+        if (key.downArrow || key.tab) {
+            setSelected((s) => (s + 1) % count);
+            return;
+        }
+        if (key.return) {
+            setActionMode(true);
+            setActionSelected(0);
+            return;
+        }
+    });
+    async function refresh() {
+        setSnapshot(manager.snapshot());
+        onChanged();
+    }
+    async function executeAction(action) {
+        if (!action || !current)
+            return;
+        setActionMode(false);
+        if (action === "Authenticate")
+            await reauthSelected();
+        else if (action === "Enable")
+            await enableSelected();
+        else if (action === "Disable")
+            await disableSelected();
+        else if (action === "Reconnect")
+            await reconnectSelected();
+    }
+    async function enableSelected() {
+        if (!current)
+            return;
+        setBusy(true);
+        setBusyMessage("Enabling…");
+        try {
+            await manager.enableServer(current.name);
+            await refresh();
+        }
+        finally {
+            setBusy(false);
+            setBusyMessage("");
+        }
+    }
+    async function disableSelected() {
+        if (!current)
+            return;
+        setBusy(true);
+        setBusyMessage("Disabling…");
+        try {
+            await manager.disableServer(current.name);
+            await refresh();
+        }
+        finally {
+            setBusy(false);
+            setBusyMessage("");
+        }
+    }
+    async function reconnectSelected() {
+        if (!current)
+            return;
+        setBusy(true);
+        setBusyMessage("Reconnecting…");
+        try {
+            await manager.disconnectOne(current.name);
+            await manager.connectOne(current.name);
+            await refresh();
+        }
+        finally {
+            setBusy(false);
+            setBusyMessage("");
+        }
+    }
+    async function reauthSelected() {
+        if (!current)
+            return;
+        const intercept = {
+            onAuthUrl: (url) => setAuthUrl(url),
+            getCode: () => new Promise((resolve, reject) => {
+                codeResolveRef.current = resolve;
+                codeRejectRef.current = reject;
+            }),
+        };
+        setAuthingServer(current.name);
+        setAuthUrl("");
+        setBusy(true);
+        try {
+            await manager.reauthServer(current.name, intercept);
+            await refresh();
+        }
+        catch {
+            // auth failed or cancelled; server stays needs-auth
+        }
+        finally {
+            setAuthingServer(null);
+            setAuthUrl("");
+            codeResolveRef.current = null;
+            codeRejectRef.current = null;
+            setBusy(false);
+        }
+    }
+    function handlePasteCode(input) {
+        try {
+            const url = new URL(input);
+            const code = url.searchParams.get("code");
+            if (code) {
+                codeResolveRef.current?.(code);
+                return;
+            }
+        }
+        catch {
+            // not a URL — treat as bare code
+        }
+        codeResolveRef.current?.(input);
+    }
+    function handleAuthCancel() {
+        codeRejectRef.current?.(new Error("Authentication cancelled."));
+    }
+    if (count === 0) {
+        return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: COLORS.primary, paddingX: 1, children: [_jsx(Text, { bold: true, color: COLORS.primary, children: "MCP servers" }), _jsx(Text, { dimColor: true, children: "No MCP servers configured." }), _jsx(Text, { dimColor: true, children: "Add servers with: orbcode mcp add <name> <command> [args...]" }), _jsx(Text, { dimColor: true, children: "esc to close" })] }));
+    }
+    if (authingServer) {
+        return (_jsx(McpAuthScreen, { serverName: authingServer, authUrl: authUrl, onPasteCode: handlePasteCode, onCancel: handleAuthCancel }));
+    }
+    const windowStart = Math.max(0, Math.min(selected - VISIBLE_ROWS + 1, count - VISIBLE_ROWS));
+    const visible = servers.slice(windowStart, windowStart + VISIBLE_ROWS);
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: COLORS.primary, paddingX: 1, children: [_jsxs(Text, { bold: true, color: COLORS.primary, children: ["Manage MCP servers (", count, ")"] }), windowStart > 0 && _jsxs(Text, { dimColor: true, children: ["  \u2191 ", windowStart, " more"] }), visible.map((state, i) => {
+                const index = windowStart + i;
+                const isSelected = index === selected && !actionMode;
+                return (_jsxs(Text, { color: isSelected ? COLORS.accent : undefined, children: [isSelected ? "❯ " : "  ", state.name, "  ", _jsxs(Text, { color: statusColor(state), children: [statusIcon(state), " ", state.status] }), state.toolCount > 0 && _jsxs(Text, { dimColor: true, children: [" \u00B7 ", state.toolCount, " tools"] })] }, state.name));
+            }), windowStart + VISIBLE_ROWS < count && (_jsxs(Text, { dimColor: true, children: ["  \u2193 ", count - windowStart - VISIBLE_ROWS, " more"] })), current && (_jsx(DetailPanel, { manager: manager, state: current, actions: actions, actionMode: actionMode, actionSelected: actionSelected })), _jsx(Text, { dimColor: true, children: busy
+                    ? busyMessage
+                    : actionMode
+                        ? "↑/↓ select action · enter execute · esc back"
+                        : "↑/↓ select server · enter open actions · esc close" })] }));
+}
+function DetailPanel({ manager, state, actions, actionMode, actionSelected, }) {
+    const cfg = manager.getConfig(state.name);
+    const configPath = manager.getConfigPath(state.name);
+    const isOAuth = manager.isOAuthServer(state.name);
+    const authenticated = manager.isAuthenticated(state.name);
+    const authText = !isOAuth
+        ? "— (static / stdio)"
+        : authenticated
+            ? "✓ authenticated"
+            : "✗ not authenticated";
+    let urlText;
+    if (cfg && (cfg.type === "http" || cfg.type === "sse")) {
+        urlText = cfg.url;
+    }
+    else if (cfg) {
+        const cmd = cfg.command;
+        const args = cfg.args ?? [];
+        urlText = `stdio: ${cmd}${args.length ? " " + args.join(" ") : ""}`;
+    }
+    else {
+        urlText = "";
+    }
+    return (_jsxs(Box, { paddingLeft: 1, marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { bold: true, children: [state.name, " MCP Server"] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Status:          " }), _jsxs(Text, { color: statusColor(state), children: [statusIcon(state), " ", state.status] })] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Auth:            " }), _jsx(Text, { color: isOAuth && !authenticated ? COLORS.error : isOAuth ? COLORS.success : COLORS.dim, children: authText })] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "URL:             " }), urlText] }), configPath && (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Config location: " }), _jsx(Text, { dimColor: true, children: configPath })] })), state.detail && (_jsx(Text, { color: state.status === "failed" ? COLORS.error : state.status === "needs-auth" ? COLORS.warning : COLORS.dim, children: state.detail })), _jsx(Box, { marginTop: 1, flexDirection: "column", children: actions.map((action, i) => {
+                    const isSelected = actionMode && i === actionSelected;
+                    return (_jsxs(Text, { color: isSelected ? COLORS.accent : undefined, children: [isSelected ? "❯ " : "  ", i + 1, ". ", action] }, action));
+                }) })] }));
+}

package/dist/ui/components/StatusBar.js

@@ -9,11 +9,11 @@ const MODE_LABELS = {
 };
 function formatRelativeTime(isoStr) {
     if (!isoStr)
-        return "???";
+        return "on session start";
     const now = Date.now();
     const target = new Date(isoStr).getTime();
     if (Number.isNaN(target))
-        return "???";
+        return "on session start";
     const diff = target - now;
     if (diff <= 0)
         return "now";
@@ -33,18 +33,37 @@ function truncate(text, max) {
     return text.length > max ? text.slice(0, max - 1) + "…" : text;
 }
 /**
- * Formats the 5hr window as "5hr limit XX% · resets <relative>".
+ * Picks the usage window that currently constrains the agent and formats it as
+ * "<window> limit XX% · resets <relative>".
+ *
+ * The smallest window (5hr) is the one actively in use, so we show it by
+ * default. We only escalate to a larger window once it has hit its cap (100%):
+ * a capped larger window is the real blocker, since a smaller window resetting
+ * won't unblock you until the larger one does. When several are capped, the
+ * largest wins (it takes longest to recover).
  * Returns null when tiered usage is unavailable so the line can be hidden.
  */
-function fiveHourSummary(tu) {
-    if (!tu?.fiveHour)
+function usageSummary(tu) {
+    if (!tu)
         return null;
-    const { percentage, resetsAt } = tu.fiveHour;
-    return `5hr limit ${Math.round(percentage)}% · resets ${formatRelativeTime(resetsAt)}`;
+    // Largest-to-smallest, so `find` returns the largest capped window and the
+    // last entry is the smallest available window.
+    const windows = [
+        { label: "monthly limit", usage: tu.monthly },
+        { label: "weekly limit", usage: tu.weekly },
+        { label: "5hr limit", usage: tu.fiveHour },
+    ];
+    const available = windows.filter((w) => Boolean(w.usage));
+    if (available.length === 0)
+        return null;
+    const binding = available.find((w) => w.usage.percentage >= 100) ??
+        available[available.length - 1];
+    const { percentage, resetsAt } = binding.usage;
+    return `${binding.label} ${Math.round(percentage)}% · resets ${formatRelativeTime(resetsAt)}`;
 }
 export function StatusBar({ modelId, contextTokens, totalCost: _totalCost, state, approvalMode, busy, title, plan: _plan, usagePercentage: _usagePercentage, tieredUsage, }) {
     const model = getModel(modelId);
     const contextPct = Math.min(100, Math.round((contextTokens / model.contextWindow) * 100));
-    const fiveHourLine = fiveHourSummary(tieredUsage);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { dimColor: true, children: [_jsx(Text, { color: approvalMode === "ask" ? undefined : COLORS.warning, children: MODE_LABELS[approvalMode] }), " (shift+tab to cycle)", busy && " · esc to interrupt", state ? _jsxs(Text, { color: COLORS.thinking, children: [" \u00B7 ", state] }) : null] }), _jsxs(Text, { dimColor: true, children: [title ? `${truncate(title, 32)} · ` : "", model.name, " \u00B7 ctx ", contextTokens.toLocaleString(), " (", contextPct, "%)"] })] }), fiveHourLine && (_jsx(Box, { justifyContent: "flex-end", children: _jsx(Text, { dimColor: true, children: fiveHourLine }) }))] }));
+    const usageLine = usageSummary(tieredUsage);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { dimColor: true, children: [_jsx(Text, { color: approvalMode === "ask" ? undefined : COLORS.warning, children: MODE_LABELS[approvalMode] }), " (shift+tab to cycle)", busy && " · esc to interrupt", state ? _jsxs(Text, { color: COLORS.thinking, children: [" \u00B7 ", state] }) : null] }), _jsxs(Text, { dimColor: true, children: [title ? `${truncate(title, 32)} · ` : "", model.name, " \u00B7 ctx ", contextTokens.toLocaleString(), " (", contextPct, "%)"] })] }), usageLine && (_jsx(Box, { justifyContent: "flex-end", children: _jsx(Text, { dimColor: true, children: usageLine }) }))] }));
 }

package/dist/utils/clipboard.js

@@ -0,0 +1,45 @@
+import { execSync } from "node:child_process";
+import { platform } from "node:os";
+/**
+ * Copy text to the system clipboard. Uses the platform's native clipboard
+ * utility (pbcopy on macOS, xclip/xsel on Linux, clip on Windows). Returns
+ * true on success, false if no clipboard utility is available.
+ */
+export function copyToClipboard(text) {
+    const cmd = clipboardCommand();
+    if (!cmd)
+        return false;
+    try {
+        execSync(cmd, { input: text, stdio: ["pipe", "ignore", "ignore"] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Detect the platform's clipboard command, or null if none is available. */
+function clipboardCommand() {
+    const p = platform();
+    if (p === "darwin")
+        return "pbcopy";
+    if (p === "win32")
+        return "clip";
+    // Linux: try xclip, then xsel. We can't check availability without spawning,
+    // so prefer xclip (more common on modern distros) and fall back to xsel.
+    if (p === "linux") {
+        try {
+            execSync("which xclip", { stdio: "ignore" });
+            return "xclip -selection clipboard";
+        }
+        catch {
+            try {
+                execSync("which xsel", { stdio: "ignore" });
+                return "xsel --clipboard --input";
+            }
+            catch {
+                return null;
+            }
+        }
+    }
+    return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterailab/orbcode",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "OrbCode CLI — agentic coding in your terminal, powered by Axon models by MatterAI",
   "type": "module",
   "bin": {
@@ -38,6 +38,7 @@
   "dependencies": {
     "@ai-sdk/anthropic": "^3.0.85",
     "@ai-sdk/openai-compatible": "^2.0.51",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "ai": "^6.0.207",
     "chalk": "^5.3.0",
     "ink": "^5.2.1",