@intent-systems/nexus 2026.1.5-3

package/dist/commands/onboard-eve-identity.js

@@ -0,0 +1,98 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { installSkill } from "../agents/skills-install.js";
+const execFileAsync = promisify(execFile);
+function coerceStringArray(input) {
+    if (!Array.isArray(input))
+        return [];
+    return input.map((v) => String(v)).map((s) => s.trim()).filter(Boolean);
+}
+function parseEveWhoamiJson(stdout) {
+    const raw = stdout.trim();
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return {
+            ok: typeof parsed.ok === "boolean" ? parsed.ok : undefined,
+            name: typeof parsed.name === "string" ? parsed.name : undefined,
+            phones: coerceStringArray(parsed.phones),
+            emails: coerceStringArray(parsed.emails),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function hasBin(bin) {
+    try {
+        const result = await execFileAsync("bash", ["-lc", `command -v ${bin}`], {
+            timeout: 5000,
+        });
+        return Boolean(result.stdout.trim());
+    }
+    catch {
+        return false;
+    }
+}
+export async function maybeSetupIdentityFromEve(params) {
+    const { workspaceDir, prompter, runtime } = params;
+    if (process.platform !== "darwin")
+        return;
+    const wants = await prompter.confirm({
+        message: "Auto-detect your name/phone/email from Messages using Eve? (installs the eve CLI if needed)",
+        initialValue: true,
+    });
+    if (!wants)
+        return;
+    // Ensure eve binary exists (via skills installer so the user sees what's happening)
+    const hasEve = await hasBin("eve");
+    if (!hasEve) {
+        runtime.log("Installing Eve CLI (skill installer)…");
+        const result = await installSkill({
+            workspaceDir,
+            skillName: "eve",
+            installId: "brew",
+            timeoutMs: 15 * 60_000,
+        });
+        if (!result.ok) {
+            await prompter.note(`Eve install failed: ${result.message}\n\nstdout:\n${result.stdout}\n\nstderr:\n${result.stderr}`, "Eve install");
+            return;
+        }
+    }
+    // Ensure databases exist (idempotent)
+    try {
+        await execFileAsync("eve", ["init"], { timeout: 60_000 });
+    }
+    catch (err) {
+        await prompter.note(`Eve init failed: ${err instanceof Error ? err.message : String(err)}`, "Eve init");
+        return;
+    }
+    // Run whoami and parse JSON output
+    let whoami = null;
+    try {
+        const res = await execFileAsync("eve", ["whoami"], { timeout: 30_000 });
+        whoami = parseEveWhoamiJson(res.stdout);
+    }
+    catch (err) {
+        await prompter.note(`Eve whoami failed: ${err instanceof Error ? err.message : String(err)}`, "Eve whoami");
+        return;
+    }
+    if (!whoami?.name && (!whoami?.phones?.length && !whoami?.emails?.length)) {
+        await prompter.note("Eve ran, but didn't return identity info in a readable format.", "Eve whoami");
+        return;
+    }
+    const summaryLines = [
+        whoami.name ? `Name: ${whoami.name}` : undefined,
+        whoami.phones && whoami.phones.length
+            ? `Phones: ${whoami.phones.join(", ")}`
+            : undefined,
+        whoami.emails && whoami.emails.length
+            ? `Emails: ${whoami.emails.join(", ")}`
+            : undefined,
+    ].filter(Boolean);
+    await prompter.note(summaryLines.join("\n"), "Detected identity (Eve)");
+    // NOTE: We don't directly edit IDENTITY.md / PROFILE.md here yet; the bootstrap ritual
+    // should incorporate these values when it runs. Next step: write this into config
+    // and/or workspace files once we agree on the exact schema + wording.
+}

package/dist/commands/onboard-github.js

@@ -0,0 +1,153 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+/**
+ * Check if gh CLI is installed and authenticated
+ */
+async function checkGhCli() {
+    try {
+        await execFileAsync("gh", ["--version"]);
+    }
+    catch {
+        return { installed: false, authenticated: false };
+    }
+    try {
+        const result = await execFileAsync("gh", ["auth", "status"]);
+        // Try to extract username
+        const usernameMatch = result.stdout.match(/Logged in to github\.com account (\S+)/);
+        const username = usernameMatch?.[1];
+        return { installed: true, authenticated: true, username };
+    }
+    catch {
+        return { installed: true, authenticated: false };
+    }
+}
+/**
+ * Check if a directory has a git remote
+ */
+async function hasGitRemote(dir) {
+    try {
+        const result = await execFileAsync("git", ["remote", "get-url", "origin"], {
+            cwd: dir,
+        });
+        return { hasRemote: true, remoteUrl: result.stdout.trim() };
+    }
+    catch {
+        return { hasRemote: false };
+    }
+}
+/**
+ * Check if directory is a git repo
+ */
+function isGitRepo(dir) {
+    return fs.existsSync(path.join(dir, ".git"));
+}
+/**
+ * Create a private GitHub repo and push
+ */
+async function createGitHubRepo(dir, repoName) {
+    try {
+        // Use gh to create repo and push
+        const result = await execFileAsync("gh", ["repo", "create", repoName, "--private", "--source", dir, "--push"], { cwd: dir });
+        // Extract repo URL from output
+        const urlMatch = result.stdout.match(/https:\/\/github\.com\/\S+/);
+        const url = urlMatch?.[0];
+        return { ok: true, url };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { ok: false, error: message };
+    }
+}
+/**
+ * Set up GitHub sync for the user's workspace
+ */
+export async function setupGitHubSync(workspaceDir, prompter, runtime) {
+    // Check if workspace is a git repo
+    if (!isGitRepo(workspaceDir)) {
+        runtime.log("Workspace is not a git repository, skipping GitHub sync setup.");
+        return;
+    }
+    // Check if already has remote
+    const remoteCheck = await hasGitRemote(workspaceDir);
+    if (remoteCheck.hasRemote) {
+        await prompter.note(`Your workspace is already synced to:\n${remoteCheck.remoteUrl}`, "GitHub Sync");
+        return;
+    }
+    // Ask if user wants to set up sync
+    const wantsSync = await prompter.confirm({
+        message: "Set up cloud sync for your workspace? (Creates a private GitHub repo)",
+        initialValue: true,
+    });
+    if (!wantsSync) {
+        await prompter.note("You can set up sync later by running:\n  cd ~/nexus/home && gh repo create nexus-home --private --source . --push", "GitHub Sync (skipped)");
+        return;
+    }
+    // Check gh CLI
+    const ghStatus = await checkGhCli();
+    if (!ghStatus.installed) {
+        await prompter.note([
+            "GitHub CLI (gh) is not installed.",
+            "",
+            "Install it with: brew install gh",
+            "Then authenticate with: gh auth login",
+            "",
+            "After that, you can sync your workspace with:",
+            "  cd ~/nexus/home && gh repo create nexus-home --private --source . --push",
+        ].join("\n"), "GitHub CLI Required");
+        return;
+    }
+    if (!ghStatus.authenticated) {
+        await prompter.note([
+            "GitHub CLI is installed but not authenticated.",
+            "",
+            "Run: gh auth login",
+            "",
+            "After that, you can sync your workspace with:",
+            "  cd ~/nexus/home && gh repo create nexus-home --private --source . --push",
+        ].join("\n"), "GitHub Auth Required");
+        return;
+    }
+    // Ask for repo name
+    const defaultName = "nexus-home";
+    const repoName = await prompter.text({
+        message: "Repository name:",
+        initialValue: defaultName,
+        placeholder: defaultName,
+    });
+    if (!repoName) {
+        return;
+    }
+    runtime.log(`Creating private repository '${repoName}'...`);
+    // Make sure we have a commit to push
+    try {
+        await execFileAsync("git", ["rev-parse", "HEAD"], { cwd: workspaceDir });
+    }
+    catch {
+        // No commits yet, create initial commit
+        runtime.log("Creating initial commit...");
+        await execFileAsync("git", ["add", "-A"], { cwd: workspaceDir });
+        await execFileAsync("git", ["commit", "-m", "Initial Nexus workspace"], {
+            cwd: workspaceDir,
+        });
+    }
+    const result = await createGitHubRepo(workspaceDir, repoName);
+    if (result.ok) {
+        await prompter.note([
+            `✓ Workspace synced to: ${result.url || `github.com/${ghStatus.username}/${repoName}`}`,
+            "",
+            "To sync from another machine:",
+            `  git clone git@github.com:${ghStatus.username}/${repoName}.git ~/nexus/home`,
+        ].join("\n"), "GitHub Sync Complete");
+    }
+    else {
+        await prompter.note([
+            `Failed to create repository: ${result.error}`,
+            "",
+            "You can try manually:",
+            `  cd ~/nexus/home && gh repo create ${repoName} --private --source . --push`,
+        ].join("\n"), "GitHub Sync Error");
+    }
+}

package/dist/commands/onboard-helpers.js

@@ -0,0 +1,303 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { inspect } from "node:util";
+import { cancel, isCancel } from "@clack/prompts";
+import { DEFAULT_AGENT_WORKSPACE_DIR, ensureAgentWorkspace, } from "../agents/workspace.js";
+import { CONFIG_PATH_NEXUS } from "../config/config.js";
+import { resolveSessionTranscriptsDir } from "../config/sessions.js";
+import { callGateway } from "../gateway/call.js";
+import { normalizeControlUiBasePath } from "../gateway/control-ui.js";
+import { pickPrimaryTailnetIPv4 } from "../infra/tailnet.js";
+import { runCommandWithTimeout } from "../process/exec.js";
+import { CONFIG_DIR, resolveUserPath } from "../utils.js";
+import { VERSION } from "../version.js";
+export function guardCancel(value, runtime) {
+    if (isCancel(value)) {
+        cancel("Setup cancelled.");
+        runtime.exit(0);
+    }
+    return value;
+}
+export function summarizeExistingConfig(config) {
+    const rows = [];
+    if (config.agent?.workspace)
+        rows.push(`workspace: ${config.agent.workspace}`);
+    if (config.agent?.model) {
+        const model = typeof config.agent.model === "string"
+            ? config.agent.model
+            : config.agent.model.primary;
+        if (model)
+            rows.push(`model: ${model}`);
+    }
+    if (config.gateway?.mode)
+        rows.push(`gateway.mode: ${config.gateway.mode}`);
+    if (typeof config.gateway?.port === "number") {
+        rows.push(`gateway.port: ${config.gateway.port}`);
+    }
+    if (config.gateway?.bind)
+        rows.push(`gateway.bind: ${config.gateway.bind}`);
+    if (config.gateway?.remote?.url) {
+        rows.push(`gateway.remote.url: ${config.gateway.remote.url}`);
+    }
+    if (config.skills?.install?.nodeManager) {
+        rows.push(`skills.nodeManager: ${config.skills.install.nodeManager}`);
+    }
+    return rows.length ? rows.join("\n") : "No key settings detected.";
+}
+export function randomToken() {
+    return crypto.randomBytes(24).toString("hex");
+}
+export function printWizardHeader(runtime) {
+    const header = [
+        "░████░█░░░░░█████░█░░░█░███░░████░░████░░▀█▀",
+        "█░░░░░█░░░░░█░░░█░█░█░█░█░░█░█░░░█░█░░░█░░█░",
+        "█░░░░░█░░░░░█████░█░█░█░█░░█░████░░█░░░█░░█░",
+        "█░░░░░█░░░░░█░░░█░█░█░█░█░░█░█░░█░░█░░░█░░█░",
+        "░████░█████░█░░░█░░█░█░░███░░████░░░███░░░█░",
+        "              🦞 FRESH DAILY 🦞",
+    ].join("\n");
+    runtime.log(header);
+}
+export function applyWizardMetadata(cfg, params) {
+    const commit = process.env.GIT_COMMIT?.trim() || process.env.GIT_SHA?.trim() || undefined;
+    return {
+        ...cfg,
+        wizard: {
+            ...cfg.wizard,
+            lastRunAt: new Date().toISOString(),
+            lastRunVersion: VERSION,
+            lastRunCommit: commit,
+            lastRunCommand: params.command,
+            lastRunMode: params.mode,
+        },
+    };
+}
+let wslCached = null;
+async function isWSL() {
+    if (wslCached !== null)
+        return wslCached;
+    if (process.platform !== "linux") {
+        wslCached = false;
+        return wslCached;
+    }
+    if (process.env.WSL_INTEROP ||
+        process.env.WSL_DISTRO_NAME ||
+        process.env.WSLENV) {
+        wslCached = true;
+        return wslCached;
+    }
+    try {
+        const release = (await fs.readFile("/proc/version", "utf8")).toLowerCase();
+        wslCached = release.includes("microsoft") || release.includes("wsl");
+    }
+    catch {
+        wslCached = false;
+    }
+    return wslCached;
+}
+async function resolveBrowserOpenCommand() {
+    const platform = process.platform;
+    const hasDisplay = Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
+    const isSsh = Boolean(process.env.SSH_CLIENT) ||
+        Boolean(process.env.SSH_TTY) ||
+        Boolean(process.env.SSH_CONNECTION);
+    if (isSsh && !hasDisplay && platform !== "win32") {
+        return { argv: null, reason: "ssh-no-display" };
+    }
+    if (platform === "win32") {
+        return { argv: ["cmd", "/c", "start", ""], command: "cmd" };
+    }
+    if (platform === "darwin") {
+        const hasOpen = await detectBinary("open");
+        return hasOpen
+            ? { argv: ["open"], command: "open" }
+            : { argv: null, reason: "missing-open" };
+    }
+    if (platform === "linux") {
+        const wsl = await isWSL();
+        if (!hasDisplay && !wsl) {
+            return { argv: null, reason: "no-display" };
+        }
+        if (wsl) {
+            const hasWslview = await detectBinary("wslview");
+            if (hasWslview)
+                return { argv: ["wslview"], command: "wslview" };
+            if (!hasDisplay)
+                return { argv: null, reason: "wsl-no-wslview" };
+        }
+        const hasXdgOpen = await detectBinary("xdg-open");
+        return hasXdgOpen
+            ? { argv: ["xdg-open"], command: "xdg-open" }
+            : { argv: null, reason: "missing-xdg-open" };
+    }
+    return { argv: null, reason: "unsupported-platform" };
+}
+export async function detectBrowserOpenSupport() {
+    const resolved = await resolveBrowserOpenCommand();
+    if (!resolved.argv)
+        return { ok: false, reason: resolved.reason };
+    return { ok: true, command: resolved.command };
+}
+export function formatControlUiSshHint(params) {
+    const basePath = normalizeControlUiBasePath(params.basePath);
+    const uiPath = basePath ? `${basePath}/` : "/";
+    const localUrl = `http://localhost:${params.port}${uiPath}`;
+    const tokenParam = params.token
+        ? `?token=${encodeURIComponent(params.token)}`
+        : "";
+    const authedUrl = params.token ? `${localUrl}${tokenParam}` : undefined;
+    const sshTarget = resolveSshTargetHint();
+    return [
+        "No GUI detected. Open from your computer:",
+        `ssh -N -L ${params.port}:127.0.0.1:${params.port} ${sshTarget}`,
+        "Then open:",
+        localUrl,
+        authedUrl,
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+function resolveSshTargetHint() {
+    const user = process.env.USER || process.env.LOGNAME || "user";
+    const conn = process.env.SSH_CONNECTION?.trim().split(/\s+/);
+    const host = conn?.[2] ?? "<host>";
+    return `${user}@${host}`;
+}
+export async function openUrl(url) {
+    const resolved = await resolveBrowserOpenCommand();
+    if (!resolved.argv)
+        return false;
+    const command = [...resolved.argv, url];
+    try {
+        await runCommandWithTimeout(command, { timeoutMs: 5_000 });
+        return true;
+    }
+    catch {
+        // ignore; we still print the URL for manual open
+        return false;
+    }
+}
+export async function ensureWorkspaceAndSessions(workspaceDir, runtime, options) {
+    const ws = await ensureAgentWorkspace({
+        dir: workspaceDir,
+        ensureBootstrapFiles: !options?.skipBootstrap,
+    });
+    runtime.log(`Workspace OK: ${ws.dir}`);
+    const sessionsDir = resolveSessionTranscriptsDir();
+    await fs.mkdir(sessionsDir, { recursive: true });
+    runtime.log(`Sessions OK: ${sessionsDir}`);
+}
+export function resolveNodeManagerOptions() {
+    return [
+        { value: "npm", label: "npm" },
+        { value: "pnpm", label: "pnpm" },
+        { value: "bun", label: "bun" },
+    ];
+}
+export async function moveToTrash(pathname, runtime) {
+    if (!pathname)
+        return;
+    try {
+        await fs.access(pathname);
+    }
+    catch {
+        return;
+    }
+    try {
+        await runCommandWithTimeout(["trash", pathname], { timeoutMs: 5000 });
+        runtime.log(`Moved to Trash: ${pathname}`);
+    }
+    catch {
+        runtime.log(`Failed to move to Trash (manual delete): ${pathname}`);
+    }
+}
+export async function handleReset(scope, workspaceDir, runtime) {
+    await moveToTrash(CONFIG_PATH_NEXUS, runtime);
+    if (scope === "config")
+        return;
+    await moveToTrash(path.join(CONFIG_DIR, "credentials"), runtime);
+    await moveToTrash(resolveSessionTranscriptsDir(), runtime);
+    if (scope === "full") {
+        await moveToTrash(workspaceDir, runtime);
+    }
+}
+export async function detectBinary(name) {
+    if (!name?.trim())
+        return false;
+    const resolved = name.startsWith("~") ? resolveUserPath(name) : name;
+    if (path.isAbsolute(resolved) || resolved.startsWith(".")) {
+        try {
+            await fs.access(resolved);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    const command = process.platform === "win32"
+        ? ["where", name]
+        : ["/usr/bin/env", "sh", "-lc", `command -v ${name}`];
+    try {
+        const result = await runCommandWithTimeout(command, { timeoutMs: 2000 });
+        return result.code === 0 && result.stdout.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+export async function probeGatewayReachable(params) {
+    const url = params.url.trim();
+    const timeoutMs = params.timeoutMs ?? 1500;
+    try {
+        await callGateway({
+            url,
+            token: params.token,
+            password: params.password,
+            method: "health",
+            timeoutMs,
+            clientName: "nexus-probe",
+            mode: "probe",
+        });
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, detail: summarizeError(err) };
+    }
+}
+function summarizeError(err) {
+    let raw = "unknown error";
+    if (err instanceof Error) {
+        raw = err.message || raw;
+    }
+    else if (typeof err === "string") {
+        raw = err || raw;
+    }
+    else if (err !== undefined) {
+        raw = inspect(err, { depth: 2 });
+    }
+    const line = raw
+        .split("\n")
+        .map((s) => s.trim())
+        .find(Boolean) ?? raw;
+    return line.length > 120 ? `${line.slice(0, 119)}…` : line;
+}
+export const DEFAULT_WORKSPACE = DEFAULT_AGENT_WORKSPACE_DIR;
+export function resolveControlUiLinks(params) {
+    const port = params.port;
+    const bind = params.bind ?? "loopback";
+    const tailnetIPv4 = pickPrimaryTailnetIPv4();
+    const customHost = params.customBindHost?.trim();
+    const host = customHost
+        ? customHost
+        : bind === "tailnet" || (bind === "auto" && tailnetIPv4)
+            ? (tailnetIPv4 ?? "127.0.0.1")
+            : "127.0.0.1";
+    const basePath = normalizeControlUiBasePath(params.basePath);
+    const uiPath = basePath ? `${basePath}/` : "/";
+    const wsPath = basePath ? basePath : "";
+    return {
+        httpUrl: `http://${host}:${port}${uiPath}`,
+        wsUrl: `ws://${host}:${port}${wsPath}`,
+    };
+}

package/dist/commands/onboard-interactive.js

@@ -0,0 +1,17 @@
+import { defaultRuntime } from "../runtime.js";
+import { createClackPrompter } from "../wizard/clack-prompter.js";
+import { runOnboardingWizard } from "../wizard/onboarding.js";
+import { WizardCancelledError } from "../wizard/prompts.js";
+export async function runInteractiveOnboarding(opts, runtime = defaultRuntime) {
+    const prompter = createClackPrompter();
+    try {
+        await runOnboardingWizard(opts, runtime, prompter);
+    }
+    catch (err) {
+        if (err instanceof WizardCancelledError) {
+            runtime.exit(0);
+            return;
+        }
+        throw err;
+    }
+}