@intent-systems/nexus 2026.1.5-3

package/dist/daemon/launchd.js

@@ -0,0 +1,295 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { GATEWAY_LAUNCH_AGENT_LABEL, LEGACY_GATEWAY_LAUNCH_AGENT_LABELS, } from "./constants.js";
+const execFileAsync = promisify(execFile);
+function resolveHomeDir(env) {
+    const home = env.HOME?.trim() || env.USERPROFILE?.trim();
+    if (!home)
+        throw new Error("Missing HOME");
+    return home;
+}
+function resolveLaunchAgentPlistPathForLabel(env, label) {
+    const home = resolveHomeDir(env);
+    return path.join(home, "Library", "LaunchAgents", `${label}.plist`);
+}
+export function resolveLaunchAgentPlistPath(env) {
+    return resolveLaunchAgentPlistPathForLabel(env, GATEWAY_LAUNCH_AGENT_LABEL);
+}
+export function resolveGatewayLogPaths(env) {
+    const home = resolveHomeDir(env);
+    const stateDir = env.NEXUS_STATE_DIR?.trim();
+    // Prefer the configured state dir when provided; otherwise default to ~/nexus/state/logs
+    const logDir = stateDir
+        ? path.join(path.resolve(stateDir), "logs")
+        : path.join(home, "nexus", "state", "logs");
+    return {
+        logDir,
+        stdoutPath: path.join(logDir, "gateway.log"),
+        stderrPath: path.join(logDir, "gateway.err.log"),
+    };
+}
+function plistEscape(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&apos;");
+}
+function plistUnescape(value) {
+    return value
+        .replaceAll("&apos;", "'")
+        .replaceAll("&quot;", '"')
+        .replaceAll("&gt;", ">")
+        .replaceAll("&lt;", "<")
+        .replaceAll("&amp;", "&");
+}
+function renderEnvDict(env) {
+    if (!env)
+        return "";
+    const entries = Object.entries(env).filter(([, value]) => typeof value === "string" && value.trim());
+    if (entries.length === 0)
+        return "";
+    const items = entries
+        .map(([key, value]) => `
+    <key>${plistEscape(key)}</key>
+    <string>${plistEscape(value?.trim() ?? "")}</string>`)
+        .join("");
+    return `
+    <key>EnvironmentVariables</key>
+    <dict>${items}
+    </dict>`;
+}
+export async function readLaunchAgentProgramArguments(env) {
+    const plistPath = resolveLaunchAgentPlistPath(env);
+    try {
+        const plist = await fs.readFile(plistPath, "utf8");
+        const programMatch = plist.match(/<key>ProgramArguments<\/key>\s*<array>([\s\S]*?)<\/array>/i);
+        if (!programMatch)
+            return null;
+        const args = Array.from(programMatch[1].matchAll(/<string>([\s\S]*?)<\/string>/gi)).map((match) => plistUnescape(match[1] ?? "").trim());
+        const workingDirMatch = plist.match(/<key>WorkingDirectory<\/key>\s*<string>([\s\S]*?)<\/string>/i);
+        const workingDirectory = workingDirMatch
+            ? plistUnescape(workingDirMatch[1] ?? "").trim()
+            : "";
+        return {
+            programArguments: args.filter(Boolean),
+            ...(workingDirectory ? { workingDirectory } : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function buildLaunchAgentPlist({ label = GATEWAY_LAUNCH_AGENT_LABEL, programArguments, workingDirectory, stdoutPath, stderrPath, environment, }) {
+    const argsXml = programArguments
+        .map((arg) => `\n      <string>${plistEscape(arg)}</string>`)
+        .join("");
+    const workingDirXml = workingDirectory
+        ? `
+    <key>WorkingDirectory</key>
+    <string>${plistEscape(workingDirectory)}</string>`
+        : "";
+    const envXml = renderEnvDict(environment);
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>Label</key>
+    <string>${plistEscape(label)}</string>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>ProgramArguments</key>
+    <array>${argsXml}
+    </array>
+    ${workingDirXml}
+    <key>StandardOutPath</key>
+    <string>${plistEscape(stdoutPath)}</string>
+    <key>StandardErrorPath</key>
+    <string>${plistEscape(stderrPath)}</string>${envXml}
+  </dict>
+</plist>
+`;
+}
+async function execLaunchctl(args) {
+    try {
+        const { stdout, stderr } = await execFileAsync("launchctl", args, {
+            encoding: "utf8",
+        });
+        return {
+            stdout: String(stdout ?? ""),
+            stderr: String(stderr ?? ""),
+            code: 0,
+        };
+    }
+    catch (error) {
+        const e = error;
+        return {
+            stdout: typeof e.stdout === "string" ? e.stdout : "",
+            stderr: typeof e.stderr === "string"
+                ? e.stderr
+                : typeof e.message === "string"
+                    ? e.message
+                    : "",
+            code: typeof e.code === "number" ? e.code : 1,
+        };
+    }
+}
+function resolveGuiDomain() {
+    if (typeof process.getuid !== "function")
+        return "gui/501";
+    return `gui/${process.getuid()}`;
+}
+export async function isLaunchAgentLoaded() {
+    const domain = resolveGuiDomain();
+    const label = GATEWAY_LAUNCH_AGENT_LABEL;
+    const res = await execLaunchctl(["print", `${domain}/${label}`]);
+    return res.code === 0;
+}
+export async function findLegacyLaunchAgents(env) {
+    const domain = resolveGuiDomain();
+    const results = [];
+    for (const label of LEGACY_GATEWAY_LAUNCH_AGENT_LABELS) {
+        const plistPath = resolveLaunchAgentPlistPathForLabel(env, label);
+        const res = await execLaunchctl(["print", `${domain}/${label}`]);
+        const loaded = res.code === 0;
+        let exists = false;
+        try {
+            await fs.access(plistPath);
+            exists = true;
+        }
+        catch {
+            // ignore
+        }
+        if (loaded || exists) {
+            results.push({ label, plistPath, loaded, exists });
+        }
+    }
+    return results;
+}
+export async function uninstallLegacyLaunchAgents({ env, stdout, }) {
+    const domain = resolveGuiDomain();
+    const agents = await findLegacyLaunchAgents(env);
+    if (agents.length === 0)
+        return agents;
+    const home = resolveHomeDir(env);
+    const trashDir = path.join(home, ".Trash");
+    try {
+        await fs.mkdir(trashDir, { recursive: true });
+    }
+    catch {
+        // ignore
+    }
+    for (const agent of agents) {
+        await execLaunchctl(["bootout", domain, agent.plistPath]);
+        await execLaunchctl(["unload", agent.plistPath]);
+        try {
+            await fs.access(agent.plistPath);
+        }
+        catch {
+            continue;
+        }
+        const dest = path.join(trashDir, `${agent.label}.plist`);
+        try {
+            await fs.rename(agent.plistPath, dest);
+            stdout.write(`Moved legacy LaunchAgent to Trash: ${dest}\n`);
+        }
+        catch {
+            stdout.write(`Legacy LaunchAgent remains at ${agent.plistPath} (could not move)\n`);
+        }
+    }
+    return agents;
+}
+export async function uninstallLaunchAgent({ env, stdout, }) {
+    const domain = resolveGuiDomain();
+    const plistPath = resolveLaunchAgentPlistPath(env);
+    await execLaunchctl(["bootout", domain, plistPath]);
+    await execLaunchctl(["unload", plistPath]);
+    try {
+        await fs.access(plistPath);
+    }
+    catch {
+        stdout.write(`LaunchAgent not found at ${plistPath}\n`);
+        return;
+    }
+    const home = resolveHomeDir(env);
+    const trashDir = path.join(home, ".Trash");
+    const dest = path.join(trashDir, `${GATEWAY_LAUNCH_AGENT_LABEL}.plist`);
+    try {
+        await fs.mkdir(trashDir, { recursive: true });
+        await fs.rename(plistPath, dest);
+        stdout.write(`Moved LaunchAgent to Trash: ${dest}\n`);
+    }
+    catch {
+        stdout.write(`LaunchAgent remains at ${plistPath} (could not move)\n`);
+    }
+}
+function isLaunchctlNotLoaded(res) {
+    const detail = `${res.stderr || res.stdout}`.toLowerCase();
+    return (detail.includes("no such process") ||
+        detail.includes("could not find service") ||
+        detail.includes("not found"));
+}
+export async function stopLaunchAgent({ stdout, }) {
+    const domain = resolveGuiDomain();
+    const label = GATEWAY_LAUNCH_AGENT_LABEL;
+    const res = await execLaunchctl(["bootout", `${domain}/${label}`]);
+    if (res.code !== 0 && !isLaunchctlNotLoaded(res)) {
+        throw new Error(`launchctl bootout failed: ${res.stderr || res.stdout}`.trim());
+    }
+    stdout.write(`Stopped LaunchAgent: ${domain}/${label}\n`);
+}
+export async function installLaunchAgent({ env, stdout, programArguments, workingDirectory, environment, }) {
+    const { logDir, stdoutPath, stderrPath } = resolveGatewayLogPaths(env);
+    await fs.mkdir(logDir, { recursive: true });
+    const domain = resolveGuiDomain();
+    for (const legacyLabel of LEGACY_GATEWAY_LAUNCH_AGENT_LABELS) {
+        const legacyPlistPath = resolveLaunchAgentPlistPathForLabel(env, legacyLabel);
+        await execLaunchctl(["bootout", domain, legacyPlistPath]);
+        await execLaunchctl(["unload", legacyPlistPath]);
+        try {
+            await fs.unlink(legacyPlistPath);
+        }
+        catch {
+            // ignore
+        }
+    }
+    const plistPath = resolveLaunchAgentPlistPath(env);
+    await fs.mkdir(path.dirname(plistPath), { recursive: true });
+    const plist = buildLaunchAgentPlist({
+        programArguments,
+        workingDirectory,
+        stdoutPath,
+        stderrPath,
+        environment,
+    });
+    await fs.writeFile(plistPath, plist, "utf8");
+    await execLaunchctl(["bootout", domain, plistPath]);
+    await execLaunchctl(["unload", plistPath]);
+    const boot = await execLaunchctl(["bootstrap", domain, plistPath]);
+    if (boot.code !== 0) {
+        throw new Error(`launchctl bootstrap failed: ${boot.stderr || boot.stdout}`.trim());
+    }
+    await execLaunchctl(["enable", `${domain}/${GATEWAY_LAUNCH_AGENT_LABEL}`]);
+    await execLaunchctl([
+        "kickstart",
+        "-k",
+        `${domain}/${GATEWAY_LAUNCH_AGENT_LABEL}`,
+    ]);
+    stdout.write(`Installed LaunchAgent: ${plistPath}\n`);
+    stdout.write(`Logs: ${stdoutPath}\n`);
+    return { plistPath };
+}
+export async function restartLaunchAgent({ stdout, }) {
+    const domain = resolveGuiDomain();
+    const label = GATEWAY_LAUNCH_AGENT_LABEL;
+    const res = await execLaunchctl(["kickstart", "-k", `${domain}/${label}`]);
+    if (res.code !== 0) {
+        throw new Error(`launchctl kickstart failed: ${res.stderr || res.stdout}`.trim());
+    }
+    stdout.write(`Restarted LaunchAgent: ${domain}/${label}\n`);
+}

package/dist/daemon/legacy.js

@@ -0,0 +1,63 @@
+import { findLegacyLaunchAgents, uninstallLegacyLaunchAgents, } from "./launchd.js";
+import { findLegacyScheduledTasks, uninstallLegacyScheduledTasks, } from "./schtasks.js";
+import { findLegacySystemdUnits, uninstallLegacySystemdUnits, } from "./systemd.js";
+function formatLegacyLaunchAgents(agents) {
+    return agents.map((agent) => ({
+        platform: "darwin",
+        label: agent.label,
+        detail: [
+            agent.loaded ? "loaded" : "not loaded",
+            agent.exists ? `plist: ${agent.plistPath}` : "plist missing",
+        ].join(", "),
+    }));
+}
+function formatLegacySystemdUnits(units) {
+    return units.map((unit) => ({
+        platform: "linux",
+        label: `${unit.name}.service`,
+        detail: [
+            unit.enabled ? "enabled" : "disabled",
+            unit.exists ? `unit: ${unit.unitPath}` : "unit missing",
+        ].join(", "),
+    }));
+}
+function formatLegacyScheduledTasks(tasks) {
+    return tasks.map((task) => ({
+        platform: "win32",
+        label: task.name,
+        detail: [
+            task.installed ? "installed" : "not installed",
+            task.scriptExists ? `script: ${task.scriptPath}` : "script missing",
+        ].join(", "),
+    }));
+}
+export async function findLegacyGatewayServices(env) {
+    if (process.platform === "darwin") {
+        const agents = await findLegacyLaunchAgents(env);
+        return formatLegacyLaunchAgents(agents);
+    }
+    if (process.platform === "linux") {
+        const units = await findLegacySystemdUnits(env);
+        return formatLegacySystemdUnits(units);
+    }
+    if (process.platform === "win32") {
+        const tasks = await findLegacyScheduledTasks(env);
+        return formatLegacyScheduledTasks(tasks);
+    }
+    return [];
+}
+export async function uninstallLegacyGatewayServices({ env, stdout, }) {
+    if (process.platform === "darwin") {
+        const agents = await uninstallLegacyLaunchAgents({ env, stdout });
+        return formatLegacyLaunchAgents(agents);
+    }
+    if (process.platform === "linux") {
+        const units = await uninstallLegacySystemdUnits({ env, stdout });
+        return formatLegacySystemdUnits(units);
+    }
+    if (process.platform === "win32") {
+        const tasks = await uninstallLegacyScheduledTasks({ env, stdout });
+        return formatLegacyScheduledTasks(tasks);
+    }
+    return [];
+}

package/dist/daemon/program-args.js

@@ -0,0 +1,141 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+function isNodeRuntime(execPath) {
+    const base = path.basename(execPath).toLowerCase();
+    return base === "node" || base === "node.exe";
+}
+function isBunRuntime(execPath) {
+    const base = path.basename(execPath).toLowerCase();
+    return base === "bun" || base === "bun.exe";
+}
+async function resolveCliEntrypointPathForService() {
+    const argv1 = process.argv[1];
+    if (!argv1)
+        throw new Error("Unable to resolve CLI entrypoint path");
+    const normalized = path.resolve(argv1);
+    const resolvedPath = await resolveRealpathSafe(normalized);
+    const looksLikeDist = /[/\\]dist[/\\].+\.(cjs|js|mjs)$/.test(resolvedPath);
+    if (looksLikeDist) {
+        await fs.access(resolvedPath);
+        return resolvedPath;
+    }
+    const distCandidates = buildDistCandidates(resolvedPath, normalized);
+    for (const candidate of distCandidates) {
+        try {
+            await fs.access(candidate);
+            return candidate;
+        }
+        catch {
+            // keep going
+        }
+    }
+    throw new Error(`Cannot find built CLI at ${distCandidates.join(" or ")}. Run "pnpm build" first, or use dev mode.`);
+}
+async function resolveRealpathSafe(inputPath) {
+    try {
+        return await fs.realpath(inputPath);
+    }
+    catch {
+        return inputPath;
+    }
+}
+function buildDistCandidates(...inputs) {
+    const candidates = [];
+    const seen = new Set();
+    for (const inputPath of inputs) {
+        if (!inputPath)
+            continue;
+        const baseDir = path.dirname(inputPath);
+        appendDistCandidates(candidates, seen, path.resolve(baseDir, ".."));
+        appendDistCandidates(candidates, seen, baseDir);
+        appendNodeModulesBinCandidates(candidates, seen, inputPath);
+    }
+    return candidates;
+}
+function appendDistCandidates(candidates, seen, baseDir) {
+    const distDir = path.resolve(baseDir, "dist");
+    const distEntries = [
+        path.join(distDir, "index.js"),
+        path.join(distDir, "index.mjs"),
+        path.join(distDir, "entry.js"),
+        path.join(distDir, "entry.mjs"),
+    ];
+    for (const entry of distEntries) {
+        if (seen.has(entry))
+            continue;
+        seen.add(entry);
+        candidates.push(entry);
+    }
+}
+function appendNodeModulesBinCandidates(candidates, seen, inputPath) {
+    const parts = inputPath.split(path.sep);
+    const binIndex = parts.lastIndexOf(".bin");
+    if (binIndex <= 0)
+        return;
+    if (parts[binIndex - 1] !== "node_modules")
+        return;
+    const binName = path.basename(inputPath);
+    const nodeModulesDir = parts.slice(0, binIndex).join(path.sep);
+    const packageRoot = path.join(nodeModulesDir, binName);
+    appendDistCandidates(candidates, seen, packageRoot);
+}
+function resolveRepoRootForDev() {
+    const argv1 = process.argv[1];
+    if (!argv1)
+        throw new Error("Unable to resolve repo root");
+    const normalized = path.resolve(argv1);
+    const parts = normalized.split(path.sep);
+    const srcIndex = parts.lastIndexOf("src");
+    if (srcIndex === -1) {
+        throw new Error("Dev mode requires running from repo (src/index.ts)");
+    }
+    return parts.slice(0, srcIndex).join(path.sep);
+}
+async function resolveBunPath() {
+    // Bun is expected to be in PATH, resolve via which/where
+    const { execSync } = await import("node:child_process");
+    try {
+        const bunPath = execSync("which bun", { encoding: "utf8" }).trim();
+        await fs.access(bunPath);
+        return bunPath;
+    }
+    catch {
+        throw new Error("Bun not found in PATH. Install bun: https://bun.sh");
+    }
+}
+export async function resolveGatewayProgramArguments(params) {
+    const gatewayArgs = ["gateway-daemon", "--port", String(params.port)];
+    const execPath = process.execPath;
+    if (!params.dev) {
+        try {
+            const cliEntrypointPath = await resolveCliEntrypointPathForService();
+            return {
+                programArguments: [execPath, cliEntrypointPath, ...gatewayArgs],
+            };
+        }
+        catch (error) {
+            // If running under bun or another runtime that can execute TS directly
+            if (!isNodeRuntime(execPath)) {
+                return { programArguments: [execPath, ...gatewayArgs] };
+            }
+            throw error;
+        }
+    }
+    // Dev mode: use bun to run TypeScript directly
+    const repoRoot = resolveRepoRootForDev();
+    const devCliPath = path.join(repoRoot, "src", "index.ts");
+    await fs.access(devCliPath);
+    // If already running under bun, use current execPath
+    if (isBunRuntime(execPath)) {
+        return {
+            programArguments: [execPath, devCliPath, ...gatewayArgs],
+            workingDirectory: repoRoot,
+        };
+    }
+    // Otherwise resolve bun from PATH
+    const bunPath = await resolveBunPath();
+    return {
+        programArguments: [bunPath, devCliPath, ...gatewayArgs],
+        workingDirectory: repoRoot,
+    };
+}