@intent-systems/nexus 2026.1.5-3 → 2026.1.5-5

package/dist/auto-reply/reply/directives.js

@@ -1,9 +1,9 @@
-import { normalizeElevatedLevel, normalizeThinkLevel, normalizeVerboseLevel, } from "../thinking.js";
+import { normalizeElevatedLevel, normalizeReasoningLevel, normalizeThinkLevel, normalizeVerboseLevel, } from "../thinking.js";
 export function extractThinkDirective(body) {
     if (!body)
         return { cleaned: "", hasDirective: false };
     // Match the longest keyword first to avoid partial captures (e.g. "/think:high")
-    const match = body.match(/(?:^|\s)\/(?:thinking|think|t)\s*:?\s*([a-zA-Z-]+)\b/i);
+    const match = body.match(/(?:^|\s)\/(?:thinking|think|t)(?=$|\s|:)\s*:?\s*([a-zA-Z-]+)?\b/i);
     const thinkLevel = normalizeThinkLevel(match?.[1]);
     const cleaned = match
         ? body.replace(match[0], "").replace(/\s+/g, " ").trim()
@@ -45,6 +45,21 @@ export function extractElevatedDirective(body) {
         hasDirective: !!match,
     };
 }
+export function extractReasoningDirective(body) {
+    if (!body)
+        return { cleaned: "", hasDirective: false };
+    const match = body.match(/(?:^|\s)\/(?:reasoning|reason)(?=$|\s|:)\s*:?\s*([a-zA-Z-]+)?\b/i);
+    const reasoningLevel = normalizeReasoningLevel(match?.[1]);
+    const cleaned = match
+        ? body.replace(match[0], "").replace(/\s+/g, " ").trim()
+        : body.trim();
+    return {
+        cleaned,
+        reasoningLevel,
+        rawLevel: match?.[1],
+        hasDirective: !!match,
+    };
+}
 export function extractStatusDirective(body) {
     if (!body)
         return { cleaned: "", hasDirective: false };

package/dist/auto-reply/reply/model-selection.js

@@ -122,7 +122,8 @@ export function resolveModelDirectiveSelection(params) {
             if (params.provider && provider !== normalizeProviderId(params.provider))
                 continue;
             const haystack = `${provider}/${model}`.toLowerCase();
-            if (haystack.includes(fragment) || model.toLowerCase().includes(fragment)) {
+            if (haystack.includes(fragment) ||
+                model.toLowerCase().includes(fragment)) {
                 candidates.push({ provider, model });
             }
         }
@@ -132,7 +133,10 @@ export function resolveModelDirectiveSelection(params) {
             for (const [aliasKey, entry] of aliasIndex.byAlias.entries()) {
                 if (!aliasKey.includes(fragment))
                     continue;
-                aliasMatches.push({ provider: entry.ref.provider, model: entry.ref.model });
+                aliasMatches.push({
+                    provider: entry.ref.provider,
+                    model: entry.ref.model,
+                });
             }
             for (const match of aliasMatches) {
                 const key = modelKey(match.provider, match.model);
@@ -176,7 +180,8 @@ export function resolveModelDirectiveSelection(params) {
     }
     const resolvedKey = modelKey(resolved.ref.provider, resolved.ref.model);
     if (allowedModelKeys.size === 0 || allowedModelKeys.has(resolvedKey)) {
-        const alias = resolved.alias ?? pickAliasForKey(resolved.ref.provider, resolved.ref.model);
+        const alias = resolved.alias ??
+            pickAliasForKey(resolved.ref.provider, resolved.ref.model);
         return {
             selection: {
                 provider: resolved.ref.provider,

package/dist/auto-reply/reply/queue.js

@@ -370,8 +370,8 @@ function defaultQueueModeForProvider(provider) {
 export function resolveQueueSettings(params) {
     const providerKey = params.provider?.trim().toLowerCase();
     const queueCfg = params.cfg.routing?.queue;
-    const providerModeRaw = providerKey && queueCfg?.byProvider
-        ? queueCfg.byProvider[providerKey]
+    const providerModeRaw = providerKey && queueCfg?.byChannel
+        ? queueCfg.byChannel[providerKey]
         : undefined;
     const resolvedMode = params.inlineMode ??
         normalizeQueueMode(params.sessionEntry?.queueMode) ??

package/dist/auto-reply/reply.js

@@ -35,7 +35,7 @@ export { extractElevatedDirective, extractThinkDirective, extractVerboseDirectiv
 export { extractQueueDirective } from "./reply/queue.js";
 export { extractReplyToTag } from "./reply/reply-tags.js";
 const BARE_SESSION_RESET_PROMPT = "A new session was started via /new or /reset. Say hi briefly (1-2 sentences) and ask what the user wants to do next. Do not mention internal steps, files, tools, or reasoning.";
-const CONTROL_COMMAND_PREFIX_RE = /^\/(?:status|help|thinking|think|t|verbose|v|elevated|elev|model|queue|activation|send|restart|reset|new|compact)\b/i;
+const CONTROL_COMMAND_PREFIX_RE = /^\/(?:status|help|thinking|think|t|reasoning|reason|verbose|v|elevated|elev|model|queue|activation|send|restart|reset|new|compact)\b/i;
 function normalizeAllowToken(value) {
     if (!value)
         return "";

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

@@ -0,0 +1,245 @@
+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 { ensureCredentialIndexSync } from "../credentials/store.js";
+import { MANAGED_SKILLS_DIR, NEXUS_ROOT } from "../utils.js";
+import { loadCapabilityRegistry } from "./registry.js";
+const STATUS_PRIORITY = [
+    "active",
+    "ready",
+    "needs_setup",
+    "needs_install",
+    "broken",
+    "unavailable",
+];
+function hasBinary(bin) {
+    const pathEnv = process.env.PATH ?? "";
+    const parts = pathEnv.split(path.delimiter).filter(Boolean);
+    for (const part of parts) {
+        const candidate = path.join(part, bin);
+        try {
+            fs.accessSync(candidate, fs.constants.X_OK);
+            return true;
+        }
+        catch {
+            // keep scanning
+        }
+    }
+    return false;
+}
+function normalizeProviderId(raw) {
+    return raw.trim().toLowerCase();
+}
+function resolveCredentialAliases(providerId) {
+    const base = providerId.replace(/-oauth$/, "");
+    const aliases = new Set([providerId, base]);
+    if (providerId === "gog") {
+        aliases.add("google");
+        aliases.add("google-oauth");
+    }
+    if (providerId === "google-oauth") {
+        aliases.add("google");
+        aliases.add("gog");
+    }
+    return Array.from(aliases).filter(Boolean);
+}
+function setupLooksCredentialed(raw) {
+    const lowered = raw.toLowerCase();
+    if (!lowered || lowered === "-" || lowered === "none")
+        return false;
+    return (lowered.includes("oauth") ||
+        lowered.includes("api key") ||
+        lowered.includes("apikey") ||
+        lowered.includes("token") ||
+        lowered.includes("account") ||
+        lowered.includes("bot") ||
+        lowered.includes("key"));
+}
+function detectSkillUsageActive(skillName) {
+    const usageLog = path.join(MANAGED_SKILLS_DIR, skillName, "usage.log");
+    try {
+        const stat = fs.statSync(usageLog);
+        return stat.isFile() && stat.size > 0;
+    }
+    catch {
+        return false;
+    }
+}
+function resolveSkillType(_skillName, metadata) {
+    if (metadata?.type)
+        return metadata.type;
+    const requires = metadata?.requires;
+    if (requires?.env?.length || requires?.config?.length)
+        return "connector";
+    if (requires?.bins?.length)
+        return "tool";
+    return "guide";
+}
+function resolveSkillProviderStatus(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",
+        };
+    }
+    const skillKey = metadata?.skillKey ?? skillName;
+    const skillConfig = resolveSkillConfig(config, skillKey);
+    const requires = metadata?.requires;
+    const missingBins = (requires?.bins ?? []).filter((bin) => !hasBinary(bin));
+    const anyBins = requires?.anyBins ?? [];
+    const anyBinsOk = anyBins.length === 0 || anyBins.some((bin) => hasBinary(bin));
+    if (missingBins.length > 0 || !anyBinsOk) {
+        return {
+            id: providerId,
+            kind: "skill",
+            status: "needs_install",
+            reason: missingBins.length > 0 ? "missing_bins" : "missing_any_bins",
+        };
+    }
+    const missingEnv = (requires?.env ?? []).filter((envName) => {
+        if (process.env[envName])
+            return false;
+        if (skillConfig?.env?.[envName])
+            return false;
+        if (skillConfig?.apiKey && metadata?.primaryEnv === envName)
+            return false;
+        return true;
+    });
+    if (missingEnv.length > 0) {
+        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",
+        };
+    }
+    const credentialHints = requires?.credentials ?? [];
+    const requiresCredential = setupLooksCredentialed(setupHint ?? "");
+    if (skillType === "connector" ||
+        credentialHints.length > 0 ||
+        requiresCredential) {
+        const aliases = new Set();
+        for (const entry of [providerId, ...credentialHints]) {
+            for (const alias of resolveCredentialAliases(entry))
+                aliases.add(alias);
+        }
+        const hasCred = Array.from(aliases).some((alias) => credentialServices.has(alias));
+        if (!hasCred) {
+            return {
+                id: providerId,
+                kind: "skill",
+                status: "needs_setup",
+                reason: "missing_credentials",
+            };
+        }
+    }
+    if (detectSkillUsageActive(skillName)) {
+        return { id: providerId, kind: "skill", status: "active" };
+    }
+    return { id: providerId, kind: "skill", status: "ready" };
+}
+function resolveCredentialProviderStatus(providerId, credentialServices) {
+    const aliases = resolveCredentialAliases(providerId);
+    const hasCredential = aliases.some((alias) => credentialServices.has(alias));
+    return {
+        id: providerId,
+        kind: "credential",
+        status: hasCredential ? "ready" : "needs_setup",
+        reason: hasCredential ? undefined : "missing_credentials",
+    };
+}
+function pickBestStatus(statuses) {
+    for (const status of STATUS_PRIORITY) {
+        if (statuses.includes(status))
+            return status;
+    }
+    return "unavailable";
+}
+export function detectCapabilities(params) {
+    const config = params?.config ?? loadConfig();
+    const workspaceDir = params?.workspaceDir ?? path.join(NEXUS_ROOT, "home");
+    const registry = params?.registry ?? loadCapabilityRegistry();
+    const credentialIndex = ensureCredentialIndexSync();
+    const credentialServices = new Set(Object.keys(credentialIndex.services ?? {}).map((name) => normalizeProviderId(name)));
+    const skillEntries = loadWorkspaceSkillEntries(workspaceDir, { config });
+    const skillMap = new Map();
+    const providesMap = new Map();
+    for (const entry of skillEntries) {
+        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);
+        for (const capId of provides) {
+            const normalizedCap = capId.trim();
+            if (!normalizedCap)
+                continue;
+            const existing = providesMap.get(normalizedCap) ?? [];
+            if (!existing.includes(key))
+                existing.push(key);
+            providesMap.set(normalizedCap, existing);
+        }
+    }
+    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 providerStatuses = [];
+        for (const provider of providerList) {
+            const normalized = normalizeProviderId(provider);
+            const skillEntry = skillMap.get(normalized);
+            if (skillEntry) {
+                providerStatuses.push(resolveSkillProviderStatus({
+                    skillName: skillEntry.name,
+                    providerId: normalized,
+                    config,
+                    credentialServices,
+                    metadata: skillEntry.metadata,
+                    setupHint: capability.setup,
+                }));
+            }
+            else if (resolveCredentialAliases(normalized).some((alias) => credentialServices.has(alias))) {
+                providerStatuses.push(resolveCredentialProviderStatus(normalized, credentialServices));
+            }
+            else {
+                providerStatuses.push({
+                    id: normalized,
+                    kind: "unknown",
+                    status: "unavailable",
+                });
+            }
+        }
+        const status = pickBestStatus(providerStatuses.map((p) => p.status));
+        capabilities.push({ ...capability, status, providers: providerStatuses });
+    }
+    const summary = {
+        total: capabilities.length,
+        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,
+        unavailable: capabilities.filter((c) => c.status === "unavailable").length,
+        broken: capabilities.filter((c) => c.status === "broken").length,
+    };
+    return { registry, capabilities, summary };
+}

package/dist/capabilities/registry.js

@@ -0,0 +1,99 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveUserPath } from "../utils.js";
+const CAPABILITIES_PATH = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../docs/CAPABILITIES.md");
+function resolveCapabilitiesPath() {
+    const candidates = [];
+    const override = process.env.NEXUS_CAPABILITIES_PATH?.trim();
+    if (override) {
+        candidates.push(resolveUserPath(override));
+    }
+    candidates.push(CAPABILITIES_PATH);
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        try {
+            if (fs.existsSync(candidate))
+                return candidate;
+        }
+        catch {
+            // ignore and keep searching
+        }
+    }
+    return null;
+}
+function normalizeProviderToken(raw) {
+    const normalized = raw
+        .replace(/\(.*?\)/g, "")
+        .replace(/\s+/g, " ")
+        .trim()
+        .toLowerCase();
+    if (normalized.endsWith(" guide")) {
+        return normalized.slice(0, -" guide".length).trim();
+    }
+    return normalized;
+}
+function parseProviders(raw) {
+    const cleaned = raw.replace(/\(.*?\)/g, "").trim();
+    if (!cleaned)
+        return [];
+    const parts = cleaned.split(/[,;+]/g).map((p) => p.trim());
+    const out = [];
+    for (const part of parts) {
+        if (!part)
+            continue;
+        const normalized = normalizeProviderToken(part);
+        if (!normalized)
+            continue;
+        if (!out.includes(normalized))
+            out.push(normalized);
+    }
+    return out;
+}
+export function loadCapabilityRegistry() {
+    const capabilitiesPath = resolveCapabilitiesPath();
+    if (!capabilitiesPath) {
+        return { categories: {}, all: [] };
+    }
+    let raw;
+    try {
+        raw = fs.readFileSync(capabilitiesPath, "utf-8");
+    }
+    catch {
+        return { categories: {}, all: [] };
+    }
+    const lines = raw.replace(/\r\n/g, "\n").split("\n");
+    let currentCategory = "Uncategorized";
+    const categories = {};
+    const all = [];
+    for (const line of lines) {
+        const headingMatch = line.match(/^###\s+(.+)$/);
+        if (headingMatch) {
+            currentCategory =
+                headingMatch[1]?.replace(/^[-–]\s*/, "").trim() || currentCategory;
+            continue;
+        }
+        const tableMatch = line.match(/^\|\s*`([^`]+)`\s*\|\s*([^|]+)\|\s*([^|]+)\|\s*([^|]+)\|/);
+        if (!tableMatch)
+            continue;
+        const [, idRaw, descriptionRaw, providersRaw, setupRaw] = tableMatch;
+        const id = (idRaw ?? "").trim();
+        if (!id)
+            continue;
+        const providersRawTrimmed = (providersRaw ?? "").trim();
+        const providers = parseProviders(providersRawTrimmed);
+        const capability = {
+            id,
+            description: (descriptionRaw ?? "").trim(),
+            providersRaw: providersRawTrimmed,
+            providers,
+            setup: (setupRaw ?? "").trim(),
+            category: currentCategory,
+        };
+        categories[currentCategory] = categories[currentCategory] ?? [];
+        categories[currentCategory].push(capability);
+        all.push(capability);
+    }
+    return { categories, all };
+}

package/dist/channels/location.js

@@ -0,0 +1,44 @@
+function resolveLocation(location) {
+    const source = location.source ??
+        (location.isLive ? "live" : location.name || location.address ? "place" : "pin");
+    const isLive = Boolean(location.isLive ?? source === "live");
+    return { ...location, source, isLive };
+}
+function formatAccuracy(accuracy) {
+    if (!Number.isFinite(accuracy))
+        return "";
+    return ` ±${Math.round(accuracy ?? 0)}m`;
+}
+function formatCoords(latitude, longitude) {
+    return `${latitude.toFixed(6)}, ${longitude.toFixed(6)}`;
+}
+export function formatLocationText(location) {
+    const resolved = resolveLocation(location);
+    const coords = formatCoords(resolved.latitude, resolved.longitude);
+    const accuracy = formatAccuracy(resolved.accuracy);
+    const caption = resolved.caption?.trim();
+    let header = "";
+    if (resolved.source === "live" || resolved.isLive) {
+        header = `🛰 Live location: ${coords}${accuracy}`;
+    }
+    else if (resolved.name || resolved.address) {
+        const label = [resolved.name, resolved.address].filter(Boolean).join(" — ");
+        header = `📍 ${label} (${coords}${accuracy})`;
+    }
+    else {
+        header = `📍 ${coords}${accuracy}`;
+    }
+    return caption ? `${header}\n${caption}` : header;
+}
+export function toLocationContext(location) {
+    const resolved = resolveLocation(location);
+    return {
+        LocationLat: resolved.latitude,
+        LocationLon: resolved.longitude,
+        LocationAccuracy: resolved.accuracy,
+        LocationName: resolved.name,
+        LocationAddress: resolved.address,
+        LocationSource: resolved.source,
+        LocationIsLive: resolved.isLive,
+    };
+}

package/dist/channels/web/index.js

@@ -0,0 +1,2 @@
+/* istanbul ignore file */
+export { createWaSocket, loginWeb, logWebSelfId, monitorWebChannel, monitorWebInbox, pickWebChannel, sendMessageWhatsApp, WA_WEB_AUTH_DIR, waitForWaConnection, webAuthExists, } from "../../channel-web.js";

package/dist/cli/cloud-cli.js

@@ -1,10 +1,10 @@
+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 { 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 +77,7 @@ async function storeHubToken(params) {
             value: params.token,
         });
     }
+    let envVar;
     if (storedInKeychain) {
         record = {
             owner: "user",
@@ -86,17 +87,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();
@@ -296,7 +298,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}`);
     }