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

package/dist/capabilities/detector.js

@@ -0,0 +1,214 @@
+import fs from "node:fs";
+import path from "node:path";
+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 { 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(resolveStateDir(), "nexus", "skills", 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,98 @@
+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";