@intent-systems/nexus 2026.1.5-3

package/dist/commands/setup.js

@@ -0,0 +1,59 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import JSON5 from "json5";
+import { DEFAULT_AGENT_WORKSPACE_DIR, ensureAgentWorkspace } from "../agents/workspace.js";
+import { CONFIG_PATH_NEXUS } from "../config/config.js";
+import { applyModelDefaults } from "../config/defaults.js";
+import { resolveSessionTranscriptsDir } from "../config/sessions.js";
+import { defaultRuntime } from "../runtime.js";
+async function readConfigFileRaw() {
+    try {
+        const raw = await fs.readFile(CONFIG_PATH_NEXUS, "utf-8");
+        const parsed = JSON5.parse(raw);
+        if (parsed && typeof parsed === "object") {
+            return { exists: true, parsed: parsed };
+        }
+        return { exists: true, parsed: {} };
+    }
+    catch {
+        return { exists: false, parsed: {} };
+    }
+}
+async function writeConfigFile(cfg) {
+    await fs.mkdir(path.dirname(CONFIG_PATH_NEXUS), { recursive: true });
+    const json = JSON.stringify(applyModelDefaults(cfg), null, 2).trimEnd().concat("\n");
+    await fs.writeFile(CONFIG_PATH_NEXUS, json, "utf-8");
+}
+export async function setupCommand(opts, runtime = defaultRuntime) {
+    const desiredWorkspace = typeof opts?.workspace === "string" && opts.workspace.trim()
+        ? opts.workspace.trim()
+        : undefined;
+    const existingRaw = await readConfigFileRaw();
+    const cfg = existingRaw.parsed;
+    const agent = cfg.agent ?? {};
+    const workspace = desiredWorkspace ?? agent.workspace ?? DEFAULT_AGENT_WORKSPACE_DIR;
+    const next = {
+        ...cfg,
+        agent: {
+            ...agent,
+            workspace,
+        },
+    };
+    if (!existingRaw.exists || agent.workspace !== workspace) {
+        await writeConfigFile(next);
+        runtime.log(!existingRaw.exists
+            ? `Wrote ${CONFIG_PATH_NEXUS}`
+            : `Updated ${CONFIG_PATH_NEXUS} (set agent.workspace)`);
+    }
+    else {
+        runtime.log(`Config OK: ${CONFIG_PATH_NEXUS}`);
+    }
+    const ws = await ensureAgentWorkspace({
+        dir: workspace,
+        ensureBootstrapFiles: !next.agent?.skipBootstrap,
+    });
+    runtime.log(`Workspace OK: ${ws.dir}`);
+    const sessionsDir = resolveSessionTranscriptsDir();
+    await fs.mkdir(sessionsDir, { recursive: true });
+    runtime.log(`Sessions OK: ${sessionsDir}`);
+}

package/dist/commands/signal-install.js

@@ -0,0 +1,135 @@
+import { createWriteStream } from "node:fs";
+import fs from "node:fs/promises";
+import { request } from "node:https";
+import os from "node:os";
+import path from "node:path";
+import { pipeline } from "node:stream/promises";
+import { runCommandWithTimeout } from "../process/exec.js";
+import { CONFIG_DIR } from "../utils.js";
+function looksLikeArchive(name) {
+    return (name.endsWith(".tar.gz") || name.endsWith(".tgz") || name.endsWith(".zip"));
+}
+function pickAsset(assets, platform) {
+    const withName = assets.filter((asset) => Boolean(asset.name && asset.browser_download_url));
+    const byName = (pattern) => withName.find((asset) => pattern.test(asset.name.toLowerCase()));
+    if (platform === "linux") {
+        return (byName(/linux-native/) ||
+            byName(/linux/) ||
+            withName.find((asset) => looksLikeArchive(asset.name.toLowerCase())));
+    }
+    if (platform === "darwin") {
+        return (byName(/macos|osx|darwin/) ||
+            withName.find((asset) => looksLikeArchive(asset.name.toLowerCase())));
+    }
+    if (platform === "win32") {
+        return (byName(/windows|win/) ||
+            withName.find((asset) => looksLikeArchive(asset.name.toLowerCase())));
+    }
+    return withName.find((asset) => looksLikeArchive(asset.name.toLowerCase()));
+}
+async function downloadToFile(url, dest, maxRedirects = 5) {
+    await new Promise((resolve, reject) => {
+        const req = request(url, (res) => {
+            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400) {
+                const location = res.headers.location;
+                if (!location || maxRedirects <= 0) {
+                    reject(new Error("Redirect loop or missing Location header"));
+                    return;
+                }
+                const redirectUrl = new URL(location, url).href;
+                resolve(downloadToFile(redirectUrl, dest, maxRedirects - 1));
+                return;
+            }
+            if (!res.statusCode || res.statusCode >= 400) {
+                reject(new Error(`HTTP ${res.statusCode ?? "?"} downloading file`));
+                return;
+            }
+            const out = createWriteStream(dest);
+            pipeline(res, out).then(resolve).catch(reject);
+        });
+        req.on("error", reject);
+        req.end();
+    });
+}
+async function findSignalCliBinary(root) {
+    const candidates = [];
+    const enqueue = async (dir, depth) => {
+        if (depth > 3)
+            return;
+        const entries = await fs
+            .readdir(dir, { withFileTypes: true })
+            .catch(() => []);
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await enqueue(full, depth + 1);
+            }
+            else if (entry.isFile() && entry.name === "signal-cli") {
+                candidates.push(full);
+            }
+        }
+    };
+    await enqueue(root, 0);
+    return candidates[0] ?? null;
+}
+export async function installSignalCli(runtime) {
+    if (process.platform === "win32") {
+        return {
+            ok: false,
+            error: "Signal CLI auto-install is not supported on Windows yet.",
+        };
+    }
+    const apiUrl = "https://api.github.com/repos/AsamK/signal-cli/releases/latest";
+    const response = await fetch(apiUrl, {
+        headers: {
+            "User-Agent": "nexus",
+            Accept: "application/vnd.github+json",
+        },
+    });
+    if (!response.ok) {
+        return {
+            ok: false,
+            error: `Failed to fetch release info (${response.status})`,
+        };
+    }
+    const payload = (await response.json());
+    const version = payload.tag_name?.replace(/^v/, "") ?? "unknown";
+    const assets = payload.assets ?? [];
+    const asset = pickAsset(assets, process.platform);
+    const assetName = asset?.name ?? "";
+    const assetUrl = asset?.browser_download_url ?? "";
+    if (!assetName || !assetUrl) {
+        return {
+            ok: false,
+            error: "No compatible release asset found for this platform.",
+        };
+    }
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "nexus-signal-"));
+    const archivePath = path.join(tmpDir, assetName);
+    runtime.log(`Downloading signal-cli ${version} (${assetName})…`);
+    await downloadToFile(assetUrl, archivePath);
+    const installRoot = path.join(CONFIG_DIR, "tools", "signal-cli", version);
+    await fs.mkdir(installRoot, { recursive: true });
+    if (assetName.endsWith(".zip")) {
+        await runCommandWithTimeout(["unzip", "-q", archivePath, "-d", installRoot], {
+            timeoutMs: 60_000,
+        });
+    }
+    else if (assetName.endsWith(".tar.gz") || assetName.endsWith(".tgz")) {
+        await runCommandWithTimeout(["tar", "-xzf", archivePath, "-C", installRoot], {
+            timeoutMs: 60_000,
+        });
+    }
+    else {
+        return { ok: false, error: `Unsupported archive type: ${assetName}` };
+    }
+    const cliPath = await findSignalCliBinary(installRoot);
+    if (!cliPath) {
+        return {
+            ok: false,
+            error: `signal-cli binary not found after extracting ${assetName}`,
+        };
+    }
+    await fs.chmod(cliPath, 0o755).catch(() => { });
+    return { ok: true, cliPath, version };
+}

package/dist/commands/skills-manifest.js

@@ -0,0 +1,235 @@
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveStateDir } from "../config/paths.js";
+/**
+ * Parse skill frontmatter to extract name and description
+ */
+function parseSkillFrontmatter(content) {
+    const result = {};
+    const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    if (!normalized.startsWith("---"))
+        return result;
+    const endIndex = normalized.indexOf("\n---", 3);
+    if (endIndex === -1)
+        return result;
+    const block = normalized.slice(4, endIndex);
+    for (const line of block.split("\n")) {
+        const match = line.match(/^(name|description):\s*(.*)$/);
+        if (!match)
+            continue;
+        const key = match[1];
+        let value = match[2].trim();
+        // Strip quotes
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        result[key] = value;
+    }
+    return result;
+}
+/**
+ * Resolve the bundled skills directory from the installed Nexus package.
+ * This finds skills shipped with the CLI, NOT from user workspace.
+ */
+export function resolveBundledSkillsDir() {
+    // Check env override first
+    const override = process.env.NEXUS_BUNDLED_SKILLS_DIR?.trim();
+    if (override && fs.existsSync(override))
+        return override;
+    // bun --compile: ship a sibling `skills/` next to the executable
+    try {
+        const execDir = path.dirname(process.execPath);
+        const sibling = path.join(execDir, "skills");
+        if (fs.existsSync(sibling))
+            return sibling;
+    }
+    catch {
+        // ignore
+    }
+    // npm/dev: resolve `<packageRoot>/skills` relative to this module
+    try {
+        const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+        const root = path.resolve(moduleDir, "..", "..");
+        const candidate = path.join(root, "skills");
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    catch {
+        // ignore
+    }
+    return undefined;
+}
+/**
+ * Scan a directory for SKILL.md files and return manifest entries
+ */
+async function scanSkillsDir(dir, source) {
+    const skills = {};
+    if (!fs.existsSync(dir)) {
+        return skills;
+    }
+    const entries = await fsp.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (entry.name.startsWith("."))
+            continue;
+        const skillPath = path.join(dir, entry.name, "SKILL.md");
+        if (!fs.existsSync(skillPath))
+            continue;
+        try {
+            const content = await fsp.readFile(skillPath, "utf-8");
+            const frontmatter = parseSkillFrontmatter(content);
+            const name = frontmatter.name || entry.name;
+            skills[name] = {
+                name,
+                description: frontmatter.description,
+                version: source === "bundled" ? "bundled" : "installed",
+                enabled: true,
+                source,
+                dirName: entry.name,
+            };
+        }
+        catch {
+            // Skip malformed skills
+        }
+    }
+    return skills;
+}
+/**
+ * Copy bundled skills from installed package to ~/nexus/skills/
+ */
+export async function copyBundledSkills(targetDir) {
+    const bundledDir = resolveBundledSkillsDir();
+    const result = {
+        copied: [],
+        skipped: [],
+        errors: [],
+    };
+    if (!bundledDir) {
+        result.errors.push("Bundled skills directory not found in package");
+        return result;
+    }
+    await fsp.mkdir(targetDir, { recursive: true });
+    const entries = await fsp.readdir(bundledDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (entry.name.startsWith("."))
+            continue;
+        const sourcePath = path.join(bundledDir, entry.name);
+        const targetPath = path.join(targetDir, entry.name);
+        // Check if SKILL.md exists
+        if (!fs.existsSync(path.join(sourcePath, "SKILL.md")))
+            continue;
+        try {
+            // Check if already exists
+            if (fs.existsSync(targetPath)) {
+                result.skipped.push(entry.name);
+                continue;
+            }
+            // Copy recursively
+            await fsp.cp(sourcePath, targetPath, { recursive: true });
+            result.copied.push(entry.name);
+        }
+        catch (err) {
+            result.errors.push(`${entry.name}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return result;
+}
+/**
+ * Generate a complete skill manifest by scanning skill directories
+ */
+export async function generateSkillManifest(skillsDir, userSkillsDir) {
+    // Skills in ~/nexus/skills/ are considered "bundled" (copied from package)
+    // Skills user installs via NexusHub go in a managed/ subfolder or directly
+    // User skills are in ~/nexus/home/skills/
+    const bundledSkills = await scanSkillsDir(skillsDir, "bundled");
+    // Check for managed subfolder (NexusHub installs)
+    const managedDir = path.join(skillsDir, "managed");
+    const managedSkills = fs.existsSync(managedDir)
+        ? await scanSkillsDir(managedDir, "managed")
+        : {};
+    // User skills from workspace
+    const userSkills = userSkillsDir
+        ? await scanSkillsDir(userSkillsDir, "user")
+        : {};
+    return {
+        version: 1,
+        lastUpdated: new Date().toISOString(),
+        bundled: {
+            count: Object.keys(bundledSkills).length,
+            skills: bundledSkills,
+        },
+        managed: {
+            count: Object.keys(managedSkills).length,
+            skills: managedSkills,
+        },
+        user: {
+            count: Object.keys(userSkills).length,
+            skills: userSkills,
+        },
+    };
+}
+/**
+ * Get the path to the skills manifest file
+ */
+export function getSkillManifestPath() {
+    return path.join(resolveStateDir(), "nexus", "skills", "manifest.json");
+}
+/**
+ * Write the skill manifest to disk
+ */
+export async function writeSkillManifest(manifest) {
+    const manifestPath = getSkillManifestPath();
+    const stateDir = path.dirname(manifestPath);
+    await fsp.mkdir(stateDir, { recursive: true });
+    await fsp.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+}
+/**
+ * Read the skill manifest from disk
+ */
+export async function readSkillManifest() {
+    const manifestPath = getSkillManifestPath();
+    try {
+        const content = await fsp.readFile(manifestPath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Get all skills as a flat list for display
+ */
+export function flattenManifest(manifest) {
+    const all = [];
+    // Add in precedence order: bundled < managed < user
+    for (const skill of Object.values(manifest.bundled.skills)) {
+        all.push(skill);
+    }
+    for (const skill of Object.values(manifest.managed.skills)) {
+        // Managed overrides bundled
+        const existingIdx = all.findIndex((s) => s.name === skill.name);
+        if (existingIdx >= 0) {
+            all[existingIdx] = skill;
+        }
+        else {
+            all.push(skill);
+        }
+    }
+    for (const skill of Object.values(manifest.user.skills)) {
+        // User overrides all
+        const existingIdx = all.findIndex((s) => s.name === skill.name);
+        if (existingIdx >= 0) {
+            all[existingIdx] = skill;
+        }
+        else {
+            all.push(skill);
+        }
+    }
+    return all.sort((a, b) => a.name.localeCompare(b.name));
+}

package/dist/commands/status.js

@@ -0,0 +1,139 @@
+import fs from "node:fs";
+import path from "node:path";
+import { detectCapabilities } from "../capabilities/detector.js";
+import { listCredentials } from "./credential.js";
+import { resolveStateDir } from "../config/paths.js";
+import { defaultRuntime } from "../runtime.js";
+function readField(pathname, label) {
+    try {
+        const raw = fs.readFileSync(pathname, "utf-8");
+        const regex = new RegExp(`^[-*]?\\s*${label}\\s*:\\s*(.+)$`, "im");
+        const match = raw.match(regex);
+        return match?.[1]?.trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+function getIdentitySnapshot() {
+    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 agentIdentityPath = path.join(agentIdentityDir, "IDENTITY.md");
+    const agentSoulPath = path.join(agentIdentityDir, "SOUL.md");
+    const agentMemoryPath = path.join(agentIdentityDir, "MEMORY.md");
+    const userProfilePath = path.join(userIdentityDir, "PROFILE.md");
+    const bootstrapPath = path.join(onboardingDir, "BOOTSTRAP.md");
+    const hasIdentity = fs.existsSync(agentIdentityPath) && fs.existsSync(userProfilePath);
+    const agentName = readField(agentIdentityPath, "Name");
+    const userName = readField(userProfilePath, "Name");
+    return {
+        agentId,
+        agentName,
+        userName,
+        agentIdentityPath,
+        agentSoulPath,
+        agentMemoryPath,
+        userProfilePath,
+        bootstrapPath,
+        hasIdentity,
+    };
+}
+function readBootstrapPrompt(pathname) {
+    try {
+        return fs.readFileSync(pathname, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+function formatSuggestions(capabilities) {
+    const picks = capabilities.filter((cap) => ["ready", "needs_setup", "needs_install", "broken"].includes(cap.status));
+    const sorted = picks.sort((a, b) => a.status.localeCompare(b.status));
+    return sorted.slice(0, 3).map((cap, idx) => ({
+        id: cap.id,
+        status: cap.status,
+        index: idx + 1,
+    }));
+}
+export async function statusCommand(opts, runtime = defaultRuntime) {
+    const identity = getIdentitySnapshot();
+    const bootstrapPrompt = !identity.hasIdentity
+        ? readBootstrapPrompt(identity.bootstrapPath)
+        : null;
+    const showBrief = opts.brief === true;
+    const showCredentials = opts.credentials === true || (!opts.capabilities && !showBrief);
+    const showCapabilities = opts.capabilities === true || (!opts.credentials && !showBrief);
+    const credentials = showCredentials ? await listCredentials() : null;
+    const capabilitySnapshot = showCapabilities ? detectCapabilities() : null;
+    const suggestions = capabilitySnapshot ? formatSuggestions(capabilitySnapshot.capabilities) : [];
+    if (opts.json) {
+        runtime.log(JSON.stringify({
+            platform: `${process.platform}/${process.arch}`,
+            identity,
+            bootstrap: bootstrapPrompt ? { required: true, prompt: bootstrapPrompt } : undefined,
+            credentials: credentials ?? undefined,
+            capabilities: capabilitySnapshot ?? undefined,
+            suggestions,
+        }, null, 2));
+        return;
+    }
+    runtime.log(`\nNexus Status (${process.platform}/${process.arch})`);
+    if (bootstrapPrompt) {
+        runtime.log("\nBootstrap required (identity missing).");
+        runtime.log(`\nBootstrap prompt (${identity.bootstrapPath}):\n`);
+        runtime.log(bootstrapPrompt.trimEnd());
+        return;
+    }
+    runtime.log("\nIdentity");
+    runtime.log(`  User: ${identity.userName ?? "(unknown)"} → ${identity.userProfilePath}`);
+    runtime.log(`  Agent: ${identity.agentName ?? "(unknown)"} (${identity.agentId}) → ${identity.agentIdentityPath}`);
+    runtime.log(`         → ${identity.agentSoulPath}`);
+    runtime.log(`         → ${identity.agentMemoryPath}`);
+    if (showCredentials && credentials) {
+        const services = Object.entries(credentials.services ?? {});
+        runtime.log(`\nCredentials (${services.length} services)`);
+        for (const [service, info] of services) {
+            const accounts = info.accounts ?? [];
+            const summary = accounts.length > 0 ? `${accounts.length} account(s)` : "no accounts";
+            runtime.log(`  ${service}: ${summary}`);
+        }
+    }
+    if (showCapabilities && capabilitySnapshot) {
+        runtime.log(`\nCapabilities (${capabilitySnapshot.summary.active}/${capabilitySnapshot.summary.total} active)`);
+        for (const [category, entries] of Object.entries(capabilitySnapshot.registry.categories)) {
+            const categoryCaps = capabilitySnapshot.capabilities.filter((cap) => cap.category === category);
+            const activeCount = categoryCaps.filter((cap) => cap.status === "active").length;
+            if (categoryCaps.length === 0)
+                continue;
+            runtime.log(`  ${category} (${activeCount}/${categoryCaps.length})`);
+            const sample = categoryCaps.slice(0, 3);
+            for (const cap of sample) {
+                const providers = cap.providers.map((p) => p.id).join(", ");
+                runtime.log(`    - ${cap.id}: ${providers || cap.providersRaw}`);
+            }
+        }
+    }
+    if (suggestions.length > 0) {
+        runtime.log("\nSuggestions");
+        for (const suggestion of suggestions) {
+            runtime.log(`  ${suggestion.index}. ${suggestion.id} (${suggestion.status})`);
+        }
+    }
+    runtime.log(`\nNext: run 'nexus capabilities' or 'nexus credential list' for details.`);
+}
+export async function getStatusSummary() {
+    const identity = getIdentitySnapshot();
+    return {
+        ok: true,
+        platform: `${process.platform}/${process.arch}`,
+        identity: {
+            agentId: identity.agentId,
+            hasIdentity: identity.hasIdentity,
+            agentName: identity.agentName,
+            userName: identity.userName,
+        },
+    };
+}

package/dist/commands/suggestions.js

@@ -0,0 +1,54 @@
+import { defaultRuntime } from "../runtime.js";
+import { buildUsageSuggestions } from "../infra/usage-suggestions.js";
+function parseKinds(raw) {
+    if (!raw)
+        return undefined;
+    const parts = raw
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    const out = [];
+    for (const part of parts) {
+        if (part === "cli" || part === "tool") {
+            out.push(part);
+        }
+    }
+    return out.length > 0 ? out : undefined;
+}
+export async function suggestionsCommand(opts, runtime = defaultRuntime) {
+    const sources = opts.source ? [opts.source] : undefined;
+    const kinds = parseKinds(opts.kind);
+    const history = opts.history && opts.history > 0 ? opts.history : 1;
+    const limit = opts.limit && opts.limit > 0 ? opts.limit : 5;
+    const scope = opts.scope === "session" ? "session" : "global";
+    const result = await buildUsageSuggestions({
+        history,
+        limit,
+        sessionId: opts.session,
+        sources,
+        kinds,
+        scope,
+    });
+    if (opts.json) {
+        runtime.log(JSON.stringify({
+            history: result.history,
+            suggestions: result.suggestions,
+            totalEvents: result.totalEvents,
+        }, null, 2));
+        return;
+    }
+    runtime.log("\nUsage Suggestions");
+    runtime.log(`  Scope: ${scope}`);
+    if (result.history.length > 0) {
+        const last = result.history[result.history.length - 1];
+        runtime.log(`  Based on: ${last.source}:${last.kind}:${last.name}`);
+    }
+    if (result.suggestions.length === 0) {
+        runtime.log("  No suggestions yet (insufficient history).");
+        return;
+    }
+    for (const [idx, suggestion] of result.suggestions.entries()) {
+        const score = (suggestion.score * 100).toFixed(1);
+        runtime.log(`  ${idx + 1}. ${suggestion.source}:${suggestion.kind}:${suggestion.name} (${score}%)`);
+    }
+}

package/dist/commands/systemd-linger.js

@@ -0,0 +1,71 @@
+import { note } from "@clack/prompts";
+import { enableSystemdUserLinger, readSystemdUserLingerStatus, } from "../daemon/systemd.js";
+export async function ensureSystemdUserLingerInteractive(params) {
+    if (process.platform !== "linux")
+        return;
+    if (params.prompt === false)
+        return;
+    const env = params.env ?? process.env;
+    const prompter = params.prompter ?? { note };
+    const title = params.title ?? "Systemd";
+    const status = await readSystemdUserLingerStatus(env);
+    if (!status) {
+        await prompter.note("Unable to read loginctl linger status. Ensure systemd + loginctl are available.", title);
+        return;
+    }
+    if (status.linger === "yes")
+        return;
+    const reason = params.reason ??
+        "Systemd user services stop when you log out or go idle, which kills the Gateway.";
+    const actionNote = params.requireConfirm
+        ? "We can enable lingering now (may require sudo; writes /var/lib/systemd/linger)."
+        : "Enabling lingering now (may require sudo; writes /var/lib/systemd/linger).";
+    await prompter.note(`${reason}\n${actionNote}`, title);
+    if (params.requireConfirm && prompter.confirm) {
+        const ok = await prompter.confirm({
+            message: `Enable systemd lingering for ${status.user}?`,
+            initialValue: true,
+        });
+        if (!ok) {
+            await prompter.note("Without lingering, the Gateway will stop when you log out.", title);
+            return;
+        }
+    }
+    const resultNoSudo = await enableSystemdUserLinger({
+        env,
+        user: status.user,
+    });
+    if (resultNoSudo.ok) {
+        await prompter.note(`Enabled systemd lingering for ${status.user}.`, title);
+        return;
+    }
+    const result = await enableSystemdUserLinger({
+        env,
+        user: status.user,
+        sudoMode: "prompt",
+    });
+    if (result.ok) {
+        await prompter.note(`Enabled systemd lingering for ${status.user}.`, title);
+        return;
+    }
+    params.runtime.error(`Failed to enable lingering: ${result.stderr || result.stdout || "unknown error"}`);
+    await prompter.note(`Run manually: sudo loginctl enable-linger ${status.user}`, title);
+}
+export async function ensureSystemdUserLingerNonInteractive(params) {
+    if (process.platform !== "linux")
+        return;
+    const env = params.env ?? process.env;
+    const status = await readSystemdUserLingerStatus(env);
+    if (!status || status.linger === "yes")
+        return;
+    const result = await enableSystemdUserLinger({
+        env,
+        user: status.user,
+        sudoMode: "non-interactive",
+    });
+    if (result.ok) {
+        params.runtime.log(`Enabled systemd lingering for ${status.user}.`);
+        return;
+    }
+    params.runtime.log(`Systemd lingering is disabled for ${status.user}. Run: sudo loginctl enable-linger ${status.user}`);
+}