@intent-systems/nexus 2026.1.5-3

package/dist/cli/hooks-cli.js

@@ -0,0 +1,135 @@
+import { danger } from "../globals.js";
+import { DEFAULT_GMAIL_LABEL, DEFAULT_GMAIL_MAX_BYTES, DEFAULT_GMAIL_RENEW_MINUTES, DEFAULT_GMAIL_SERVE_BIND, DEFAULT_GMAIL_SERVE_PATH, DEFAULT_GMAIL_SERVE_PORT, DEFAULT_GMAIL_SUBSCRIPTION, DEFAULT_GMAIL_TOPIC, } from "../hooks/gmail.js";
+import { runGmailService, runGmailSetup, } from "../hooks/gmail-ops.js";
+import { defaultRuntime } from "../runtime.js";
+export function registerHooksCli(program) {
+    const hooks = program
+        .command("hooks")
+        .description("Webhook helpers and hook-based integrations");
+    const gmail = hooks
+        .command("gmail")
+        .description("Gmail Pub/Sub hooks (via gogcli)");
+    gmail
+        .command("setup")
+        .description("Configure Gmail watch + Pub/Sub + Nexus hooks")
+        .requiredOption("--account <email>", "Gmail account to watch")
+        .option("--project <id>", "GCP project id (OAuth client owner)")
+        .option("--topic <name>", "Pub/Sub topic name", DEFAULT_GMAIL_TOPIC)
+        .option("--subscription <name>", "Pub/Sub subscription name", DEFAULT_GMAIL_SUBSCRIPTION)
+        .option("--label <label>", "Gmail label to watch", DEFAULT_GMAIL_LABEL)
+        .option("--hook-url <url>", "Nexus hook URL")
+        .option("--hook-token <token>", "Nexus hook token")
+        .option("--push-token <token>", "Push token for gog watch serve")
+        .option("--bind <host>", "gog watch serve bind host", DEFAULT_GMAIL_SERVE_BIND)
+        .option("--port <port>", "gog watch serve port", String(DEFAULT_GMAIL_SERVE_PORT))
+        .option("--path <path>", "gog watch serve path", DEFAULT_GMAIL_SERVE_PATH)
+        .option("--include-body", "Include email body snippets", true)
+        .option("--max-bytes <n>", "Max bytes for body snippets", String(DEFAULT_GMAIL_MAX_BYTES))
+        .option("--renew-minutes <n>", "Renew watch every N minutes", String(DEFAULT_GMAIL_RENEW_MINUTES))
+        .option("--tailscale <mode>", "Expose push endpoint via tailscale (funnel|serve|off)", "funnel")
+        .option("--tailscale-path <path>", "Path for tailscale serve/funnel")
+        .option("--push-endpoint <url>", "Explicit Pub/Sub push endpoint")
+        .option("--json", "Output JSON summary", false)
+        .action(async (opts) => {
+        try {
+            const parsed = parseGmailSetupOptions(opts);
+            await runGmailSetup(parsed);
+        }
+        catch (err) {
+            defaultRuntime.error(danger(String(err)));
+            defaultRuntime.exit(1);
+        }
+    });
+    gmail
+        .command("run")
+        .description("Run gog watch serve + auto-renew loop")
+        .option("--account <email>", "Gmail account to watch")
+        .option("--topic <topic>", "Pub/Sub topic path (projects/.../topics/..)")
+        .option("--subscription <name>", "Pub/Sub subscription name")
+        .option("--label <label>", "Gmail label to watch")
+        .option("--hook-url <url>", "Nexus hook URL")
+        .option("--hook-token <token>", "Nexus hook token")
+        .option("--push-token <token>", "Push token for gog watch serve")
+        .option("--bind <host>", "gog watch serve bind host")
+        .option("--port <port>", "gog watch serve port")
+        .option("--path <path>", "gog watch serve path")
+        .option("--include-body", "Include email body snippets")
+        .option("--max-bytes <n>", "Max bytes for body snippets")
+        .option("--renew-minutes <n>", "Renew watch every N minutes")
+        .option("--tailscale <mode>", "Expose push endpoint via tailscale (funnel|serve|off)")
+        .option("--tailscale-path <path>", "Path for tailscale serve/funnel")
+        .action(async (opts) => {
+        try {
+            const parsed = parseGmailRunOptions(opts);
+            await runGmailService(parsed);
+        }
+        catch (err) {
+            defaultRuntime.error(danger(String(err)));
+            defaultRuntime.exit(1);
+        }
+    });
+}
+function parseGmailSetupOptions(raw) {
+    const accountRaw = raw.account;
+    const account = typeof accountRaw === "string" ? accountRaw.trim() : "";
+    if (!account)
+        throw new Error("--account is required");
+    return {
+        account,
+        project: stringOption(raw.project),
+        topic: stringOption(raw.topic),
+        subscription: stringOption(raw.subscription),
+        label: stringOption(raw.label),
+        hookUrl: stringOption(raw.hookUrl),
+        hookToken: stringOption(raw.hookToken),
+        pushToken: stringOption(raw.pushToken),
+        bind: stringOption(raw.bind),
+        port: numberOption(raw.port),
+        path: stringOption(raw.path),
+        includeBody: booleanOption(raw.includeBody),
+        maxBytes: numberOption(raw.maxBytes),
+        renewEveryMinutes: numberOption(raw.renewMinutes),
+        tailscale: stringOption(raw.tailscale),
+        tailscalePath: stringOption(raw.tailscalePath),
+        pushEndpoint: stringOption(raw.pushEndpoint),
+        json: Boolean(raw.json),
+    };
+}
+function parseGmailRunOptions(raw) {
+    return {
+        account: stringOption(raw.account),
+        topic: stringOption(raw.topic),
+        subscription: stringOption(raw.subscription),
+        label: stringOption(raw.label),
+        hookUrl: stringOption(raw.hookUrl),
+        hookToken: stringOption(raw.hookToken),
+        pushToken: stringOption(raw.pushToken),
+        bind: stringOption(raw.bind),
+        port: numberOption(raw.port),
+        path: stringOption(raw.path),
+        includeBody: booleanOption(raw.includeBody),
+        maxBytes: numberOption(raw.maxBytes),
+        renewEveryMinutes: numberOption(raw.renewMinutes),
+        tailscale: stringOption(raw.tailscale),
+        tailscalePath: stringOption(raw.tailscalePath),
+    };
+}
+function stringOption(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+function numberOption(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const n = typeof value === "number" ? value : Number(value);
+    if (!Number.isFinite(n) || n <= 0)
+        return undefined;
+    return Math.floor(n);
+}
+function booleanOption(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    return Boolean(value);
+}

package/dist/cli/memory-cli.js

@@ -0,0 +1,101 @@
+import chalk from "chalk";
+import { loadConfig } from "../config/config.js";
+import { getMemorySearchManager } from "../memory/index.js";
+import { DEFAULT_AGENT_ID, normalizeAgentId } from "../routing/session-key.js";
+import { defaultRuntime } from "../runtime.js";
+function resolveAgent(cfg, agent) {
+    const trimmed = agent?.trim();
+    if (trimmed)
+        return normalizeAgentId(trimmed);
+    return normalizeAgentId(cfg.routing?.defaultAgentId ?? DEFAULT_AGENT_ID);
+}
+export function registerMemoryCli(program) {
+    const memory = program.command("memory").description("Memory search tools");
+    memory
+        .command("status")
+        .description("Show memory search index status")
+        .option("--agent <id>", "Agent id (default: default agent)")
+        .option("--json", "Print JSON")
+        .action(async (opts) => {
+        const cfg = loadConfig();
+        const agentId = resolveAgent(cfg, opts.agent);
+        const { manager, error } = await getMemorySearchManager({ cfg, agentId });
+        if (!manager) {
+            defaultRuntime.log(error ?? "Memory search disabled.");
+            return;
+        }
+        const status = manager.status();
+        if (opts.json) {
+            defaultRuntime.log(JSON.stringify(status, null, 2));
+            return;
+        }
+        const lines = [
+            `${chalk.bold.cyan("Memory Search")} (${agentId})`,
+            `Provider: ${status.provider} (requested: ${status.requestedProvider})`,
+            status.fallback ? chalk.yellow(`Fallback: ${status.fallback.from}`) : null,
+            `Files: ${status.files}`,
+            `Chunks: ${status.chunks}`,
+            `Dirty: ${status.dirty ? "yes" : "no"}`,
+            `Index: ${status.dbPath}`,
+        ].filter(Boolean);
+        if (status.fallback?.reason) {
+            lines.push(chalk.gray(status.fallback.reason));
+        }
+        defaultRuntime.log(lines.join("\n"));
+    });
+    memory
+        .command("index")
+        .description("Reindex memory files")
+        .option("--agent <id>", "Agent id (default: default agent)")
+        .option("--force", "Force full reindex", false)
+        .action(async (opts) => {
+        const cfg = loadConfig();
+        const agentId = resolveAgent(cfg, opts.agent);
+        const { manager, error } = await getMemorySearchManager({ cfg, agentId });
+        if (!manager) {
+            defaultRuntime.log(error ?? "Memory search disabled.");
+            return;
+        }
+        await manager.sync({ reason: "cli", force: opts.force });
+        defaultRuntime.log("Memory index updated.");
+    });
+    memory
+        .command("search")
+        .description("Search memory files")
+        .argument("<query>", "Search query")
+        .option("--agent <id>", "Agent id (default: default agent)")
+        .option("--max-results <n>", "Max results", (v) => Number(v))
+        .option("--min-score <n>", "Minimum score", (v) => Number(v))
+        .option("--json", "Print JSON")
+        .action(async (query, opts) => {
+        const cfg = loadConfig();
+        const agentId = resolveAgent(cfg, opts.agent);
+        const { manager, error } = await getMemorySearchManager({
+            cfg,
+            agentId,
+        });
+        if (!manager) {
+            defaultRuntime.log(error ?? "Memory search disabled.");
+            return;
+        }
+        const results = await manager.search(query, {
+            maxResults: opts.maxResults,
+            minScore: opts.minScore,
+        });
+        if (opts.json) {
+            defaultRuntime.log(JSON.stringify({ results }, null, 2));
+            return;
+        }
+        if (results.length === 0) {
+            defaultRuntime.log("No matches.");
+            return;
+        }
+        const lines = [];
+        for (const result of results) {
+            lines.push(`${chalk.green(result.score.toFixed(3))} ${result.path}:${result.startLine}-${result.endLine}`);
+            lines.push(chalk.gray(result.snippet));
+            lines.push("");
+        }
+        defaultRuntime.log(lines.join("\n").trim());
+    });
+}

package/dist/cli/models-cli.js

@@ -0,0 +1,248 @@
+import { modelsAliasesAddCommand, modelsAliasesListCommand, modelsAliasesRemoveCommand, modelsFallbacksAddCommand, modelsFallbacksClearCommand, modelsFallbacksListCommand, modelsFallbacksRemoveCommand, modelsImageFallbacksAddCommand, modelsImageFallbacksClearCommand, modelsImageFallbacksListCommand, modelsImageFallbacksRemoveCommand, modelsListCommand, modelsScanCommand, modelsSetCommand, modelsSetImageCommand, modelsStatusCommand, } from "../commands/models.js";
+import { defaultRuntime } from "../runtime.js";
+export function registerModelsCli(program) {
+    const models = program
+        .command("models")
+        .description("Model discovery, scanning, and configuration");
+    models
+        .command("list")
+        .description("List models (configured by default)")
+        .option("--all", "Show full model catalog", false)
+        .option("--local", "Filter to local models", false)
+        .option("--provider <name>", "Filter by provider")
+        .option("--json", "Output JSON", false)
+        .option("--plain", "Plain line output", false)
+        .action(async (opts) => {
+        try {
+            await modelsListCommand(opts, defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    models
+        .command("status")
+        .description("Show configured model state")
+        .option("--json", "Output JSON", false)
+        .option("--plain", "Plain output", false)
+        .action(async (opts) => {
+        try {
+            await modelsStatusCommand(opts, defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    models
+        .command("set")
+        .description("Set the default model")
+        .argument("<model>", "Model id or alias")
+        .action(async (model) => {
+        try {
+            await modelsSetCommand(model, defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    models
+        .command("set-image")
+        .description("Set the image model")
+        .argument("<model>", "Model id or alias")
+        .action(async (model) => {
+        try {
+            await modelsSetImageCommand(model, defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    const aliases = models.command("aliases").description("Manage model aliases");
+    aliases
+        .command("list")
+        .description("List model aliases")
+        .option("--json", "Output JSON", false)
+        .option("--plain", "Plain output", false)
+        .action(async (opts) => {
+        try {
+            await modelsAliasesListCommand(opts, defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    aliases
+        .command("add")
+        .description("Add or update a model alias")
+        .argument("<alias>", "Alias name")
+        .argument("<model>", "Model id or alias")
+        .action(async (alias, model) => {
+        try {
+            await modelsAliasesAddCommand(alias, model, defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    aliases
+        .command("remove")
+        .description("Remove a model alias")
+        .argument("<alias>", "Alias name")
+        .action(async (alias) => {
+        try {
+            await modelsAliasesRemoveCommand(alias, defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    const fallbacks = models
+        .command("fallbacks")
+        .description("Manage model fallback list");
+    fallbacks
+        .command("list")
+        .description("List fallback models")
+        .option("--json", "Output JSON", false)
+        .option("--plain", "Plain output", false)
+        .action(async (opts) => {
+        try {
+            await modelsFallbacksListCommand(opts, defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    fallbacks
+        .command("add")
+        .description("Add a fallback model")
+        .argument("<model>", "Model id or alias")
+        .action(async (model) => {
+        try {
+            await modelsFallbacksAddCommand(model, defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    fallbacks
+        .command("remove")
+        .description("Remove a fallback model")
+        .argument("<model>", "Model id or alias")
+        .action(async (model) => {
+        try {
+            await modelsFallbacksRemoveCommand(model, defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    fallbacks
+        .command("clear")
+        .description("Clear all fallback models")
+        .action(async () => {
+        try {
+            await modelsFallbacksClearCommand(defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    const imageFallbacks = models
+        .command("image-fallbacks")
+        .description("Manage image model fallback list");
+    imageFallbacks
+        .command("list")
+        .description("List image fallback models")
+        .option("--json", "Output JSON", false)
+        .option("--plain", "Plain output", false)
+        .action(async (opts) => {
+        try {
+            await modelsImageFallbacksListCommand(opts, defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    imageFallbacks
+        .command("add")
+        .description("Add an image fallback model")
+        .argument("<model>", "Model id or alias")
+        .action(async (model) => {
+        try {
+            await modelsImageFallbacksAddCommand(model, defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    imageFallbacks
+        .command("remove")
+        .description("Remove an image fallback model")
+        .argument("<model>", "Model id or alias")
+        .action(async (model) => {
+        try {
+            await modelsImageFallbacksRemoveCommand(model, defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    imageFallbacks
+        .command("clear")
+        .description("Clear all image fallback models")
+        .action(async () => {
+        try {
+            await modelsImageFallbacksClearCommand(defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    models
+        .command("scan")
+        .description("Scan OpenRouter free models for tools + images")
+        .option("--min-params <b>", "Minimum parameter size (billions)")
+        .option("--max-age-days <days>", "Skip models older than N days")
+        .option("--provider <name>", "Filter by provider prefix")
+        .option("--max-candidates <n>", "Max fallback candidates", "6")
+        .option("--timeout <ms>", "Per-probe timeout in ms")
+        .option("--concurrency <n>", "Probe concurrency")
+        .option("--yes", "Accept defaults without prompting", false)
+        .option("--no-input", "Disable prompts (use defaults)")
+        .option("--set-default", "Set agent.model to the first selection", false)
+        .option("--set-image", "Set agent.imageModel to the first image selection", false)
+        .option("--json", "Output JSON", false)
+        .action(async (opts) => {
+        try {
+            await modelsScanCommand(opts, defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    models.action(async () => {
+        try {
+            await modelsStatusCommand({}, defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+}

package/dist/cli/nodes-camera.js

@@ -0,0 +1,57 @@
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+function asRecord(value) {
+    return typeof value === "object" && value !== null
+        ? value
+        : {};
+}
+function asString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : undefined;
+}
+function asBoolean(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+export function parseCameraSnapPayload(value) {
+    const obj = asRecord(value);
+    const format = asString(obj.format);
+    const base64 = asString(obj.base64);
+    const width = asNumber(obj.width);
+    const height = asNumber(obj.height);
+    if (!format || !base64 || width === undefined || height === undefined) {
+        throw new Error("invalid camera.snap payload");
+    }
+    return { format, base64, width, height };
+}
+export function parseCameraClipPayload(value) {
+    const obj = asRecord(value);
+    const format = asString(obj.format);
+    const base64 = asString(obj.base64);
+    const durationMs = asNumber(obj.durationMs);
+    const hasAudio = asBoolean(obj.hasAudio);
+    if (!format ||
+        !base64 ||
+        durationMs === undefined ||
+        hasAudio === undefined) {
+        throw new Error("invalid camera.clip payload");
+    }
+    return { format, base64, durationMs, hasAudio };
+}
+export function cameraTempPath(opts) {
+    const tmpDir = opts.tmpDir ?? os.tmpdir();
+    const id = opts.id ?? randomUUID();
+    const facingPart = opts.facing ? `-${opts.facing}` : "";
+    const ext = opts.ext.startsWith(".") ? opts.ext : `.${opts.ext}`;
+    return path.join(tmpDir, `nexus-camera-${opts.kind}${facingPart}-${id}${ext}`);
+}
+export async function writeBase64ToFile(filePath, base64) {
+    const buf = Buffer.from(base64, "base64");
+    await fs.writeFile(filePath, buf);
+    return { path: filePath, bytes: buf.length };
+}

package/dist/cli/nodes-canvas.js

@@ -0,0 +1,26 @@
+import { randomUUID } from "node:crypto";
+import * as os from "node:os";
+import * as path from "node:path";
+function asRecord(value) {
+    return typeof value === "object" && value !== null
+        ? value
+        : {};
+}
+function asString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+export function parseCanvasSnapshotPayload(value) {
+    const obj = asRecord(value);
+    const format = asString(obj.format);
+    const base64 = asString(obj.base64);
+    if (!format || !base64) {
+        throw new Error("invalid canvas.snapshot payload");
+    }
+    return { format, base64 };
+}
+export function canvasSnapshotTempPath(opts) {
+    const tmpDir = opts.tmpDir ?? os.tmpdir();
+    const id = opts.id ?? randomUUID();
+    const ext = opts.ext.startsWith(".") ? opts.ext : `.${opts.ext}`;
+    return path.join(tmpDir, `nexus-canvas-snapshot-${id}${ext}`);
+}