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

package/dist/cli/usage-cli.js

@@ -1,3 +1,4 @@
+import { usageTrackingCommand } from "../commands/usage-tracking.js";
 import { usageUploadCommand } from "../commands/usage-upload.js";
 import { defaultRuntime } from "../runtime.js";
 export function registerUsageCli(program) {
@@ -21,4 +22,17 @@ export function registerUsageCli(program) {
             onlyFlush: Boolean(opts.onlyFlush),
         }, defaultRuntime);
     });
+    usageCmd
+        .command("tracking")
+        .description("View or update usage tracking preference")
+        .option("--enable", "Enable usage tracking")
+        .option("--disable", "Disable usage tracking (paid only)")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        await usageTrackingCommand({
+            json: Boolean(opts.json),
+            enable: Boolean(opts.enable),
+            disable: Boolean(opts.disable),
+        }, defaultRuntime);
+    });
 }

package/dist/commands/auth-choice-options.js

@@ -1,5 +1,5 @@
-import { CLAUDE_CLI_PROFILE_ID, CODEX_CLI_PROFILE_ID, } from "../agents/auth-profiles.js";
 import chalk from "chalk";
+import { CLAUDE_CLI_PROFILE_ID, CODEX_CLI_PROFILE_ID, } from "../agents/auth-profiles.js";
 function formatOAuthHint(expires, opts) {
     if (!expires) {
         return chalk.dim("token unavailable");
@@ -65,11 +65,16 @@ export function buildAuthChoiceOptions(params) {
         label: "OpenAI Codex (ChatGPT OAuth)",
     });
     options.push({ value: "openai-api-key", label: "OpenAI API key" });
+    options.push({
+        value: "github-copilot",
+        label: "GitHub Copilot (device login)",
+    });
     options.push({
         value: "antigravity",
         label: "Google Antigravity (Claude Opus 4.5, Gemini 3, etc.)",
     });
     options.push({ value: "gemini-api-key", label: "Google Gemini API key" });
+    options.push({ value: "chutes", label: "Chutes OAuth (remote)" });
     options.push({ value: "apiKey", label: "Anthropic API key" });
     options.push({ value: "minimax-cloud", label: "MiniMax M2.1 (minimax.io)" });
     options.push({ value: "minimax", label: "Minimax M2.1 (LM Studio)" });

package/dist/commands/auth-choice.js

@@ -1,9 +1,11 @@
 import { CLAUDE_CLI_PROFILE_ID, ensureAuthProfileStore, upsertAuthProfile, } from "../agents/auth-profiles.js";
-import { applyAuthProfileConfig } from "./onboard-auth.js";
 import { buildTokenProfileId, validateAnthropicSetupToken, } from "./auth-token.js";
+import { CHUTES_TOKEN_ENDPOINT } from "../agents/chutes-oauth.js";
+import { importCliCredential } from "./credential.js";
+import { applyAuthProfileConfig, writeOAuthCredentials } from "./onboard-auth.js";
 export async function applyAuthChoice(params) {
     let nextConfig = params.config;
-    let agentModelOverride;
+    const agentModelOverride = undefined;
     if (params.authChoice === "claude-cli") {
         const store = ensureAuthProfileStore();
         const hasClaudeCli = Boolean(store.profiles[CLAUDE_CLI_PROFILE_ID]);
@@ -21,8 +23,21 @@ export async function applyAuthChoice(params) {
                 return { config: nextConfig, agentModelOverride };
             }
         }
-        const storeWithKeychain = ensureAuthProfileStore();
-        if (!storeWithKeychain.profiles[CLAUDE_CLI_PROFILE_ID]) {
+        let hasProfile = hasClaudeCli;
+        if (!hasProfile) {
+            try {
+                await importCliCredential({
+                    source: "claude-cli",
+                    allowKeychainPrompt: true,
+                });
+            }
+            catch {
+                // ignore; we will prompt for setup-token below
+            }
+            const refreshed = ensureAuthProfileStore();
+            hasProfile = Boolean(refreshed.profiles[CLAUDE_CLI_PROFILE_ID]);
+        }
+        if (!hasProfile) {
             if (process.stdin.isTTY) {
                 const runNow = await params.prompter.confirm({
                     message: "Run `claude setup-token` now?",
@@ -41,6 +56,16 @@ export async function applyAuthChoice(params) {
             else {
                 await params.prompter.note("`claude setup-token` requires an interactive TTY.", "Claude setup-token");
             }
+            try {
+                await importCliCredential({
+                    source: "claude-cli",
+                    allowKeychainPrompt: true,
+                    force: true,
+                });
+            }
+            catch {
+                // ignore; handled below
+            }
             const refreshed = ensureAuthProfileStore();
             if (!refreshed.profiles[CLAUDE_CLI_PROFILE_ID]) {
                 await params.prompter.note(process.platform === "darwin"
@@ -83,6 +108,16 @@ export async function applyAuthChoice(params) {
             await params.prompter.note(`claude setup-token failed (exit ${res.status})`, "Anthropic setup-token");
             return { config: nextConfig, agentModelOverride };
         }
+        try {
+            await importCliCredential({
+                source: "claude-cli",
+                allowKeychainPrompt: true,
+                force: true,
+            });
+        }
+        catch {
+            // ignore; handled below
+        }
         const store = ensureAuthProfileStore();
         if (!store.profiles[CLAUDE_CLI_PROFILE_ID]) {
             await params.prompter.note(`No Claude CLI credentials found after setup-token. Expected ${CLAUDE_CLI_PROFILE_ID}.`, "Anthropic setup-token");
@@ -107,7 +142,9 @@ export async function applyAuthChoice(params) {
             message: "Paste Anthropic setup-token",
             validate: (value) => validateAnthropicSetupToken(String(value ?? "")),
         });
-        const token = String(tokenRaw).trim();
+        const tokenInput = String(tokenRaw).trim();
+        const tokenMatch = tokenInput.match(/sk-ant-oat01-[A-Za-z0-9_-]+/);
+        const token = tokenMatch?.[0] ?? tokenInput;
         const profileNameRaw = await params.prompter.text({
             message: "Token name (blank = default)",
             placeholder: "default",
@@ -130,5 +167,120 @@ export async function applyAuthChoice(params) {
             mode: "token",
         });
     }
+    else if (params.authChoice === "chutes") {
+        const clientId = process.env.CHUTES_CLIENT_ID?.trim();
+        if (!clientId) {
+            params.runtime.error("CHUTES_CLIENT_ID is required for Chutes OAuth.");
+            params.runtime.exit(1);
+            return { config: nextConfig, agentModelOverride };
+        }
+        const rawInput = await params.prompter.text({
+            message: "Paste the redirect URL (or authorization code)",
+        });
+        const raw = String(rawInput ?? "").trim();
+        if (!raw) {
+            params.runtime.error("Missing Chutes authorization code.");
+            params.runtime.exit(1);
+            return { config: nextConfig, agentModelOverride };
+        }
+        let code = raw;
+        try {
+            const url = new URL(raw);
+            code = url.searchParams.get("code") ?? url.searchParams.get("authorization_code") ?? raw;
+        }
+        catch {
+            // leave raw as code
+        }
+        const tokenRes = await fetch(CHUTES_TOKEN_ENDPOINT, {
+            method: "POST",
+            headers: { "content-type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({
+                grant_type: "authorization_code",
+                code,
+                client_id: clientId,
+            }),
+        });
+        if (!tokenRes.ok) {
+            const text = await tokenRes.text().catch(() => "");
+            params.runtime.error(`Chutes token exchange failed (${tokenRes.status}): ${text || "no response"}`);
+            params.runtime.exit(1);
+            return { config: nextConfig, agentModelOverride };
+        }
+        const tokenJson = (await tokenRes.json());
+        const accessToken = tokenJson.access_token?.trim();
+        const refreshToken = tokenJson.refresh_token?.trim();
+        if (!accessToken || !refreshToken) {
+            params.runtime.error("Chutes token response missing access or refresh token.");
+            params.runtime.exit(1);
+            return { config: nextConfig, agentModelOverride };
+        }
+        const expiresIn = typeof tokenJson.expires_in === "number"
+            ? tokenJson.expires_in
+            : Number.parseInt(String(tokenJson.expires_in ?? ""), 10);
+        const expiresAt = Number.isFinite(expiresIn) && expiresIn > 0
+            ? Date.now() + expiresIn * 1000
+            : undefined;
+        const userRes = await fetch("https://api.chutes.ai/idp/userinfo", {
+            headers: { authorization: `Bearer ${accessToken}` },
+        });
+        if (!userRes.ok) {
+            const text = await userRes.text().catch(() => "");
+            params.runtime.error(`Chutes userinfo failed (${userRes.status}): ${text || "no response"}`);
+            params.runtime.exit(1);
+            return { config: nextConfig, agentModelOverride };
+        }
+        const userJson = (await userRes.json());
+        const account = userJson.username?.trim() || userJson.email?.trim() || "default";
+        const expires = typeof expiresAt === "number" && Number.isFinite(expiresAt)
+            ? expiresAt
+            : Date.now() + 3600_000;
+        const oauthCreds = {
+            access: accessToken,
+            refresh: refreshToken,
+            expires,
+            email: account,
+        };
+        await writeOAuthCredentials("chutes", oauthCreds);
+        const profileId = `chutes:${account}`;
+        nextConfig = applyAuthProfileConfig(nextConfig, {
+            profileId,
+            provider: "chutes",
+            mode: "oauth",
+            email: account,
+        });
+    }
+    else if (params.authChoice === "github-copilot") {
+        try {
+            const { githubCopilotLoginCommand } = await import("../providers/github-copilot-auth.js");
+            await githubCopilotLoginCommand({ yes: true }, params.runtime);
+        }
+        catch (err) {
+            params.runtime.error(`GitHub Copilot login failed: ${String(err)}`);
+            params.runtime.exit(1);
+            return { config: nextConfig, agentModelOverride };
+        }
+        const profileId = "github-copilot:github";
+        nextConfig = applyAuthProfileConfig(nextConfig, {
+            profileId,
+            provider: "github-copilot",
+            mode: "token",
+        });
+        if (params.setDefaultModel) {
+            const existing = nextConfig.agent?.model;
+            const fallbacks = existing && typeof existing === "object" && "fallbacks" in existing
+                ? { fallbacks: existing.fallbacks }
+                : undefined;
+            nextConfig = {
+                ...nextConfig,
+                agent: {
+                    ...nextConfig.agent,
+                    model: {
+                        ...fallbacks,
+                        primary: "github-copilot/gpt-4o",
+                    },
+                },
+            };
+        }
+    }
     return { config: nextConfig, agentModelOverride };
 }

package/dist/commands/bootstrap-preset.js

@@ -1,9 +1,9 @@
+import { execFile } from "node:child_process";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { installSkill } from "../agents/skills-install.js";
-import { resolveStateDir } from "../config/paths.js";
+import { resolveBootstrapPath, resolveStateDir } from "../config/paths.js";
 import { NEXUS_ROOT } from "../utils.js";
 const execFileAsync = promisify(execFile);
 function firstName(full) {
@@ -15,7 +15,10 @@ function firstName(full) {
 function coerceStringArray(input) {
     if (!Array.isArray(input))
         return [];
-    return input.map((v) => String(v)).map((s) => s.trim()).filter(Boolean);
+    return input
+        .map((v) => String(v))
+        .map((s) => s.trim())
+        .filter(Boolean);
 }
 function parseEveWhoamiJson(stdout) {
     const raw = stdout.trim();
@@ -104,16 +107,15 @@ export async function applyBootstrapPreset(params) {
     const { workspaceDir, runtime } = params;
     const stateDir = resolveStateDir();
     const agentId = process.env.NEXUS_AGENT_ID?.trim() || "default";
-    const agentIdentityDir = path.join(stateDir, "agents", agentId, "identity");
-    const userIdentityDir = path.join(stateDir, "user", "identity");
-    const onboardingDir = path.join(stateDir, "nexus", "onboarding");
-    const bootstrapPath = path.join(onboardingDir, "BOOTSTRAP.md");
+    const agentIdentityDir = path.join(stateDir, "agents", agentId);
+    const userIdentityDir = path.join(stateDir, "user");
+    const bootstrapPath = resolveBootstrapPath(undefined, stateDir);
     if (!(await fileExists(bootstrapPath)))
         return;
     await fs.mkdir(agentIdentityDir, { recursive: true });
     await fs.mkdir(userIdentityDir, { recursive: true });
     const identityPath = path.join(agentIdentityDir, "IDENTITY.md");
-    const userPath = path.join(userIdentityDir, "PROFILE.md");
+    const userPath = path.join(userIdentityDir, "IDENTITY.md");
     const soulPath = path.join(agentIdentityDir, "SOUL.md");
     const agentsPath = path.join(NEXUS_ROOT, "AGENTS.md");
     const preset = resolvePreset(params.preset);
@@ -151,7 +153,9 @@ export async function applyBootstrapPreset(params) {
                 runtime.log(`Eve init failed; continuing without Eve identity: ${err instanceof Error ? err.message : String(err)}`);
             }
             try {
-                const res = await execFileAsync(eveCmd, ["whoami"], { timeout: 30_000 });
+                const res = await execFileAsync(eveCmd, ["whoami"], {
+                    timeout: 30_000,
+                });
                 const whoami = parseEveWhoamiJson(res.stdout);
                 if (whoami?.name)
                     userName = whoami.name;
@@ -169,17 +173,27 @@ export async function applyBootstrapPreset(params) {
         userName = "Test User";
     if (!preferredAddress)
         preferredAddress = firstName(userName) || "friend";
-    const identityMd = `# IDENTITY.md - Agent Identity
+    const identityMd = `---
+name: ${agentName}
+emoji: ${preset.emoji}
+creature: ${preset.creature}
+vibe: ${preset.vibe}
+---
+# IDENTITY.md - Agent Identity
 
 - Name: ${agentName}
 - Creature: ${preset.creature}
 - Vibe: ${preset.vibe}
 - Emoji: ${preset.emoji}
 `;
-    const userMd = `# PROFILE.md - User Profile
+    const userMd = `---
+name: ${userName}
+call: ${preferredAddress}
+---
+# IDENTITY.md - User Identity
 
 - Name: ${userName}
-- Preferred address: ${preferredAddress}
+- What to call them: ${preferredAddress}
 - Pronouns (optional):
 - Timezone (optional):
 - Notes:

package/dist/commands/capabilities.js

@@ -1,5 +1,5 @@
-import { defaultRuntime } from "../runtime.js";
 import { detectCapabilities } from "../capabilities/detector.js";
+import { defaultRuntime } from "../runtime.js";
 const STATUS_ICON = {
     active: "✅",
     ready: "⭐",
@@ -8,28 +8,55 @@ const STATUS_ICON = {
     unavailable: "⛔",
     broken: "❌",
 };
+function normalizeCategory(input) {
+    return input.toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function normalizeStatus(input) {
+    if (!input)
+        return undefined;
+    return input.toLowerCase().replace(/-/g, "_");
+}
 export async function capabilitiesCommand(opts, runtime = defaultRuntime) {
     const { registry, capabilities, summary } = detectCapabilities();
+    const statusFilter = normalizeStatus(opts?.status);
+    const categoryFilter = opts?.category
+        ? normalizeCategory(opts.category)
+        : undefined;
+    const filtered = capabilities.filter((cap) => {
+        if (statusFilter && cap.status !== statusFilter)
+            return false;
+        if (categoryFilter) {
+            const normalized = normalizeCategory(cap.category);
+            if (normalized !== categoryFilter)
+                return false;
+        }
+        return true;
+    });
     if (opts?.json) {
         runtime.log(JSON.stringify({
             platform: `${process.platform}/${process.arch}`,
             summary,
-            capabilities,
+            capabilities: filtered,
         }, null, 2));
         return;
     }
     runtime.log(`\nNexus Capabilities (${process.platform}/${process.arch})`);
     runtime.log("Legend: ✅ active  ⭐ ready  🔧 needs-setup  📥 needs-install  ⛔ unavailable  ❌ broken\n");
-    for (const [category, entries] of Object.entries(registry.categories)) {
-        const categoryCaps = capabilities.filter((cap) => cap.category === category);
+    for (const [category, _entries] of Object.entries(registry.categories)) {
+        const categoryCaps = filtered.filter((cap) => cap.category === category);
         if (categoryCaps.length === 0)
             continue;
         const activeCount = categoryCaps.filter((cap) => cap.status === "active").length;
         runtime.log(`${category} (${activeCount}/${categoryCaps.length})`);
         for (const cap of categoryCaps) {
             const icon = STATUS_ICON[cap.status] ?? "•";
-            const providers = cap.providers.map((p) => p.id).join(", ");
-            runtime.log(`  ${icon} ${cap.id} — ${providers || cap.providersRaw}`);
+            if (opts?.compact) {
+                runtime.log(`  ${icon} ${cap.id}`);
+            }
+            else {
+                const providers = cap.providers.map((p) => p.id).join(", ");
+                runtime.log(`  ${icon} ${cap.id} — ${providers || cap.providersRaw}`);
+            }
         }
         runtime.log("");
     }

package/dist/commands/claude-md.js

@@ -1,6 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { buildWorkspaceSkillSnapshot, loadWorkspaceSkillEntries, getSkillMetadata } from "../agents/skills.js";
+import { buildWorkspaceSkillSnapshot, getSkillMetadata, loadWorkspaceSkillEntries, } from "../agents/skills.js";
 import { loadConfig } from "../config/config.js";
 import { defaultRuntime } from "../runtime.js";
 /**
@@ -17,7 +17,8 @@ import { defaultRuntime } from "../runtime.js";
  *   nexus claude-md [--workspace <path>]
  */
 export async function claudeMdCommand(opts, runtime = defaultRuntime) {
-    const workspaceDir = opts?.workspace?.trim() || path.join(process.env.HOME || "~", "nexus", "home");
+    const workspaceDir = opts?.workspace?.trim() ||
+        path.join(process.env.HOME || "~", "nexus", "home");
     runtime.log(`Generating CLAUDE.md for workspace: ${workspaceDir}`);
     // Load config
     const config = loadConfig();

package/dist/commands/config-view.js

@@ -1,5 +1,5 @@
-import { defaultRuntime } from "../runtime.js";
 import { readConfigFileSnapshot } from "../config/config.js";
+import { defaultRuntime } from "../runtime.js";
 export async function configViewCommand(opts, runtime = defaultRuntime) {
     const snapshot = await readConfigFileSnapshot();
     if (opts?.json) {

package/dist/commands/config.js

@@ -0,0 +1,85 @@
+import { loadConfig, readConfigFileSnapshot, writeConfigFile } from "../config/config.js";
+import { defaultRuntime } from "../runtime.js";
+function getByPath(obj, key) {
+    const parts = key.split(".").filter(Boolean);
+    let current = obj;
+    for (const part of parts) {
+        if (!current || typeof current !== "object")
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+function setByPath(obj, key, value) {
+    const parts = key.split(".").filter(Boolean);
+    let current = obj;
+    for (let i = 0; i < parts.length; i += 1) {
+        const part = parts[i];
+        if (i === parts.length - 1) {
+            current[part] = value;
+            break;
+        }
+        const next = current[part];
+        if (!next || typeof next !== "object") {
+            current[part] = {};
+        }
+        current = current[part];
+    }
+    return obj;
+}
+function parseValue(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return "";
+    if (trimmed === "true")
+        return true;
+    if (trimmed === "false")
+        return false;
+    if (!Number.isNaN(Number(trimmed)))
+        return Number(trimmed);
+    if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+        (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return trimmed;
+        }
+    }
+    return trimmed;
+}
+export async function configListCommand(opts, runtime = defaultRuntime) {
+    const snapshot = await readConfigFileSnapshot();
+    const payload = snapshot.valid ? snapshot.parsed : {};
+    if (opts?.json) {
+        runtime.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    runtime.log(JSON.stringify(payload, null, 2));
+}
+export async function configGetCommand(opts, runtime = defaultRuntime) {
+    const config = loadConfig();
+    const value = getByPath(config, opts.key);
+    if (opts.json) {
+        runtime.log(JSON.stringify({ key: opts.key, value }, null, 2));
+        return;
+    }
+    if (typeof value === "string") {
+        runtime.log(value);
+        return;
+    }
+    runtime.log(JSON.stringify(value ?? null, null, 2));
+}
+export async function configSetCommand(opts, runtime = defaultRuntime) {
+    const snapshot = await readConfigFileSnapshot();
+    const base = snapshot.valid && snapshot.parsed && typeof snapshot.parsed === "object"
+        ? snapshot.parsed
+        : {};
+    const next = setByPath({ ...base }, opts.key, parseValue(opts.value));
+    await writeConfigFile(next);
+    if (opts.json) {
+        runtime.log(JSON.stringify({ key: opts.key, value: getByPath(next, opts.key) }, null, 2));
+        return;
+    }
+    runtime.log(`Updated ${opts.key}`);
+}

package/dist/commands/configure.js

@@ -430,11 +430,11 @@ export async function runConfigureWizard(opts, runtime = defaultRuntime) {
         }
     }
     const localUrl = "ws://127.0.0.1:18789";
-    const localToken = baseConfig.gateway?.auth?.token ?? process.env.NEXUS_GATEWAY_TOKEN;
+    const _localToken = baseConfig.gateway?.auth?.token ?? process.env.NEXUS_GATEWAY_TOKEN;
     const configPassword = baseConfig.gateway?.auth?.password;
     const envPassword = process.env.NEXUS_GATEWAY_PASSWORD;
-    const primaryPassword = configPassword ?? envPassword;
-    let localProbe = await probeGatewayReachable({
+    const _primaryPassword = configPassword ?? envPassword;
+    const localProbe = await probeGatewayReachable({
         url: localUrl,
         token: baseConfig.gateway?.auth?.token ?? process.env.CLAWDBOT_GATEWAY_TOKEN,
         password: baseConfig.gateway?.auth?.password ??
@@ -599,7 +599,7 @@ export async function runConfigureWizard(opts, runtime = defaultRuntime) {
             password: oldPassword,
         });
     }
-    const gatewayStatusLine = gatewayProbe.ok
+    const _gatewayStatusLine = gatewayProbe.ok
         ? "Gateway: reachable"
         : `Gateway: not detected${gatewayProbe.detail ? ` (${gatewayProbe.detail})` : ""}`;
     note((() => {