@intent-systems/nexus 2026.1.5-4 → 2026.1.5-8

package/dist/auto-reply/thinking.js

@@ -21,6 +21,8 @@ export function normalizeThinkLevel(raw) {
         "max",
     ].includes(key))
         return "high";
+    if (["xhigh", "x-high", "extra-high"].includes(key))
+        return "xhigh";
     if (["think"].includes(key))
         return "minimal";
     return undefined;
@@ -47,3 +49,16 @@ export function normalizeElevatedLevel(raw) {
         return "on";
     return undefined;
 }
+// Normalize reasoning visibility flags used to control <think> output.
+export function normalizeReasoningLevel(raw) {
+    if (!raw)
+        return undefined;
+    const key = raw.toLowerCase();
+    if (["off", "false", "no", "0"].includes(key))
+        return "off";
+    if (["on", "true", "yes", "1"].includes(key))
+        return "on";
+    if (["stream", "live"].includes(key))
+        return "stream";
+    return undefined;
+}

package/dist/browser/chrome.js

@@ -7,7 +7,7 @@ import { ensurePortAvailable } from "../infra/ports.js";
 import { createSubsystemLogger } from "../logging.js";
 import { CONFIG_DIR } from "../utils.js";
 import { normalizeCdpWsUrl } from "./cdp.js";
-import { DEFAULT_NEXUS_BROWSER_COLOR, DEFAULT_NEXUS_BROWSER_PROFILE_NAME } from "./constants.js";
+import { DEFAULT_NEXUS_BROWSER_COLOR, DEFAULT_NEXUS_BROWSER_PROFILE_NAME, } from "./constants.js";
 const log = createSubsystemLogger("browser").child("chrome");
 function exists(filePath) {
     try {

package/dist/browser/client.js

@@ -96,6 +96,8 @@ export async function browserSnapshot(baseUrl, opts) {
         q.set("targetId", opts.targetId);
     if (typeof opts.limit === "number")
         q.set("limit", String(opts.limit));
+    if (typeof opts.maxChars === "number")
+        q.set("maxChars", String(opts.maxChars));
     if (opts.profile)
         q.set("profile", opts.profile);
     return await fetchBrowserJson(`${baseUrl}/snapshot?${q.toString()}`, {

package/dist/browser/config.js

@@ -56,7 +56,8 @@ function ensureDefaultProfile(profiles, defaultColor, legacyCdpPort, derivedDefa
 }
 export function resolveBrowserConfig(cfg) {
     const enabled = cfg?.enabled ?? DEFAULT_NEXUS_BROWSER_ENABLED;
-    const envControlUrl = (process.env.NEXUS_BROWSER_CONTROL_URL ?? process.env.NEXUS_BROWSER_CONTROL_URL)?.trim();
+    const envControlUrl = (process.env.NEXUS_BROWSER_CONTROL_URL ??
+        process.env.NEXUS_BROWSER_CONTROL_URL)?.trim();
     const derivedControlPort = (() => {
         const raw = (process.env.NEXUS_GATEWAY_PORT ?? process.env.NEXUS_GATEWAY_PORT)?.trim();
         if (!raw)
@@ -69,7 +70,10 @@ export function resolveBrowserConfig(cfg) {
     const derivedControlUrl = derivedControlPort
         ? `http://127.0.0.1:${derivedControlPort}`
         : null;
-    const controlInfo = parseHttpUrl(cfg?.controlUrl ?? envControlUrl ?? derivedControlUrl ?? DEFAULT_NEXUS_BROWSER_CONTROL_URL, "browser.controlUrl");
+    const controlInfo = parseHttpUrl(cfg?.controlUrl ??
+        envControlUrl ??
+        derivedControlUrl ??
+        DEFAULT_NEXUS_BROWSER_CONTROL_URL, "browser.controlUrl");
     const controlPort = controlInfo.port;
     const defaultColor = normalizeHexColor(cfg?.color);
     const derivedCdpRange = deriveDefaultBrowserCdpPortRange(controlPort);

package/dist/browser/pw-tools-core.js

@@ -20,6 +20,9 @@ export async function snapshotAiViaPlaywright(opts) {
     const result = await maybe._snapshotForAI({
         timeout: Math.max(500, Math.min(60_000, Math.floor(opts.timeoutMs ?? 5000))),
         track: "response",
+        ...(typeof opts.maxChars === "number" && Number.isFinite(opts.maxChars)
+            ? { maxChars: Math.max(1, Math.floor(opts.maxChars)) }
+            : {}),
     });
     return { snapshot: String(result?.full ?? "") };
 }

package/dist/browser/routes/agent.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { ensureMediaDir, saveMediaBuffer } from "../../media/store.js";
 import { captureScreenshot, snapshotAria } from "../cdp.js";
+import { DEFAULT_AI_SNAPSHOT_MAX_CHARS } from "../constants.js";
 import { DEFAULT_BROWSER_SCREENSHOT_MAX_BYTES, DEFAULT_BROWSER_SCREENSHOT_MAX_SIDE, normalizeBrowserScreenshot, } from "../screenshot.js";
 import { getProfileContext, jsonError, toBoolean, toNumber, toStringArray, toStringOrEmpty, } from "./utils.js";
 const SELECTOR_UNSUPPORTED_MESSAGE = [
@@ -498,6 +499,18 @@ export function registerBrowserAgentRoutes(app, ctx) {
                     ? "ai"
                     : "aria";
         const limit = typeof req.query.limit === "string" ? Number(req.query.limit) : undefined;
+        const maxCharsRaw = typeof req.query.maxChars === "string" ||
+            typeof req.query.maxChars === "number"
+            ? Number(req.query.maxChars)
+            : undefined;
+        const maxChars = format === "ai" &&
+            typeof maxCharsRaw === "number" &&
+            Number.isFinite(maxCharsRaw) &&
+            maxCharsRaw > 0
+            ? Math.floor(maxCharsRaw)
+            : format === "ai"
+                ? DEFAULT_AI_SNAPSHOT_MAX_CHARS
+                : undefined;
         try {
             const tab = await profileCtx.ensureTabAvailable(targetId || undefined);
             if (format === "ai") {
@@ -507,6 +520,7 @@ export function registerBrowserAgentRoutes(app, ctx) {
                 const snap = await pw.snapshotAiViaPlaywright({
                     cdpUrl: profileCtx.profile.cdpUrl,
                     targetId: tab.targetId,
+                    maxChars,
                 });
                 return res.json({
                     ok: true,

package/dist/canvas-host/server.js

@@ -126,7 +126,7 @@ async function resolveFilePath(rootReal, urlPath) {
     }
 }
 function isDisabledByEnv() {
-    if (process.env.NEXUS_SKIP_CANVAS_HOST === "1" || process.env.NEXUS_SKIP_CANVAS_HOST === "1")
+    if (process.env.NEXUS_SKIP_CANVAS_HOST === "1")
         return true;
     if (process.env.NODE_ENV === "test")
         return true;

package/dist/capabilities/detector.js

@@ -1,10 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
+import { getSkillMetadata, isConfigPathTruthy, loadWorkspaceSkillEntries, resolveRuntimePlatform, resolveSkillConfig, } from "../agents/skills.js";
 import { loadConfig } from "../config/config.js";
-import { resolveStateDir } from "../config/paths.js";
-import { getSkillMetadata, isConfigPathTruthy, loadWorkspaceSkillEntries, resolveSkillConfig, resolveRuntimePlatform, } from "../agents/skills.js";
 import { ensureCredentialIndexSync } from "../credentials/store.js";
-import { NEXUS_ROOT } from "../utils.js";
+import { NEXUS_ROOT, SKILLS_STATE_DIR } from "../utils.js";
 import { loadCapabilityRegistry } from "./registry.js";
 const STATUS_PRIORITY = [
     "active",
@@ -58,7 +57,7 @@ function setupLooksCredentialed(raw) {
         lowered.includes("key"));
 }
 function detectSkillUsageActive(skillName) {
-    const usageLog = path.join(resolveStateDir(), "nexus", "skills", skillName, "usage.log");
+    const usageLog = path.join(SKILLS_STATE_DIR, skillName, "usage.log");
     try {
         const stat = fs.statSync(usageLog);
         return stat.isFile() && stat.size > 0;
@@ -67,7 +66,7 @@ function detectSkillUsageActive(skillName) {
         return false;
     }
 }
-function resolveSkillType(skillName, metadata) {
+function resolveSkillType(_skillName, metadata) {
     if (metadata?.type)
         return metadata.type;
     const requires = metadata?.requires;
@@ -78,11 +77,16 @@ function resolveSkillType(skillName, metadata) {
     return "guide";
 }
 function resolveSkillProviderStatus(params) {
-    const { skillName, providerId, config, credentialServices, metadata, setupHint } = params;
+    const { skillName, providerId, config, credentialServices, metadata, setupHint, } = params;
     const platform = resolveRuntimePlatform();
     const skillType = resolveSkillType(skillName, metadata);
     if (metadata?.os?.length && !metadata.os.includes(platform)) {
-        return { id: providerId, kind: "skill", status: "unavailable", reason: "os" };
+        return {
+            id: providerId,
+            kind: "skill",
+            status: "unavailable",
+            reason: "os",
+        };
     }
     const skillKey = metadata?.skillKey ?? skillName;
     const skillConfig = resolveSkillConfig(config, skillKey);
@@ -108,15 +112,27 @@ function resolveSkillProviderStatus(params) {
         return true;
     });
     if (missingEnv.length > 0) {
-        return { id: providerId, kind: "skill", status: "needs_setup", reason: "missing_env" };
+        return {
+            id: providerId,
+            kind: "skill",
+            status: "needs_setup",
+            reason: "missing_env",
+        };
     }
     const missingConfig = (requires?.config ?? []).filter((configPath) => !isConfigPathTruthy(config, configPath));
     if (missingConfig.length > 0) {
-        return { id: providerId, kind: "skill", status: "needs_setup", reason: "missing_config" };
+        return {
+            id: providerId,
+            kind: "skill",
+            status: "needs_setup",
+            reason: "missing_config",
+        };
     }
     const credentialHints = requires?.credentials ?? [];
     const requiresCredential = setupLooksCredentialed(setupHint ?? "");
-    if (skillType === "connector" || credentialHints.length > 0 || requiresCredential) {
+    if (skillType === "connector" ||
+        credentialHints.length > 0 ||
+        requiresCredential) {
         const aliases = new Set();
         for (const entry of [providerId, ...credentialHints]) {
             for (const alias of resolveCredentialAliases(entry))
@@ -124,7 +140,12 @@ function resolveSkillProviderStatus(params) {
         }
         const hasCred = Array.from(aliases).some((alias) => credentialServices.has(alias));
         if (!hasCred) {
-            return { id: providerId, kind: "skill", status: "needs_setup", reason: "missing_credentials" };
+            return {
+                id: providerId,
+                kind: "skill",
+                status: "needs_setup",
+                reason: "missing_credentials",
+            };
         }
     }
     if (detectSkillUsageActive(skillName)) {
@@ -162,7 +183,9 @@ export function detectCapabilities(params) {
         const metadata = getSkillMetadata(entry);
         const key = normalizeProviderId(metadata?.skillKey ?? entry.skill.name);
         skillMap.set(key, { name: entry.skill.name, metadata });
-        const provides = (metadata?.provides ?? []).map((cap) => cap.trim()).filter(Boolean);
+        const provides = (metadata?.provides ?? [])
+            .map((cap) => cap.trim())
+            .filter(Boolean);
         for (const capId of provides) {
             const normalizedCap = capId.trim();
             if (!normalizedCap)
@@ -176,7 +199,10 @@ export function detectCapabilities(params) {
     const capabilities = [];
     for (const capability of registry.all) {
         const extraProviders = providesMap.get(capability.id) ?? [];
-        const providerList = Array.from(new Set([...capability.providers.map(normalizeProviderId), ...extraProviders]));
+        const providerList = Array.from(new Set([
+            ...capability.providers.map(normalizeProviderId),
+            ...extraProviders,
+        ]));
         const providerStatuses = [];
         for (const provider of providerList) {
             const normalized = normalizeProviderId(provider);
@@ -195,7 +221,11 @@ export function detectCapabilities(params) {
                 providerStatuses.push(resolveCredentialProviderStatus(normalized, credentialServices));
             }
             else {
-                providerStatuses.push({ id: normalized, kind: "unknown", status: "unavailable" });
+                providerStatuses.push({
+                    id: normalized,
+                    kind: "unknown",
+                    status: "unavailable",
+                });
             }
         }
         const status = pickBestStatus(providerStatuses.map((p) => p.status));
@@ -206,7 +236,8 @@ export function detectCapabilities(params) {
         active: capabilities.filter((c) => c.status === "active").length,
         ready: capabilities.filter((c) => c.status === "ready").length,
         needs_setup: capabilities.filter((c) => c.status === "needs_setup").length,
-        needs_install: capabilities.filter((c) => c.status === "needs_install").length,
+        needs_install: capabilities.filter((c) => c.status === "needs_install")
+            .length,
         unavailable: capabilities.filter((c) => c.status === "unavailable").length,
         broken: capabilities.filter((c) => c.status === "broken").length,
     };

package/dist/capabilities/registry.js

@@ -70,7 +70,8 @@ export function loadCapabilityRegistry() {
     for (const line of lines) {
         const headingMatch = line.match(/^###\s+(.+)$/);
         if (headingMatch) {
-            currentCategory = headingMatch[1]?.replace(/^[-–]\s*/, "").trim() || currentCategory;
+            currentCategory =
+                headingMatch[1]?.replace(/^[-–]\s*/, "").trim() || currentCategory;
             continue;
         }
         const tableMatch = line.match(/^\|\s*`([^`]+)`\s*\|\s*([^|]+)\|\s*([^|]+)\|\s*([^|]+)\|/);

package/dist/cli/cloud-cli.js

@@ -1,10 +1,11 @@
+import { spawn } from "node:child_process";
+import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import crypto from "node:crypto";
-import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
 import { scanCredentials } from "../commands/credential.js";
 import { openUrl } from "../commands/onboard-helpers.js";
-import { storeKeychainSecret, writeCredentialRecord, } from "../credentials/store.js";
+import { resolveDefaultEnvVar, storeKeychainSecret, writeCredentialRecord, } from "../credentials/store.js";
 import { NEXUS_ROOT, sleep } from "../utils.js";
 const DEFAULT_CLOUD_TIMEOUT_MS = 120_000;
 const DEFAULT_CLOUD_POLL_MS = 2_000;
@@ -77,6 +78,7 @@ async function storeHubToken(params) {
             value: params.token,
         });
     }
+    let envVar;
     if (storedInKeychain) {
         record = {
             owner: "user",
@@ -86,17 +88,18 @@ async function storeHubToken(params) {
         };
     }
     else {
+        envVar = resolveDefaultEnvVar({ service, type: "token" });
+        process.env[envVar] = params.token;
         record = {
             owner: "user",
             type: "token",
             configuredAt: now,
-            storage: { provider: "plaintext" },
-            token: params.token,
+            storage: { provider: "env", var: envVar },
         };
     }
     await writeCredentialRecord(service, account, authId, record);
     await scanCredentials();
-    return { storedInKeychain, account };
+    return { storedInKeychain, account, envVar };
 }
 function parseCloudLoginArgs(args) {
     let baseUrl = getHubBaseUrl();
@@ -206,6 +209,56 @@ function resolveRepoRoot(argv1 = process.argv[1]) {
     }
     return null;
 }
+function resolveModuleRoot() {
+    try {
+        let dir = path.dirname(fileURLToPath(import.meta.url));
+        for (let i = 0; i < 6; i += 1) {
+            if (fs.existsSync(path.join(dir, "package.json")))
+                return dir;
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function resolvePackageRoot(argv1 = process.argv[1]) {
+    const moduleRoot = resolveModuleRoot();
+    if (moduleRoot)
+        return moduleRoot;
+    if (!argv1)
+        return null;
+    let normalized = path.resolve(argv1);
+    try {
+        normalized = fs.realpathSync(normalized);
+    }
+    catch {
+        // ignore
+    }
+    const parts = normalized.split(path.sep);
+    const distIndex = parts.lastIndexOf("dist");
+    if (distIndex !== -1) {
+        return parts.slice(0, distIndex).join(path.sep);
+    }
+    return null;
+}
+function resolveBundledCloudBinary(packageRoot) {
+    const ext = process.platform === "win32" ? ".exe" : "";
+    const platformId = `${process.platform}-${process.arch}`;
+    const candidates = [
+        path.join(packageRoot, "dist", "native", "nexus-cloud", platformId, `nexus-cloud-rs${ext}`),
+        path.join(packageRoot, "dist", "native", "nexus-cloud", `nexus-cloud-rs${ext}`),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
 function resolveCloudRunner(args) {
     const env = { ...process.env };
     if (!env.NEXUS_HOME && NEXUS_ROOT) {
@@ -215,6 +268,13 @@ function resolveCloudRunner(args) {
     if (override) {
         return { command: override, args, env };
     }
+    const packageRoot = resolvePackageRoot();
+    if (packageRoot) {
+        const bundled = resolveBundledCloudBinary(packageRoot);
+        if (bundled) {
+            return { command: bundled, args, env };
+        }
+    }
     const repoRoot = resolveRepoRoot();
     if (repoRoot) {
         const nativeRoot = path.join(repoRoot, "native", "nexus-cloud");
@@ -296,7 +356,10 @@ async function handleCloudLogin(rawArgs) {
     }
     console.log(stored.storedInKeychain
         ? "   Token stored in keychain"
-        : "   Token stored in plaintext credentials");
+        : `   Token stored in env var ${stored.envVar ?? ""}`.trim());
+    if (!stored.storedInKeychain && stored.envVar) {
+        console.log(`   Persist it in your shell: export ${stored.envVar}=...`);
+    }
     if (cloudUrl) {
         console.log(`   Cloud URL: ${cloudUrl}`);
     }