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

package/dist/memory/internal.js

@@ -0,0 +1,163 @@
+import crypto from "node:crypto";
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+export function ensureDir(dir) {
+    try {
+        fsSync.mkdirSync(dir, { recursive: true });
+    }
+    catch { }
+    return dir;
+}
+export function normalizeRelPath(value) {
+    const trimmed = value.trim().replace(/^[./]+/, "");
+    return trimmed.replace(/\\/g, "/");
+}
+export function isMemoryPath(relPath) {
+    const normalized = normalizeRelPath(relPath);
+    if (!normalized)
+        return false;
+    if (normalized === "MEMORY.md" || normalized === "memory.md")
+        return true;
+    return normalized.startsWith("memory/");
+}
+async function exists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function walkDir(dir, files) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await walkDir(full, files);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        if (!entry.name.endsWith(".md"))
+            continue;
+        files.push(full);
+    }
+}
+export async function listMemoryFiles(workspaceDir) {
+    const result = [];
+    const memoryFile = path.join(workspaceDir, "MEMORY.md");
+    const altMemoryFile = path.join(workspaceDir, "memory.md");
+    if (await exists(memoryFile))
+        result.push(memoryFile);
+    if (await exists(altMemoryFile))
+        result.push(altMemoryFile);
+    const memoryDir = path.join(workspaceDir, "memory");
+    if (await exists(memoryDir)) {
+        await walkDir(memoryDir, result);
+    }
+    return result;
+}
+export function hashText(value) {
+    return crypto.createHash("sha256").update(value).digest("hex");
+}
+export async function buildFileEntry(absPath, workspaceDir) {
+    const stat = await fs.stat(absPath);
+    const content = await fs.readFile(absPath, "utf-8");
+    const hash = hashText(content);
+    return {
+        path: path.relative(workspaceDir, absPath).replace(/\\/g, "/"),
+        absPath,
+        mtimeMs: stat.mtimeMs,
+        size: stat.size,
+        hash,
+    };
+}
+export function chunkMarkdown(content, chunking) {
+    const lines = content.split("\n");
+    if (lines.length === 0)
+        return [];
+    const maxChars = Math.max(32, chunking.tokens * 4);
+    const overlapChars = Math.max(0, chunking.overlap * 4);
+    const chunks = [];
+    let current = [];
+    let currentChars = 0;
+    const flush = () => {
+        if (current.length === 0)
+            return;
+        const firstEntry = current[0];
+        const lastEntry = current[current.length - 1];
+        if (!firstEntry || !lastEntry)
+            return;
+        const text = current.map((entry) => entry.line).join("\n");
+        const startLine = firstEntry.lineNo;
+        const endLine = lastEntry.lineNo;
+        chunks.push({
+            startLine,
+            endLine,
+            text,
+            hash: hashText(text),
+        });
+    };
+    const carryOverlap = () => {
+        if (overlapChars <= 0 || current.length === 0) {
+            current = [];
+            currentChars = 0;
+            return;
+        }
+        let acc = 0;
+        const kept = [];
+        for (let i = current.length - 1; i >= 0; i -= 1) {
+            const entry = current[i];
+            if (!entry)
+                continue;
+            acc += entry.line.length + 1;
+            kept.unshift(entry);
+            if (acc >= overlapChars)
+                break;
+        }
+        current = kept;
+        currentChars = kept.reduce((sum, entry) => sum + entry.line.length + 1, 0);
+    };
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? "";
+        const lineNo = i + 1;
+        const lineSize = line.length + 1;
+        if (currentChars + lineSize > maxChars && current.length > 0) {
+            flush();
+            carryOverlap();
+        }
+        current.push({ line, lineNo });
+        currentChars += lineSize;
+    }
+    flush();
+    return chunks;
+}
+export function parseEmbedding(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function cosineSimilarity(a, b) {
+    if (a.length === 0 || b.length === 0)
+        return 0;
+    const len = Math.min(a.length, b.length);
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < len; i += 1) {
+        const av = a[i] ?? 0;
+        const bv = b[i] ?? 0;
+        dot += av * bv;
+        normA += av * av;
+        normB += bv * bv;
+    }
+    if (normA === 0 || normB === 0)
+        return 0;
+    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}

package/dist/pairing/pairing-store.js

@@ -0,0 +1,218 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { resolveOAuthDir, resolveStateDir } from "../config/paths.js";
+function resolveCredentialsDir(env = process.env) {
+    const stateDir = resolveStateDir(env, os.homedir);
+    return resolveOAuthDir(env, stateDir);
+}
+function resolvePairingPath(provider, env = process.env) {
+    return path.join(resolveCredentialsDir(env), `${provider}-pairing.json`);
+}
+function resolveAllowFromPath(provider, env = process.env) {
+    return path.join(resolveCredentialsDir(env), `${provider}-allowFrom.json`);
+}
+function safeParseJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+async function readJsonFile(filePath, fallback) {
+    try {
+        const raw = await fs.promises.readFile(filePath, "utf-8");
+        const parsed = safeParseJson(raw);
+        if (parsed == null)
+            return { value: fallback, exists: true };
+        return { value: parsed, exists: true };
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return { value: fallback, exists: false };
+        return { value: fallback, exists: false };
+    }
+}
+async function writeJsonFile(filePath, value) {
+    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.promises.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
+}
+function randomCode() {
+    // Human-friendly: 8 chars, upper, no ambiguous chars (0O1I).
+    const alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+    let out = "";
+    for (let i = 0; i < 8; i++) {
+        out += alphabet[Math.floor(Math.random() * alphabet.length)];
+    }
+    return out;
+}
+function normalizeId(value) {
+    return String(value).trim();
+}
+function normalizeAllowEntry(provider, entry) {
+    const trimmed = entry.trim();
+    if (!trimmed)
+        return "";
+    if (trimmed === "*")
+        return "";
+    if (provider === "telegram")
+        return trimmed.replace(/^(telegram|tg):/i, "");
+    if (provider === "signal")
+        return trimmed.replace(/^signal:/i, "");
+    if (provider === "discord")
+        return trimmed.replace(/^(discord|user):/i, "");
+    if (provider === "slack")
+        return trimmed.replace(/^(slack|user):/i, "");
+    return trimmed;
+}
+export async function readProviderAllowFromStore(provider, env = process.env) {
+    const filePath = resolveAllowFromPath(provider, env);
+    const { value } = await readJsonFile(filePath, {
+        version: 1,
+        allowFrom: [],
+    });
+    const list = Array.isArray(value.allowFrom) ? value.allowFrom : [];
+    return list
+        .map((v) => normalizeAllowEntry(provider, String(v)))
+        .filter(Boolean);
+}
+export async function addProviderAllowFromStoreEntry(params) {
+    const env = params.env ?? process.env;
+    const filePath = resolveAllowFromPath(params.provider, env);
+    const { value } = await readJsonFile(filePath, {
+        version: 1,
+        allowFrom: [],
+    });
+    const current = (Array.isArray(value.allowFrom) ? value.allowFrom : [])
+        .map((v) => normalizeAllowEntry(params.provider, String(v)))
+        .filter(Boolean);
+    const normalized = normalizeAllowEntry(params.provider, normalizeId(params.entry));
+    if (!normalized)
+        return { changed: false, allowFrom: current };
+    if (current.includes(normalized))
+        return { changed: false, allowFrom: current };
+    const next = [...current, normalized];
+    await writeJsonFile(filePath, {
+        version: 1,
+        allowFrom: next,
+    });
+    return { changed: true, allowFrom: next };
+}
+export async function listProviderPairingRequests(provider, env = process.env) {
+    const filePath = resolvePairingPath(provider, env);
+    const { value } = await readJsonFile(filePath, {
+        version: 1,
+        requests: [],
+    });
+    const reqs = Array.isArray(value.requests) ? value.requests : [];
+    return reqs
+        .filter((r) => r &&
+        typeof r.id === "string" &&
+        typeof r.code === "string" &&
+        typeof r.createdAt === "string")
+        .slice()
+        .sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+export async function upsertProviderPairingRequest(params) {
+    const env = params.env ?? process.env;
+    const filePath = resolvePairingPath(params.provider, env);
+    const { value } = await readJsonFile(filePath, {
+        version: 1,
+        requests: [],
+    });
+    const now = new Date().toISOString();
+    const id = normalizeId(params.id);
+    const meta = params.meta && typeof params.meta === "object"
+        ? Object.fromEntries(Object.entries(params.meta)
+            .map(([k, v]) => [k, String(v ?? "").trim()])
+            .filter(([_, v]) => Boolean(v)))
+        : undefined;
+    const reqs = Array.isArray(value.requests) ? value.requests : [];
+    const existingIdx = reqs.findIndex((r) => r.id === id);
+    if (existingIdx >= 0) {
+        const existing = reqs[existingIdx];
+        const existingCode = existing && typeof existing.code === "string" ? existing.code.trim() : "";
+        const code = existingCode || randomCode();
+        const next = {
+            id,
+            code,
+            createdAt: existing?.createdAt ?? now,
+            lastSeenAt: now,
+            meta: meta ?? existing?.meta,
+        };
+        reqs[existingIdx] = next;
+        await writeJsonFile(filePath, {
+            version: 1,
+            requests: reqs,
+        });
+        return { code, created: false };
+    }
+    const code = randomCode();
+    const next = {
+        id,
+        code,
+        createdAt: now,
+        lastSeenAt: now,
+        ...(meta ? { meta } : {}),
+    };
+    await writeJsonFile(filePath, {
+        version: 1,
+        requests: [...reqs, next],
+    });
+    return { code, created: true };
+}
+export async function approveProviderPairingCode(params) {
+    const env = params.env ?? process.env;
+    const code = params.code.trim().toUpperCase();
+    if (!code)
+        return null;
+    const filePath = resolvePairingPath(params.provider, env);
+    const { value } = await readJsonFile(filePath, {
+        version: 1,
+        requests: [],
+    });
+    const reqs = Array.isArray(value.requests) ? value.requests : [];
+    const idx = reqs.findIndex((r) => String(r.code ?? "").toUpperCase() === code);
+    if (idx < 0)
+        return null;
+    const entry = reqs[idx];
+    if (!entry)
+        return null;
+    reqs.splice(idx, 1);
+    await writeJsonFile(filePath, {
+        version: 1,
+        requests: reqs,
+    });
+    await addProviderAllowFromStoreEntry({
+        provider: params.provider,
+        entry: entry.id,
+        env,
+    });
+    return { id: entry.id, entry };
+}
+export const readChannelAllowFromStore = readProviderAllowFromStore;
+export async function addChannelAllowFromStoreEntry(params) {
+    return addProviderAllowFromStoreEntry({
+        provider: params.channel,
+        entry: params.entry,
+        env: params.env,
+    });
+}
+export const listChannelPairingRequests = listProviderPairingRequests;
+export async function upsertChannelPairingRequest(params) {
+    return upsertProviderPairingRequest({
+        provider: params.channel,
+        id: params.id,
+        meta: params.meta,
+        env: params.env,
+    });
+}
+export async function approveChannelPairingCode(params) {
+    return approveProviderPairingCode({
+        provider: params.channel,
+        code: params.code,
+        env: params.env,
+    });
+}

package/dist/plugins/cli.js

@@ -0,0 +1,42 @@
+import { resolveAgentWorkspaceDir } from "../agents/agent-scope.js";
+import { loadConfig } from "../config/config.js";
+import { createSubsystemLogger } from "../logging.js";
+import { DEFAULT_AGENT_ID, normalizeAgentId } from "../routing/session-key.js";
+import { loadNexusPlugins } from "./loader.js";
+const log = createSubsystemLogger("plugins");
+function resolveDefaultAgentId(cfg) {
+    return normalizeAgentId(cfg.routing?.defaultAgentId ?? DEFAULT_AGENT_ID);
+}
+export function registerPluginCliCommands(program, cfg) {
+    const config = cfg ?? loadConfig();
+    const workspaceDir = resolveAgentWorkspaceDir(config, resolveDefaultAgentId(config));
+    const logger = {
+        info: (msg) => log.info(msg),
+        warn: (msg) => log.warn(msg),
+        error: (msg) => log.error(msg),
+        debug: (msg) => log.debug(msg),
+    };
+    const registry = loadNexusPlugins({
+        config,
+        workspaceDir,
+        logger,
+    });
+    for (const entry of registry.cliRegistrars) {
+        try {
+            const result = entry.register({
+                program,
+                config,
+                workspaceDir,
+                logger,
+            });
+            if (result && typeof result.then === "function") {
+                void result.catch((err) => {
+                    log.warn(`plugin CLI register failed (${entry.pluginId}): ${String(err)}`);
+                });
+            }
+        }
+        catch (err) {
+            log.warn(`plugin CLI register failed (${entry.pluginId}): ${String(err)}`);
+        }
+    }
+}

package/dist/plugins/discovery.js

@@ -0,0 +1,253 @@
+import fs from "node:fs";
+import path from "node:path";
+import { CONFIG_DIR, resolveUserPath } from "../utils.js";
+const EXTENSION_EXTS = new Set([".ts", ".js", ".mts", ".cts", ".mjs", ".cjs"]);
+function isExtensionFile(filePath) {
+    const ext = path.extname(filePath);
+    if (!EXTENSION_EXTS.has(ext))
+        return false;
+    return !filePath.endsWith(".d.ts");
+}
+function readPackageManifest(dir) {
+    const manifestPath = path.join(dir, "package.json");
+    if (!fs.existsSync(manifestPath))
+        return null;
+    try {
+        const raw = fs.readFileSync(manifestPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function resolvePackageExtensions(manifest) {
+    // Try nexus first, fall back to clawdbot for backward compat
+    const raw = manifest.nexus?.extensions ?? manifest.clawdbot?.extensions;
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+        .filter(Boolean);
+}
+function deriveIdHint(params) {
+    const base = path.basename(params.filePath, path.extname(params.filePath));
+    const rawPackageName = params.packageName?.trim();
+    if (!rawPackageName)
+        return base;
+    // Prefer the unscoped name so config keys stay stable even when the npm
+    // package is scoped (example: @nexus/voice-call -> voice-call).
+    const unscoped = rawPackageName.includes("/")
+        ? (rawPackageName.split("/").pop() ?? rawPackageName)
+        : rawPackageName;
+    if (!params.hasMultipleExtensions)
+        return unscoped;
+    return `${unscoped}/${base}`;
+}
+function addCandidate(params) {
+    const resolved = path.resolve(params.source);
+    if (params.seen.has(resolved))
+        return;
+    params.seen.add(resolved);
+    const manifest = params.manifest ?? null;
+    params.candidates.push({
+        idHint: params.idHint,
+        source: resolved,
+        origin: params.origin,
+        workspaceDir: params.workspaceDir,
+        packageName: manifest?.name?.trim() || undefined,
+        packageVersion: manifest?.version?.trim() || undefined,
+        packageDescription: manifest?.description?.trim() || undefined,
+    });
+}
+function discoverInDirectory(params) {
+    if (!fs.existsSync(params.dir))
+        return;
+    let entries = [];
+    try {
+        entries = fs.readdirSync(params.dir, { withFileTypes: true });
+    }
+    catch (err) {
+        params.diagnostics.push({
+            level: "warn",
+            message: `failed to read extensions dir: ${params.dir} (${String(err)})`,
+            source: params.dir,
+        });
+        return;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(params.dir, entry.name);
+        if (entry.isFile()) {
+            if (!isExtensionFile(fullPath))
+                continue;
+            addCandidate({
+                candidates: params.candidates,
+                seen: params.seen,
+                idHint: path.basename(entry.name, path.extname(entry.name)),
+                source: fullPath,
+                origin: params.origin,
+                workspaceDir: params.workspaceDir,
+            });
+        }
+        if (!entry.isDirectory())
+            continue;
+        const manifest = readPackageManifest(fullPath);
+        const extensions = manifest ? resolvePackageExtensions(manifest) : [];
+        if (extensions.length > 0) {
+            for (const extPath of extensions) {
+                const resolved = path.resolve(fullPath, extPath);
+                addCandidate({
+                    candidates: params.candidates,
+                    seen: params.seen,
+                    idHint: deriveIdHint({
+                        filePath: resolved,
+                        packageName: manifest?.name,
+                        hasMultipleExtensions: extensions.length > 1,
+                    }),
+                    source: resolved,
+                    origin: params.origin,
+                    workspaceDir: params.workspaceDir,
+                    manifest,
+                });
+            }
+            continue;
+        }
+        const indexCandidates = ["index.ts", "index.js", "index.mjs", "index.cjs"];
+        const indexFile = indexCandidates
+            .map((candidate) => path.join(fullPath, candidate))
+            .find((candidate) => fs.existsSync(candidate));
+        if (indexFile && isExtensionFile(indexFile)) {
+            addCandidate({
+                candidates: params.candidates,
+                seen: params.seen,
+                idHint: entry.name,
+                source: indexFile,
+                origin: params.origin,
+                workspaceDir: params.workspaceDir,
+            });
+        }
+    }
+}
+function discoverFromPath(params) {
+    const resolved = resolveUserPath(params.rawPath);
+    if (!fs.existsSync(resolved)) {
+        params.diagnostics.push({
+            level: "warn",
+            message: `plugin path not found: ${resolved}`,
+            source: resolved,
+        });
+        return;
+    }
+    const stat = fs.statSync(resolved);
+    if (stat.isFile()) {
+        if (!isExtensionFile(resolved)) {
+            params.diagnostics.push({
+                level: "warn",
+                message: `plugin path is not a supported file: ${resolved}`,
+                source: resolved,
+            });
+            return;
+        }
+        addCandidate({
+            candidates: params.candidates,
+            seen: params.seen,
+            idHint: path.basename(resolved, path.extname(resolved)),
+            source: resolved,
+            origin: params.origin,
+            workspaceDir: params.workspaceDir,
+        });
+        return;
+    }
+    if (stat.isDirectory()) {
+        const manifest = readPackageManifest(resolved);
+        const extensions = manifest ? resolvePackageExtensions(manifest) : [];
+        if (extensions.length > 0) {
+            for (const extPath of extensions) {
+                const source = path.resolve(resolved, extPath);
+                addCandidate({
+                    candidates: params.candidates,
+                    seen: params.seen,
+                    idHint: deriveIdHint({
+                        filePath: source,
+                        packageName: manifest?.name,
+                        hasMultipleExtensions: extensions.length > 1,
+                    }),
+                    source,
+                    origin: params.origin,
+                    workspaceDir: params.workspaceDir,
+                    manifest,
+                });
+            }
+            return;
+        }
+        const indexCandidates = ["index.ts", "index.js", "index.mjs", "index.cjs"];
+        const indexFile = indexCandidates
+            .map((candidate) => path.join(resolved, candidate))
+            .find((candidate) => fs.existsSync(candidate));
+        if (indexFile && isExtensionFile(indexFile)) {
+            addCandidate({
+                candidates: params.candidates,
+                seen: params.seen,
+                idHint: path.basename(resolved),
+                source: indexFile,
+                origin: params.origin,
+                workspaceDir: params.workspaceDir,
+            });
+            return;
+        }
+        discoverInDirectory({
+            dir: resolved,
+            origin: params.origin,
+            workspaceDir: params.workspaceDir,
+            candidates: params.candidates,
+            diagnostics: params.diagnostics,
+            seen: params.seen,
+        });
+        return;
+    }
+}
+export function discoverNexusPlugins(params) {
+    const candidates = [];
+    const diagnostics = [];
+    const seen = new Set();
+    const globalDir = path.join(CONFIG_DIR, "extensions");
+    discoverInDirectory({
+        dir: globalDir,
+        origin: "global",
+        candidates,
+        diagnostics,
+        seen,
+    });
+    const workspaceDir = params.workspaceDir?.trim();
+    if (workspaceDir) {
+        const workspaceRoot = resolveUserPath(workspaceDir);
+        // Try .nexus/extensions first, fall back to .clawdbot/extensions
+        const nexusExt = path.join(workspaceRoot, ".nexus", "extensions");
+        const clawdbotExt = path.join(workspaceRoot, ".clawdbot", "extensions");
+        const workspaceExt = fs.existsSync(nexusExt) ? nexusExt : clawdbotExt;
+        discoverInDirectory({
+            dir: workspaceExt,
+            origin: "workspace",
+            workspaceDir: workspaceRoot,
+            candidates,
+            diagnostics,
+            seen,
+        });
+    }
+    const extra = params.extraPaths ?? [];
+    for (const extraPath of extra) {
+        if (typeof extraPath !== "string")
+            continue;
+        const trimmed = extraPath.trim();
+        if (!trimmed)
+            continue;
+        discoverFromPath({
+            rawPath: trimmed,
+            origin: "config",
+            workspaceDir: workspaceDir?.trim() || undefined,
+            candidates,
+            diagnostics,
+            seen,
+        });
+    }
+    return { candidates, diagnostics };
+}