@intent-systems/nexus 2026.1.5-3

package/dist/infra/control-ui-assets.js

@@ -0,0 +1,112 @@
+import fs from "node:fs";
+import path from "node:path";
+import { runCommandWithTimeout } from "../process/exec.js";
+import { defaultRuntime } from "../runtime.js";
+export function resolveControlUiRepoRoot(argv1 = process.argv[1]) {
+    if (!argv1)
+        return null;
+    const normalized = path.resolve(argv1);
+    const parts = normalized.split(path.sep);
+    const srcIndex = parts.lastIndexOf("src");
+    if (srcIndex !== -1) {
+        const root = parts.slice(0, srcIndex).join(path.sep);
+        if (fs.existsSync(path.join(root, "ui", "vite.config.ts")))
+            return root;
+    }
+    let dir = path.dirname(normalized);
+    for (let i = 0; i < 8; i++) {
+        if (fs.existsSync(path.join(dir, "package.json")) &&
+            fs.existsSync(path.join(dir, "ui", "vite.config.ts"))) {
+            return dir;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+export function resolveControlUiDistIndexPath(argv1 = process.argv[1]) {
+    if (!argv1)
+        return null;
+    const normalized = path.resolve(argv1);
+    const distDir = path.dirname(normalized);
+    if (path.basename(distDir) !== "dist")
+        return null;
+    return path.join(distDir, "control-ui", "index.html");
+}
+function summarizeCommandOutput(text) {
+    const lines = text
+        .split(/\r?\n/g)
+        .map((l) => l.trim())
+        .filter(Boolean);
+    if (!lines.length)
+        return undefined;
+    const last = lines.at(-1);
+    if (!last)
+        return undefined;
+    return last.length > 240 ? `${last.slice(0, 239)}…` : last;
+}
+export async function ensureControlUiAssetsBuilt(runtime = defaultRuntime, opts) {
+    const indexFromDist = resolveControlUiDistIndexPath(process.argv[1]);
+    if (indexFromDist && fs.existsSync(indexFromDist)) {
+        return { ok: true, built: false };
+    }
+    const repoRoot = resolveControlUiRepoRoot(process.argv[1]);
+    if (!repoRoot) {
+        const hint = indexFromDist
+            ? `Missing Control UI assets at ${indexFromDist}`
+            : "Missing Control UI assets";
+        return {
+            ok: false,
+            built: false,
+            message: `${hint}. Build them with \`bun run ui:build\`.`,
+        };
+    }
+    const indexPath = path.join(repoRoot, "dist", "control-ui", "index.html");
+    if (fs.existsSync(indexPath)) {
+        return { ok: true, built: false };
+    }
+    const uiScript = path.join(repoRoot, "scripts", "ui.js");
+    if (!fs.existsSync(uiScript)) {
+        return {
+            ok: false,
+            built: false,
+            message: `Control UI assets missing but ${uiScript} is unavailable.`,
+        };
+    }
+    runtime.log("Control UI assets missing; building (ui:build)…");
+    const ensureInstalled = !fs.existsSync(path.join(repoRoot, "ui", "node_modules"));
+    if (ensureInstalled) {
+        const install = await runCommandWithTimeout([process.execPath, uiScript, "install"], {
+            cwd: repoRoot,
+            timeoutMs: opts?.timeoutMs ?? 10 * 60_000,
+        });
+        if (install.code !== 0) {
+            return {
+                ok: false,
+                built: false,
+                message: `Control UI install failed: ${summarizeCommandOutput(install.stderr) ?? `exit ${install.code}`}`,
+            };
+        }
+    }
+    const build = await runCommandWithTimeout([process.execPath, uiScript, "build"], {
+        cwd: repoRoot,
+        timeoutMs: opts?.timeoutMs ?? 10 * 60_000,
+    });
+    if (build.code !== 0) {
+        return {
+            ok: false,
+            built: false,
+            message: `Control UI build failed: ${summarizeCommandOutput(build.stderr) ?? `exit ${build.code}`}`,
+        };
+    }
+    if (!fs.existsSync(indexPath)) {
+        return {
+            ok: false,
+            built: true,
+            message: `Control UI build completed but ${indexPath} is still missing.`,
+        };
+    }
+    return { ok: true, built: true };
+}

package/dist/infra/dotenv.js

@@ -0,0 +1,15 @@
+import fs from "node:fs";
+import path from "node:path";
+import dotenv from "dotenv";
+import { resolveConfigDir } from "../utils.js";
+export function loadDotEnv(opts) {
+    const quiet = opts?.quiet ?? true;
+    // Load from process CWD first (dotenv default).
+    dotenv.config({ quiet });
+    // Then load global fallback: ~/nexus/state/.env (or NEXUS_STATE_DIR/.env),
+    // without overriding any env vars already present.
+    const globalEnvPath = path.join(resolveConfigDir(process.env), ".env");
+    if (!fs.existsSync(globalEnvPath))
+        return;
+    dotenv.config({ quiet, path: globalEnvPath, override: false });
+}

package/dist/infra/env.js

@@ -0,0 +1,8 @@
+export function normalizeZaiEnv() {
+    if (!process.env.ZAI_API_KEY?.trim() && process.env.Z_AI_API_KEY?.trim()) {
+        process.env.ZAI_API_KEY = process.env.Z_AI_API_KEY;
+    }
+}
+export function normalizeEnv() {
+    normalizeZaiEnv();
+}

package/dist/infra/errors.js

@@ -0,0 +1,28 @@
+export function extractErrorCode(err) {
+    if (!err || typeof err !== "object")
+        return undefined;
+    const code = err.code;
+    if (typeof code === "string")
+        return code;
+    if (typeof code === "number")
+        return String(code);
+    return undefined;
+}
+export function formatErrorMessage(err) {
+    if (err instanceof Error) {
+        return err.message || err.name || "Error";
+    }
+    if (typeof err === "string")
+        return err;
+    if (typeof err === "number" ||
+        typeof err === "boolean" ||
+        typeof err === "bigint") {
+        return String(err);
+    }
+    try {
+        return JSON.stringify(err);
+    }
+    catch {
+        return Object.prototype.toString.call(err);
+    }
+}

package/dist/infra/event-log.js

@@ -0,0 +1,251 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { resolveStateDir } from "../config/paths.js";
+import { VERSION } from "../version.js";
+import { onAgentEvent } from "./agent-events.js";
+const EVENT_SCHEMA_VERSION = 1;
+const EVENT_LOG_ENV = "NEXUS_EVENT_LOG";
+const EVENT_LOG_DIR_ENV = "NEXUS_EVENT_LOG_DIR";
+let cliSession = null;
+let agentListenerRegistered = false;
+function isEventLogEnabled(env = process.env) {
+    const raw = env[EVENT_LOG_ENV]?.trim().toLowerCase();
+    if (!raw)
+        return true;
+    return !(raw === "0" || raw === "false" || raw === "off");
+}
+function resolveUserPath(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return trimmed;
+    if (trimmed.startsWith("~")) {
+        return path.resolve(trimmed.replace("~", os.homedir()));
+    }
+    return path.resolve(trimmed);
+}
+export function resolveEventLogDir(env = process.env) {
+    const override = env[EVENT_LOG_DIR_ENV]?.trim();
+    if (override)
+        return resolveUserPath(override);
+    return path.join(resolveStateDir(env), "events");
+}
+function resolveEventLogPath(ts) {
+    const dir = resolveEventLogDir();
+    const date = new Date(ts).toISOString().slice(0, 10);
+    return path.join(dir, `events-${date}.jsonl`);
+}
+function writeEvent(entry) {
+    if (!isEventLogEnabled())
+        return;
+    try {
+        const file = resolveEventLogPath(entry.ts);
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        const line = JSON.stringify({
+            ...entry,
+            schema_version: EVENT_SCHEMA_VERSION,
+        });
+        fs.appendFileSync(file, `${line}\n`, { encoding: "utf8" });
+    }
+    catch {
+        // never block on logging failures
+    }
+}
+function nextCliSeq() {
+    if (!cliSession)
+        return 0;
+    cliSession.seq += 1;
+    return cliSession.seq;
+}
+function sanitizeArgv(argv) {
+    const redactFlags = new Set([
+        "--token",
+        "--password",
+        "--api-key",
+        "--apikey",
+        "--secret",
+        "--key",
+        "--auth",
+        "--bearer",
+        "--cookie",
+    ]);
+    const out = [];
+    let skipNext = false;
+    for (const token of argv) {
+        if (skipNext) {
+            out.push("<redacted>");
+            skipNext = false;
+            continue;
+        }
+        const lower = token.toLowerCase();
+        if (redactFlags.has(lower)) {
+            out.push(token);
+            skipNext = true;
+            continue;
+        }
+        const eqIdx = token.indexOf("=");
+        if (eqIdx > 0) {
+            const key = token.slice(0, eqIdx).toLowerCase();
+            if (redactFlags.has(key)) {
+                out.push(`${token.slice(0, eqIdx)}=<redacted>`);
+                continue;
+            }
+        }
+        out.push(token);
+    }
+    return out;
+}
+function normalizeOptions(options) {
+    if (!options)
+        return undefined;
+    const out = {};
+    for (const [key, value] of Object.entries(options)) {
+        if (typeof value === "boolean") {
+            out[key] = value;
+            continue;
+        }
+        if (value === undefined || value === null) {
+            out[key] = value;
+            continue;
+        }
+        out[key] = "<set>";
+    }
+    return out;
+}
+function createEventId() {
+    return crypto.randomUUID();
+}
+function deriveInvocationKind(argv) {
+    if (argv.length === 0)
+        return undefined;
+    const bin = path.basename(argv[0] ?? "");
+    const entry = argv[1] ?? "";
+    if (bin === "bun" && entry.includes("src/entry.ts"))
+        return "bun_dev";
+    if (bin === "node" && entry.includes("dist/entry.js"))
+        return "node_dist";
+    if (entry.includes("dist/entry.js"))
+        return "node_dist";
+    if (entry.includes("src/entry.ts"))
+        return "node_dev";
+    if (bin.startsWith("nexus"))
+        return "binary";
+    return undefined;
+}
+export function initCliEventLogSession(params) {
+    if (!isEventLogEnabled())
+        return null;
+    const sessionId = createEventId();
+    const source = params.source?.trim() || "nexus_cli";
+    const invocationKind = deriveInvocationKind(params.argv);
+    cliSession = {
+        id: sessionId,
+        source,
+        seq: 0,
+        cwd: params.cwd,
+        argv: sanitizeArgv(params.argv),
+        invocationKind,
+    };
+    writeEvent({
+        id: createEventId(),
+        ts: Date.now(),
+        seq: nextCliSeq(),
+        session_id: sessionId,
+        source,
+        event_type: "cli_session_start",
+        invocation_kind: invocationKind,
+        argv: cliSession.argv,
+        cwd: params.cwd,
+        status: "ok",
+        data: { version: VERSION, node: process.version },
+    });
+    return sessionId;
+}
+export function recordCliCommandStart(ctx) {
+    if (!cliSession)
+        return;
+    cliSession.activeCommand = ctx;
+    writeEvent({
+        id: createEventId(),
+        ts: Date.now(),
+        seq: nextCliSeq(),
+        session_id: cliSession.id,
+        source: cliSession.source,
+        event_type: "command_started",
+        command_path: ctx.commandPath,
+        invocation_kind: cliSession.invocationKind,
+        data: {
+            args: ctx.args,
+            options: normalizeOptions(ctx.options),
+        },
+    });
+}
+export function recordCliCommandFinish(status = "ok") {
+    if (!cliSession?.activeCommand)
+        return;
+    writeEvent({
+        id: createEventId(),
+        ts: Date.now(),
+        seq: nextCliSeq(),
+        session_id: cliSession.id,
+        source: cliSession.source,
+        event_type: "command_finished",
+        command_path: cliSession.activeCommand.commandPath,
+        invocation_kind: cliSession.invocationKind,
+        status,
+    });
+    cliSession.activeCommand = undefined;
+}
+export function recordCliCommandFailure(error) {
+    if (!cliSession?.activeCommand)
+        return;
+    const message = error instanceof Error ? error.message : typeof error === "string" ? error : "unknown error";
+    writeEvent({
+        id: createEventId(),
+        ts: Date.now(),
+        seq: nextCliSeq(),
+        session_id: cliSession.id,
+        source: cliSession.source,
+        event_type: "command_failed",
+        command_path: cliSession.activeCommand.commandPath,
+        invocation_kind: cliSession.invocationKind,
+        status: "error",
+        error: message,
+    });
+}
+export function recordCliSessionEnd(params) {
+    if (!cliSession)
+        return;
+    writeEvent({
+        id: createEventId(),
+        ts: Date.now(),
+        seq: nextCliSeq(),
+        session_id: cliSession.id,
+        source: cliSession.source,
+        event_type: "cli_session_end",
+        invocation_kind: cliSession.invocationKind,
+        status: params.status,
+        error: params.error,
+        data: params.exitCode !== undefined ? { exit_code: params.exitCode } : undefined,
+    });
+    cliSession = null;
+}
+export function registerAgentEventLogListener() {
+    if (agentListenerRegistered || !isEventLogEnabled())
+        return;
+    agentListenerRegistered = true;
+    onAgentEvent((evt) => {
+        writeEvent({
+            id: createEventId(),
+            ts: evt.ts,
+            seq: evt.seq,
+            session_id: evt.runId,
+            source: "nexus_agent",
+            event_type: "agent_event",
+            stream: evt.stream,
+            run_id: evt.runId,
+            data: { ...evt.data, sessionKey: evt.sessionKey },
+        });
+    });
+}

package/dist/infra/gateway-lock.js

@@ -0,0 +1,8 @@
+export class GatewayLockError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "GatewayLockError";
+    }
+}

package/dist/infra/git-commit.js

@@ -0,0 +1,91 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+const formatCommit = (value) => {
+    if (!value)
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    return trimmed.length > 7 ? trimmed.slice(0, 7) : trimmed;
+};
+const resolveGitHead = (startDir) => {
+    let current = startDir;
+    for (let i = 0; i < 12; i += 1) {
+        const gitPath = path.join(current, ".git");
+        try {
+            const stat = fs.statSync(gitPath);
+            if (stat.isDirectory()) {
+                return path.join(gitPath, "HEAD");
+            }
+            if (stat.isFile()) {
+                const raw = fs.readFileSync(gitPath, "utf-8");
+                const match = raw.match(/gitdir:\s*(.+)/i);
+                if (match?.[1]) {
+                    const resolved = path.resolve(current, match[1].trim());
+                    return path.join(resolved, "HEAD");
+                }
+            }
+        }
+        catch {
+            // ignore missing .git at this level
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return null;
+};
+let cachedCommit;
+const readCommitFromPackageJson = () => {
+    try {
+        const require = createRequire(import.meta.url);
+        const pkg = require("../../package.json");
+        return formatCommit(pkg.gitHead ?? pkg.githead ?? null);
+    }
+    catch {
+        return null;
+    }
+};
+export const resolveCommitHash = (options = {}) => {
+    if (cachedCommit !== undefined)
+        return cachedCommit;
+    const env = options.env ?? process.env;
+    const envCommit = env.GIT_COMMIT?.trim() || env.GIT_SHA?.trim();
+    const normalized = formatCommit(envCommit);
+    if (normalized) {
+        cachedCommit = normalized;
+        return cachedCommit;
+    }
+    const pkgCommit = readCommitFromPackageJson();
+    if (pkgCommit) {
+        cachedCommit = pkgCommit;
+        return cachedCommit;
+    }
+    try {
+        const headPath = resolveGitHead(options.cwd ?? process.cwd());
+        if (!headPath) {
+            cachedCommit = null;
+            return cachedCommit;
+        }
+        const head = fs.readFileSync(headPath, "utf-8").trim();
+        if (!head) {
+            cachedCommit = null;
+            return cachedCommit;
+        }
+        if (head.startsWith("ref:")) {
+            const ref = head.replace(/^ref:\s*/i, "").trim();
+            const refPath = path.resolve(path.dirname(headPath), ref);
+            const refHash = fs.readFileSync(refPath, "utf-8").trim();
+            cachedCommit = formatCommit(refHash);
+            return cachedCommit;
+        }
+        cachedCommit = formatCommit(head);
+        return cachedCommit;
+    }
+    catch {
+        cachedCommit = null;
+        return cachedCommit;
+    }
+};

package/dist/infra/heartbeat-events.js

@@ -0,0 +1,21 @@
+let lastHeartbeat = null;
+const listeners = new Set();
+export function emitHeartbeatEvent(evt) {
+    const enriched = { ts: Date.now(), ...evt };
+    lastHeartbeat = enriched;
+    for (const listener of listeners) {
+        try {
+            listener(enriched);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+export function onHeartbeatEvent(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+export function getLastHeartbeatEvent() {
+    return lastHeartbeat;
+}