@intent-systems/nexus 2026.1.5-3

package/dist/infra/provider-usage.js

@@ -0,0 +1,145 @@
+import { resolveProviderAuths } from "./provider-usage.auth.js";
+import { fetchClaudeUsage } from "./provider-usage.fetch.claude.js";
+import { fetchMinimaxUsage } from "./provider-usage.fetch.minimax.js";
+import { clampPercent, PROVIDER_LABELS } from "./provider-usage.shared.js";
+import { fetchJson } from "./provider-usage.fetch.shared.js";
+function resolveProviders(params) {
+    if (params.providers && params.providers.length > 0) {
+        return params.providers;
+    }
+    if (params.auth && params.auth.length > 0) {
+        return Array.from(new Set(params.auth.map((entry) => entry.provider)));
+    }
+    return [];
+}
+function formatDurationLabel(ms) {
+    if (!Number.isFinite(ms) || ms <= 0)
+        return "now";
+    const minutes = Math.ceil(ms / 60_000);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.ceil(minutes / 60);
+    if (hours < 24)
+        return `${hours}h`;
+    const days = Math.ceil(hours / 24);
+    return `${days}d`;
+}
+function formatResetLabel(resetAt, now) {
+    if (!Number.isFinite(resetAt))
+        return null;
+    const delta = resetAt - now;
+    return `resets ${formatDurationLabel(delta)}`;
+}
+async function fetchZaiUsage(apiKey, timeoutMs, fetchFn) {
+    const res = await fetchJson("https://api.z.ai/v1/user/usage", {
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            Accept: "application/json",
+        },
+    }, timeoutMs, fetchFn);
+    if (!res.ok) {
+        return {
+            provider: "zai",
+            displayName: PROVIDER_LABELS.zai,
+            windows: [],
+            error: `HTTP ${res.status}`,
+        };
+    }
+    const data = (await res.json().catch(() => null));
+    const plan = data?.data?.planName;
+    const limit = data?.data?.limits?.find((entry) => entry?.type === "TOKENS_LIMIT") ??
+        data?.data?.limits?.[0];
+    const usedPercent = clampPercent(limit?.percentage ?? 0);
+    const resetAt = limit?.nextResetTime ? Date.parse(limit.nextResetTime) : undefined;
+    const windows = [];
+    if (Number.isFinite(usedPercent)) {
+        windows.push({
+            label: "Plan",
+            usedPercent,
+            resetAt,
+        });
+    }
+    return {
+        provider: "zai",
+        displayName: PROVIDER_LABELS.zai,
+        windows,
+        plan: plan?.trim() || undefined,
+    };
+}
+export async function loadProviderUsageSummary(params) {
+    const now = params.now ?? Date.now();
+    const providers = resolveProviders(params);
+    if (providers.length === 0) {
+        return { updatedAt: now, providers: [] };
+    }
+    const auths = await resolveProviderAuths({
+        providers,
+        auth: params.auth,
+        agentDir: params.agentDir,
+    });
+    const fetchFn = params.fetch ?? fetch;
+    const timeoutMs = 10_000;
+    const snapshots = [];
+    for (const auth of auths) {
+        if (auth.provider === "anthropic") {
+            snapshots.push(await fetchClaudeUsage(auth.token, timeoutMs, fetchFn));
+            continue;
+        }
+        if (auth.provider === "minimax") {
+            snapshots.push(await fetchMinimaxUsage(auth.token, timeoutMs, fetchFn));
+            continue;
+        }
+        if (auth.provider === "zai") {
+            snapshots.push(await fetchZaiUsage(auth.token, timeoutMs, fetchFn));
+            continue;
+        }
+        snapshots.push({
+            provider: auth.provider,
+            displayName: PROVIDER_LABELS[auth.provider],
+            windows: [],
+            error: "Usage not supported",
+        });
+    }
+    return { updatedAt: now, providers: snapshots };
+}
+export function formatUsageSummaryLine(summary, opts = {}) {
+    const providers = summary.providers ?? [];
+    let best;
+    for (const provider of providers) {
+        for (const window of provider.windows) {
+            if (!best || window.usedPercent > best.window.usedPercent) {
+                best = { provider, window };
+            }
+        }
+    }
+    if (!best)
+        return null;
+    const remaining = Math.max(0, 100 - best.window.usedPercent);
+    const label = best.window.label ? ` (${best.window.label}` : "";
+    const suffix = best.window.label ? ")" : "";
+    return `${best.provider.displayName}: ${remaining}% left${label}${suffix}`;
+}
+export function formatUsageReportLines(summary, opts = {}) {
+    const now = opts.now ?? Date.now();
+    const lines = [];
+    for (const provider of summary.providers ?? []) {
+        if (provider.error) {
+            lines.push(`${provider.displayName}: ${provider.error}`);
+            continue;
+        }
+        if (!provider.windows || provider.windows.length === 0) {
+            lines.push(`${provider.displayName}: no usage data`);
+            continue;
+        }
+        for (const window of provider.windows) {
+            const remaining = Math.max(0, 100 - window.usedPercent);
+            const reset = window.resetAt ? formatResetLabel(window.resetAt, now) : null;
+            const extras = [provider.plan ? `plan ${provider.plan}` : null, reset]
+                .filter(Boolean)
+                .join(", ");
+            const suffix = extras ? ` (${extras})` : "";
+            lines.push(`${provider.displayName} ${window.label}: ${remaining}% left${suffix}`);
+        }
+    }
+    return lines;
+}

package/dist/infra/provider-usage.load.js

@@ -0,0 +1,54 @@
+import { resolveProviderAuths } from "./provider-usage.auth.js";
+import { fetchClaudeUsage, fetchCodexUsage, fetchCopilotUsage, fetchGeminiUsage, fetchMinimaxUsage, fetchZaiUsage, } from "./provider-usage.fetch.js";
+import { DEFAULT_TIMEOUT_MS, ignoredErrors, PROVIDER_LABELS, usageProviders, withTimeout, } from "./provider-usage.shared.js";
+export async function loadProviderUsageSummary(opts = {}) {
+    const now = opts.now ?? Date.now();
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const fetchFn = opts.fetch ?? fetch;
+    const auths = await resolveProviderAuths({
+        providers: opts.providers ?? usageProviders,
+        auth: opts.auth,
+        agentDir: opts.agentDir,
+    });
+    if (auths.length === 0) {
+        return { updatedAt: now, providers: [] };
+    }
+    const tasks = auths.map((auth) => withTimeout((async () => {
+        switch (auth.provider) {
+            case "anthropic":
+                return await fetchClaudeUsage(auth.token, timeoutMs, fetchFn);
+            case "github-copilot":
+                return await fetchCopilotUsage(auth.token, timeoutMs, fetchFn);
+            case "google-gemini-cli":
+            case "google-antigravity":
+                return await fetchGeminiUsage(auth.token, timeoutMs, fetchFn, auth.provider);
+            case "openai-codex":
+                return await fetchCodexUsage(auth.token, auth.accountId, timeoutMs, fetchFn);
+            case "minimax":
+                return await fetchMinimaxUsage(auth.token, timeoutMs, fetchFn);
+            case "zai":
+                return await fetchZaiUsage(auth.token, timeoutMs, fetchFn);
+            default:
+                return {
+                    provider: auth.provider,
+                    displayName: PROVIDER_LABELS[auth.provider],
+                    windows: [],
+                    error: "Unsupported provider",
+                };
+        }
+    })(), timeoutMs + 1000, {
+        provider: auth.provider,
+        displayName: PROVIDER_LABELS[auth.provider],
+        windows: [],
+        error: "Timeout",
+    }));
+    const snapshots = await Promise.all(tasks);
+    const providers = snapshots.filter((entry) => {
+        if (entry.windows.length > 0)
+            return true;
+        if (!entry.error)
+            return true;
+        return !ignoredErrors.has(entry.error);
+    });
+    return { updatedAt: now, providers };
+}

package/dist/infra/provider-usage.shared.js

@@ -0,0 +1,19 @@
+export const PROVIDER_LABELS = {
+    anthropic: "Claude",
+    minimax: "MiniMax",
+    zai: "Z.ai",
+    "openai-codex": "Codex",
+    "github-copilot": "Copilot",
+    "google-gemini-cli": "Gemini",
+    "google-antigravity": "Antigravity",
+};
+export function clampPercent(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    const rounded = Math.round(value);
+    if (rounded < 0)
+        return 0;
+    if (rounded > 100)
+        return 100;
+    return rounded;
+}

package/dist/infra/provider-usage.types.js

@@ -0,0 +1 @@
+export {};

package/dist/infra/restart.js

@@ -0,0 +1,29 @@
+import { spawnSync } from "node:child_process";
+const DEFAULT_LAUNCHD_LABEL = "com.nexus.mac";
+const DEFAULT_SYSTEMD_UNIT = "nexus-gateway.service";
+export function triggerNexusRestart() {
+    if (process.platform !== "darwin") {
+        if (process.platform === "linux") {
+            const unit = process.env.NEXUS_SYSTEMD_UNIT || process.env.NEXUS_SYSTEMD_UNIT || DEFAULT_SYSTEMD_UNIT;
+            const userRestart = spawnSync("systemctl", ["--user", "restart", unit], {
+                stdio: "ignore",
+            });
+            if (!userRestart.error && userRestart.status === 0) {
+                return "systemd";
+            }
+            const systemRestart = spawnSync("systemctl", ["restart", unit], {
+                stdio: "ignore",
+            });
+            if (!systemRestart.error && systemRestart.status === 0) {
+                return "systemd";
+            }
+            return "systemd";
+        }
+        return "supervisor";
+    }
+    const label = process.env.NEXUS_LAUNCHD_LABEL || process.env.NEXUS_LAUNCHD_LABEL || DEFAULT_LAUNCHD_LABEL;
+    const uid = typeof process.getuid === "function" ? process.getuid() : undefined;
+    const target = uid !== undefined ? `gui/${uid}/${label}` : label;
+    spawnSync("launchctl", ["kickstart", "-k", target], { stdio: "ignore" });
+    return "launchctl";
+}

package/dist/infra/retry.js

@@ -0,0 +1,16 @@
+export async function retryAsync(fn, attempts = 3, initialDelayMs = 300) {
+    let lastErr;
+    for (let i = 0; i < attempts; i += 1) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastErr = err;
+            if (i === attempts - 1)
+                break;
+            const delay = initialDelayMs * 2 ** i;
+            await new Promise((r) => setTimeout(r, delay));
+        }
+    }
+    throw lastErr;
+}

package/dist/infra/runtime-guard.js

@@ -0,0 +1,59 @@
+import process from "node:process";
+import { defaultRuntime } from "../runtime.js";
+const MIN_NODE = { major: 22, minor: 0, patch: 0 };
+const SEMVER_RE = /(\d+)\.(\d+)\.(\d+)/;
+export function parseSemver(version) {
+    if (!version)
+        return null;
+    const match = version.match(SEMVER_RE);
+    if (!match)
+        return null;
+    const [, major, minor, patch] = match;
+    return {
+        major: Number.parseInt(major, 10),
+        minor: Number.parseInt(minor, 10),
+        patch: Number.parseInt(patch, 10),
+    };
+}
+export function isAtLeast(version, minimum) {
+    if (!version)
+        return false;
+    if (version.major !== minimum.major)
+        return version.major > minimum.major;
+    if (version.minor !== minimum.minor)
+        return version.minor > minimum.minor;
+    return version.patch >= minimum.patch;
+}
+export function detectRuntime() {
+    const kind = process.versions?.node ? "node" : "unknown";
+    const version = process.versions?.node ?? null;
+    return {
+        kind,
+        version,
+        execPath: process.execPath ?? null,
+        pathEnv: process.env.PATH ?? "(not set)",
+    };
+}
+export function runtimeSatisfies(details) {
+    const parsed = parseSemver(details.version);
+    if (details.kind === "node")
+        return isAtLeast(parsed, MIN_NODE);
+    return false;
+}
+export function assertSupportedRuntime(runtime = defaultRuntime, details = detectRuntime()) {
+    if (runtimeSatisfies(details))
+        return;
+    const versionLabel = details.version ?? "unknown";
+    const runtimeLabel = details.kind === "unknown"
+        ? "unknown runtime"
+        : `${details.kind} ${versionLabel}`;
+    const execLabel = details.execPath ?? "unknown";
+    runtime.error([
+        "nexus requires Node >=22.0.0.",
+        `Detected: ${runtimeLabel} (exec: ${execLabel}).`,
+        `PATH searched: ${details.pathEnv}`,
+        "Install Node: https://nodejs.org/en/download",
+        "Upgrade Node and re-run nexus.",
+    ].join("\n"));
+    runtime.exit(1);
+}

package/dist/infra/shell-env.js

@@ -0,0 +1,88 @@
+import { execFileSync } from "node:child_process";
+const DEFAULT_TIMEOUT_MS = 15_000;
+const DEFAULT_MAX_BUFFER_BYTES = 2 * 1024 * 1024;
+let lastAppliedKeys = [];
+function isTruthy(raw) {
+    if (!raw)
+        return false;
+    const value = raw.trim().toLowerCase();
+    return value === "1" || value === "true" || value === "yes" || value === "on";
+}
+function resolveShell(env) {
+    const shell = env.SHELL?.trim();
+    return shell && shell.length > 0 ? shell : "/bin/sh";
+}
+export function loadShellEnvFallback(opts) {
+    const logger = opts.logger ?? console;
+    const exec = opts.exec ?? execFileSync;
+    if (!opts.enabled) {
+        lastAppliedKeys = [];
+        return { ok: true, applied: [], skippedReason: "disabled" };
+    }
+    const hasAnyKey = opts.expectedKeys.some((key) => Boolean(opts.env[key]?.trim()));
+    if (hasAnyKey) {
+        lastAppliedKeys = [];
+        return { ok: true, applied: [], skippedReason: "already-has-keys" };
+    }
+    const timeoutMs = typeof opts.timeoutMs === "number" && Number.isFinite(opts.timeoutMs)
+        ? Math.max(0, opts.timeoutMs)
+        : DEFAULT_TIMEOUT_MS;
+    const shell = resolveShell(opts.env);
+    let stdout;
+    try {
+        stdout = exec(shell, ["-l", "-c", "env -0"], {
+            encoding: "buffer",
+            timeout: timeoutMs,
+            maxBuffer: DEFAULT_MAX_BUFFER_BYTES,
+            env: opts.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.warn(`[nexus] shell env fallback failed: ${msg}`);
+        lastAppliedKeys = [];
+        return { ok: false, error: msg, applied: [] };
+    }
+    const shellEnv = new Map();
+    const parts = stdout.toString("utf8").split("\0");
+    for (const part of parts) {
+        if (!part)
+            continue;
+        const eq = part.indexOf("=");
+        if (eq <= 0)
+            continue;
+        const key = part.slice(0, eq);
+        const value = part.slice(eq + 1);
+        if (!key)
+            continue;
+        shellEnv.set(key, value);
+    }
+    const applied = [];
+    for (const key of opts.expectedKeys) {
+        if (opts.env[key]?.trim())
+            continue;
+        const value = shellEnv.get(key);
+        if (!value?.trim())
+            continue;
+        opts.env[key] = value;
+        applied.push(key);
+    }
+    lastAppliedKeys = applied;
+    return { ok: true, applied };
+}
+export function shouldEnableShellEnvFallback(env) {
+    return isTruthy(env.NEXUS_LOAD_SHELL_ENV ?? env.NEXUS_LOAD_SHELL_ENV);
+}
+export function resolveShellEnvFallbackTimeoutMs(env) {
+    const raw = (env.NEXUS_SHELL_ENV_TIMEOUT_MS ?? env.NEXUS_SHELL_ENV_TIMEOUT_MS)?.trim();
+    if (!raw)
+        return DEFAULT_TIMEOUT_MS;
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed))
+        return DEFAULT_TIMEOUT_MS;
+    return Math.max(0, parsed);
+}
+export function getShellEnvAppliedKeys() {
+    return [...lastAppliedKeys];
+}

package/dist/infra/system-events.js

@@ -0,0 +1,71 @@
+// Lightweight in-memory queue for human-readable system events that should be
+// prefixed to the next prompt. We intentionally avoid persistence to keep
+// events ephemeral. Events are session-scoped; callers that don't specify a
+// session key default to "main".
+const DEFAULT_SESSION_KEY = "main";
+const MAX_EVENTS = 20;
+const queues = new Map();
+function normalizeSessionKey(key) {
+    const trimmed = typeof key === "string" ? key.trim() : "";
+    return trimmed || DEFAULT_SESSION_KEY;
+}
+function normalizeContextKey(key) {
+    if (!key)
+        return null;
+    const trimmed = key.trim();
+    if (!trimmed)
+        return null;
+    return trimmed.toLowerCase();
+}
+export function isSystemEventContextChanged(contextKey, sessionKey) {
+    const key = normalizeSessionKey(sessionKey);
+    const existing = queues.get(key);
+    const normalized = normalizeContextKey(contextKey);
+    return normalized !== (existing?.lastContextKey ?? null);
+}
+export function enqueueSystemEvent(text, options) {
+    const key = normalizeSessionKey(options?.sessionKey);
+    const entry = queues.get(key) ??
+        (() => {
+            const created = {
+                queue: [],
+                lastText: null,
+                lastContextKey: null,
+            };
+            queues.set(key, created);
+            return created;
+        })();
+    const cleaned = text.trim();
+    if (!cleaned)
+        return;
+    entry.lastContextKey = normalizeContextKey(options?.contextKey);
+    if (entry.lastText === cleaned)
+        return; // skip consecutive duplicates
+    entry.lastText = cleaned;
+    entry.queue.push({ text: cleaned, ts: Date.now() });
+    if (entry.queue.length > MAX_EVENTS)
+        entry.queue.shift();
+}
+export function drainSystemEvents(sessionKey) {
+    const key = normalizeSessionKey(sessionKey);
+    const entry = queues.get(key);
+    if (!entry || entry.queue.length === 0)
+        return [];
+    const out = entry.queue.map((e) => e.text);
+    entry.queue.length = 0;
+    entry.lastText = null;
+    entry.lastContextKey = null;
+    queues.delete(key);
+    return out;
+}
+export function peekSystemEvents(sessionKey) {
+    const key = normalizeSessionKey(sessionKey);
+    return queues.get(key)?.queue.map((e) => e.text) ?? [];
+}
+export function hasSystemEvents(sessionKey) {
+    const key = normalizeSessionKey(sessionKey);
+    return (queues.get(key)?.queue.length ?? 0) > 0;
+}
+export function resetSystemEventsForTest() {
+    queues.clear();
+}