@intent-systems/nexus 2026.1.5-3

package/dist/daemon/schtasks.js

@@ -0,0 +1,269 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { GATEWAY_WINDOWS_TASK_NAME, LEGACY_GATEWAY_WINDOWS_TASK_NAMES, } from "./constants.js";
+const execFileAsync = promisify(execFile);
+function resolveHomeDir(env) {
+    const home = env.USERPROFILE?.trim() || env.HOME?.trim();
+    if (!home)
+        throw new Error("Missing HOME");
+    return home;
+}
+function resolveTaskScriptPath(env) {
+    const home = resolveHomeDir(env);
+    return path.join(home, ".nexus", "gateway.cmd");
+}
+function resolveLegacyTaskScriptPath(env) {
+    const home = resolveHomeDir(env);
+    return path.join(home, ".nexus", "gateway.cmd");
+}
+function quoteCmdArg(value) {
+    if (!/[ \t"]/g.test(value))
+        return value;
+    return `"${value.replace(/"/g, '\\"')}"`;
+}
+function parseCommandLine(value) {
+    const args = [];
+    let current = "";
+    let inQuotes = false;
+    let escapeNext = false;
+    for (const char of value) {
+        if (escapeNext) {
+            current += char;
+            escapeNext = false;
+            continue;
+        }
+        if (char === "\\") {
+            escapeNext = true;
+            continue;
+        }
+        if (char === '"') {
+            inQuotes = !inQuotes;
+            continue;
+        }
+        if (!inQuotes && /\s/.test(char)) {
+            if (current) {
+                args.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (current)
+        args.push(current);
+    return args;
+}
+export async function readScheduledTaskCommand(env) {
+    const scriptPath = resolveTaskScriptPath(env);
+    try {
+        const content = await fs.readFile(scriptPath, "utf8");
+        let workingDirectory = "";
+        let commandLine = "";
+        for (const rawLine of content.split(/\r?\n/)) {
+            const line = rawLine.trim();
+            if (!line)
+                continue;
+            if (line.startsWith("@echo"))
+                continue;
+            if (line.toLowerCase().startsWith("rem "))
+                continue;
+            if (line.toLowerCase().startsWith("set "))
+                continue;
+            if (line.toLowerCase().startsWith("cd /d ")) {
+                workingDirectory = line
+                    .slice("cd /d ".length)
+                    .trim()
+                    .replace(/^"|"$/g, "");
+                continue;
+            }
+            commandLine = line;
+            break;
+        }
+        if (!commandLine)
+            return null;
+        return {
+            programArguments: parseCommandLine(commandLine),
+            ...(workingDirectory ? { workingDirectory } : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function buildTaskScript({ programArguments, workingDirectory, environment, }) {
+    const lines = ["@echo off"];
+    if (workingDirectory) {
+        lines.push(`cd /d ${quoteCmdArg(workingDirectory)}`);
+    }
+    if (environment) {
+        for (const [key, value] of Object.entries(environment)) {
+            if (!value)
+                continue;
+            lines.push(`set ${key}=${value}`);
+        }
+    }
+    const command = programArguments.map(quoteCmdArg).join(" ");
+    lines.push(command);
+    return `${lines.join("\r\n")}\r\n`;
+}
+async function execSchtasks(args) {
+    try {
+        const { stdout, stderr } = await execFileAsync("schtasks", args, {
+            encoding: "utf8",
+            windowsHide: true,
+        });
+        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,
+        };
+    }
+}
+async function assertSchtasksAvailable() {
+    const res = await execSchtasks(["/Query"]);
+    if (res.code === 0)
+        return;
+    const detail = res.stderr || res.stdout;
+    throw new Error(`schtasks unavailable: ${detail || "unknown error"}`.trim());
+}
+export async function installScheduledTask({ env, stdout, programArguments, workingDirectory, environment, }) {
+    await assertSchtasksAvailable();
+    const scriptPath = resolveTaskScriptPath(env);
+    await fs.mkdir(path.dirname(scriptPath), { recursive: true });
+    const script = buildTaskScript({
+        programArguments,
+        workingDirectory,
+        environment,
+    });
+    await fs.writeFile(scriptPath, script, "utf8");
+    const quotedScript = quoteCmdArg(scriptPath);
+    const create = await execSchtasks([
+        "/Create",
+        "/F",
+        "/SC",
+        "ONLOGON",
+        "/RL",
+        "LIMITED",
+        "/TN",
+        GATEWAY_WINDOWS_TASK_NAME,
+        "/TR",
+        quotedScript,
+    ]);
+    if (create.code !== 0) {
+        throw new Error(`schtasks create failed: ${create.stderr || create.stdout}`.trim());
+    }
+    await execSchtasks(["/Run", "/TN", GATEWAY_WINDOWS_TASK_NAME]);
+    stdout.write(`Installed Scheduled Task: ${GATEWAY_WINDOWS_TASK_NAME}\n`);
+    stdout.write(`Task script: ${scriptPath}\n`);
+    return { scriptPath };
+}
+export async function uninstallScheduledTask({ env, stdout, }) {
+    await assertSchtasksAvailable();
+    await execSchtasks(["/Delete", "/F", "/TN", GATEWAY_WINDOWS_TASK_NAME]);
+    const scriptPath = resolveTaskScriptPath(env);
+    try {
+        await fs.unlink(scriptPath);
+        stdout.write(`Removed task script: ${scriptPath}\n`);
+    }
+    catch {
+        stdout.write(`Task script not found at ${scriptPath}\n`);
+    }
+}
+function isTaskNotRunning(res) {
+    const detail = `${res.stderr || res.stdout}`.toLowerCase();
+    return detail.includes("not running");
+}
+export async function stopScheduledTask({ stdout, }) {
+    await assertSchtasksAvailable();
+    const res = await execSchtasks(["/End", "/TN", GATEWAY_WINDOWS_TASK_NAME]);
+    if (res.code !== 0 && !isTaskNotRunning(res)) {
+        throw new Error(`schtasks end failed: ${res.stderr || res.stdout}`.trim());
+    }
+    stdout.write(`Stopped Scheduled Task: ${GATEWAY_WINDOWS_TASK_NAME}\n`);
+}
+export async function restartScheduledTask({ stdout, }) {
+    await assertSchtasksAvailable();
+    await execSchtasks(["/End", "/TN", GATEWAY_WINDOWS_TASK_NAME]);
+    const res = await execSchtasks(["/Run", "/TN", GATEWAY_WINDOWS_TASK_NAME]);
+    if (res.code !== 0) {
+        throw new Error(`schtasks run failed: ${res.stderr || res.stdout}`.trim());
+    }
+    stdout.write(`Restarted Scheduled Task: ${GATEWAY_WINDOWS_TASK_NAME}\n`);
+}
+export async function isScheduledTaskInstalled() {
+    await assertSchtasksAvailable();
+    const res = await execSchtasks(["/Query", "/TN", GATEWAY_WINDOWS_TASK_NAME]);
+    return res.code === 0;
+}
+export async function findLegacyScheduledTasks(env) {
+    const results = [];
+    let schtasksAvailable = true;
+    try {
+        await assertSchtasksAvailable();
+    }
+    catch {
+        schtasksAvailable = false;
+    }
+    for (const name of LEGACY_GATEWAY_WINDOWS_TASK_NAMES) {
+        const scriptPath = resolveLegacyTaskScriptPath(env);
+        let installed = false;
+        if (schtasksAvailable) {
+            const res = await execSchtasks(["/Query", "/TN", name]);
+            installed = res.code === 0;
+        }
+        let scriptExists = false;
+        try {
+            await fs.access(scriptPath);
+            scriptExists = true;
+        }
+        catch {
+            // ignore
+        }
+        if (installed || scriptExists) {
+            results.push({ name, scriptPath, installed, scriptExists });
+        }
+    }
+    return results;
+}
+export async function uninstallLegacyScheduledTasks({ env, stdout, }) {
+    const tasks = await findLegacyScheduledTasks(env);
+    if (tasks.length === 0)
+        return tasks;
+    let schtasksAvailable = true;
+    try {
+        await assertSchtasksAvailable();
+    }
+    catch {
+        schtasksAvailable = false;
+    }
+    for (const task of tasks) {
+        if (schtasksAvailable && task.installed) {
+            await execSchtasks(["/Delete", "/F", "/TN", task.name]);
+        }
+        else if (!schtasksAvailable && task.installed) {
+            stdout.write(`schtasks unavailable; unable to remove legacy task: ${task.name}\n`);
+        }
+        try {
+            await fs.unlink(task.scriptPath);
+            stdout.write(`Removed legacy task script: ${task.scriptPath}\n`);
+        }
+        catch {
+            stdout.write(`Legacy task script not found at ${task.scriptPath}\n`);
+        }
+    }
+    return tasks;
+}

package/dist/daemon/service.js

@@ -0,0 +1,69 @@
+import { installLaunchAgent, isLaunchAgentLoaded, readLaunchAgentProgramArguments, restartLaunchAgent, stopLaunchAgent, uninstallLaunchAgent, } from "./launchd.js";
+import { installScheduledTask, isScheduledTaskInstalled, readScheduledTaskCommand, restartScheduledTask, stopScheduledTask, uninstallScheduledTask, } from "./schtasks.js";
+import { installSystemdService, isSystemdServiceEnabled, readSystemdServiceExecStart, restartSystemdService, stopSystemdService, uninstallSystemdService, } from "./systemd.js";
+export function resolveGatewayService() {
+    if (process.platform === "darwin") {
+        return {
+            label: "LaunchAgent",
+            loadedText: "loaded",
+            notLoadedText: "not loaded",
+            install: async (args) => {
+                await installLaunchAgent(args);
+            },
+            uninstall: async (args) => {
+                await uninstallLaunchAgent(args);
+            },
+            stop: async (args) => {
+                await stopLaunchAgent(args);
+            },
+            restart: async (args) => {
+                await restartLaunchAgent(args);
+            },
+            isLoaded: async () => isLaunchAgentLoaded(),
+            readCommand: readLaunchAgentProgramArguments,
+        };
+    }
+    if (process.platform === "linux") {
+        return {
+            label: "systemd",
+            loadedText: "enabled",
+            notLoadedText: "disabled",
+            install: async (args) => {
+                await installSystemdService(args);
+            },
+            uninstall: async (args) => {
+                await uninstallSystemdService(args);
+            },
+            stop: async (args) => {
+                await stopSystemdService(args);
+            },
+            restart: async (args) => {
+                await restartSystemdService(args);
+            },
+            isLoaded: async () => isSystemdServiceEnabled(),
+            readCommand: readSystemdServiceExecStart,
+        };
+    }
+    if (process.platform === "win32") {
+        return {
+            label: "Scheduled Task",
+            loadedText: "registered",
+            notLoadedText: "missing",
+            install: async (args) => {
+                await installScheduledTask(args);
+            },
+            uninstall: async (args) => {
+                await uninstallScheduledTask(args);
+            },
+            stop: async (args) => {
+                await stopScheduledTask(args);
+            },
+            restart: async (args) => {
+                await restartScheduledTask(args);
+            },
+            isLoaded: async () => isScheduledTaskInstalled(),
+            readCommand: readScheduledTaskCommand,
+        };
+    }
+    throw new Error(`Gateway service install not supported on ${process.platform}`);
+}

package/dist/daemon/systemd.js

@@ -0,0 +1,332 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { runCommandWithTimeout, runExec } from "../process/exec.js";
+import { GATEWAY_SYSTEMD_SERVICE_NAME, LEGACY_GATEWAY_SYSTEMD_SERVICE_NAMES, } 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 resolveSystemdUnitPathForName(env, name) {
+    const home = resolveHomeDir(env);
+    return path.join(home, ".config", "systemd", "user", `${name}.service`);
+}
+function resolveSystemdUnitPath(env) {
+    return resolveSystemdUnitPathForName(env, GATEWAY_SYSTEMD_SERVICE_NAME);
+}
+function resolveLoginctlUser(env) {
+    const fromEnv = env.USER?.trim() || env.LOGNAME?.trim();
+    if (fromEnv)
+        return fromEnv;
+    try {
+        return os.userInfo().username;
+    }
+    catch {
+        return null;
+    }
+}
+export async function readSystemdUserLingerStatus(env) {
+    const user = resolveLoginctlUser(env);
+    if (!user)
+        return null;
+    try {
+        const { stdout } = await runExec("loginctl", ["show-user", user, "-p", "Linger"], { timeoutMs: 5_000 });
+        const line = stdout
+            .split("\n")
+            .map((entry) => entry.trim())
+            .find((entry) => entry.startsWith("Linger="));
+        const value = line?.split("=")[1]?.trim().toLowerCase();
+        if (value === "yes" || value === "no") {
+            return { user, linger: value };
+        }
+    }
+    catch {
+        // ignore; loginctl may be unavailable
+    }
+    return null;
+}
+export async function enableSystemdUserLinger(params) {
+    const user = params.user ?? resolveLoginctlUser(params.env);
+    if (!user) {
+        return { ok: false, stdout: "", stderr: "Missing user", code: 1 };
+    }
+    const needsSudo = typeof process.getuid === "function" ? process.getuid() !== 0 : true;
+    const sudoArgs = needsSudo && params.sudoMode !== undefined
+        ? ["sudo", ...(params.sudoMode === "non-interactive" ? ["-n"] : [])]
+        : [];
+    const argv = [...sudoArgs, "loginctl", "enable-linger", user];
+    try {
+        const result = await runCommandWithTimeout(argv, { timeoutMs: 30_000 });
+        return {
+            ok: result.code === 0,
+            stdout: result.stdout,
+            stderr: result.stderr,
+            code: result.code ?? 1,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { ok: false, stdout: "", stderr: message, code: 1 };
+    }
+}
+function systemdEscapeArg(value) {
+    if (!/[\s"\\]/.test(value))
+        return value;
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function renderEnvLines(env) {
+    if (!env)
+        return [];
+    const entries = Object.entries(env).filter(([, value]) => typeof value === "string" && value.trim());
+    if (entries.length === 0)
+        return [];
+    return entries.map(([key, value]) => `Environment=${systemdEscapeArg(`${key}=${value?.trim() ?? ""}`)}`);
+}
+function buildSystemdUnit({ programArguments, workingDirectory, environment, }) {
+    const execStart = programArguments.map(systemdEscapeArg).join(" ");
+    const workingDirLine = workingDirectory
+        ? `WorkingDirectory=${systemdEscapeArg(workingDirectory)}`
+        : null;
+    const envLines = renderEnvLines(environment);
+    return [
+        "[Unit]",
+        "Description=Nexus Gateway",
+        "",
+        "[Service]",
+        `ExecStart=${execStart}`,
+        "Restart=always",
+        workingDirLine,
+        ...envLines,
+        "",
+        "[Install]",
+        "WantedBy=default.target",
+        "",
+    ]
+        .filter((line) => line !== null)
+        .join("\n");
+}
+function parseSystemdExecStart(value) {
+    const args = [];
+    let current = "";
+    let inQuotes = false;
+    let escapeNext = false;
+    for (const char of value) {
+        if (escapeNext) {
+            current += char;
+            escapeNext = false;
+            continue;
+        }
+        if (char === "\\") {
+            escapeNext = true;
+            continue;
+        }
+        if (char === '"') {
+            inQuotes = !inQuotes;
+            continue;
+        }
+        if (!inQuotes && /\s/.test(char)) {
+            if (current) {
+                args.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (current)
+        args.push(current);
+    return args;
+}
+export async function readSystemdServiceExecStart(env) {
+    const unitPath = resolveSystemdUnitPath(env);
+    try {
+        const content = await fs.readFile(unitPath, "utf8");
+        let execStart = "";
+        let workingDirectory = "";
+        for (const rawLine of content.split("\n")) {
+            const line = rawLine.trim();
+            if (!line || line.startsWith("#"))
+                continue;
+            if (line.startsWith("ExecStart=")) {
+                execStart = line.slice("ExecStart=".length).trim();
+            }
+            else if (line.startsWith("WorkingDirectory=")) {
+                workingDirectory = line.slice("WorkingDirectory=".length).trim();
+            }
+        }
+        if (!execStart)
+            return null;
+        const programArguments = parseSystemdExecStart(execStart);
+        return {
+            programArguments,
+            ...(workingDirectory ? { workingDirectory } : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function execSystemctl(args) {
+    try {
+        const { stdout, stderr } = await execFileAsync("systemctl", 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,
+        };
+    }
+}
+async function assertSystemdAvailable() {
+    const res = await execSystemctl(["--user", "status"]);
+    if (res.code === 0)
+        return;
+    const detail = res.stderr || res.stdout;
+    if (detail.toLowerCase().includes("not found")) {
+        throw new Error("systemctl not available; systemd user services are required on Linux.");
+    }
+    throw new Error(`systemctl --user unavailable: ${detail || "unknown error"}`.trim());
+}
+export async function installSystemdService({ env, stdout, programArguments, workingDirectory, environment, }) {
+    await assertSystemdAvailable();
+    const unitPath = resolveSystemdUnitPath(env);
+    await fs.mkdir(path.dirname(unitPath), { recursive: true });
+    const unit = buildSystemdUnit({
+        programArguments,
+        workingDirectory,
+        environment,
+    });
+    await fs.writeFile(unitPath, unit, "utf8");
+    const unitName = `${GATEWAY_SYSTEMD_SERVICE_NAME}.service`;
+    const reload = await execSystemctl(["--user", "daemon-reload"]);
+    if (reload.code !== 0) {
+        throw new Error(`systemctl daemon-reload failed: ${reload.stderr || reload.stdout}`.trim());
+    }
+    const enable = await execSystemctl(["--user", "enable", unitName]);
+    if (enable.code !== 0) {
+        throw new Error(`systemctl enable failed: ${enable.stderr || enable.stdout}`.trim());
+    }
+    const restart = await execSystemctl(["--user", "restart", unitName]);
+    if (restart.code !== 0) {
+        throw new Error(`systemctl restart failed: ${restart.stderr || restart.stdout}`.trim());
+    }
+    stdout.write(`Installed systemd service: ${unitPath}\n`);
+    return { unitPath };
+}
+export async function uninstallSystemdService({ env, stdout, }) {
+    await assertSystemdAvailable();
+    const unitName = `${GATEWAY_SYSTEMD_SERVICE_NAME}.service`;
+    await execSystemctl(["--user", "disable", "--now", unitName]);
+    const unitPath = resolveSystemdUnitPath(env);
+    try {
+        await fs.unlink(unitPath);
+        stdout.write(`Removed systemd service: ${unitPath}\n`);
+    }
+    catch {
+        stdout.write(`Systemd service not found at ${unitPath}\n`);
+    }
+}
+export async function stopSystemdService({ stdout, }) {
+    await assertSystemdAvailable();
+    const unitName = `${GATEWAY_SYSTEMD_SERVICE_NAME}.service`;
+    const res = await execSystemctl(["--user", "stop", unitName]);
+    if (res.code !== 0) {
+        throw new Error(`systemctl stop failed: ${res.stderr || res.stdout}`.trim());
+    }
+    stdout.write(`Stopped systemd service: ${unitName}\n`);
+}
+export async function restartSystemdService({ stdout, }) {
+    await assertSystemdAvailable();
+    const unitName = `${GATEWAY_SYSTEMD_SERVICE_NAME}.service`;
+    const res = await execSystemctl(["--user", "restart", unitName]);
+    if (res.code !== 0) {
+        throw new Error(`systemctl restart failed: ${res.stderr || res.stdout}`.trim());
+    }
+    stdout.write(`Restarted systemd service: ${unitName}\n`);
+}
+export async function isSystemdServiceEnabled() {
+    await assertSystemdAvailable();
+    const unitName = `${GATEWAY_SYSTEMD_SERVICE_NAME}.service`;
+    const res = await execSystemctl(["--user", "is-enabled", unitName]);
+    return res.code === 0;
+}
+async function isSystemctlAvailable() {
+    const res = await execSystemctl(["--user", "status"]);
+    if (res.code === 0)
+        return true;
+    const detail = `${res.stderr || res.stdout}`.toLowerCase();
+    return !detail.includes("not found");
+}
+export async function findLegacySystemdUnits(env) {
+    const results = [];
+    const systemctlAvailable = await isSystemctlAvailable();
+    for (const name of LEGACY_GATEWAY_SYSTEMD_SERVICE_NAMES) {
+        const unitPath = resolveSystemdUnitPathForName(env, name);
+        let exists = false;
+        try {
+            await fs.access(unitPath);
+            exists = true;
+        }
+        catch {
+            // ignore
+        }
+        let enabled = false;
+        if (systemctlAvailable) {
+            const res = await execSystemctl([
+                "--user",
+                "is-enabled",
+                `${name}.service`,
+            ]);
+            enabled = res.code === 0;
+        }
+        if (exists || enabled) {
+            results.push({ name, unitPath, enabled, exists });
+        }
+    }
+    return results;
+}
+export async function uninstallLegacySystemdUnits({ env, stdout, }) {
+    const units = await findLegacySystemdUnits(env);
+    if (units.length === 0)
+        return units;
+    const systemctlAvailable = await isSystemctlAvailable();
+    for (const unit of units) {
+        if (systemctlAvailable) {
+            await execSystemctl([
+                "--user",
+                "disable",
+                "--now",
+                `${unit.name}.service`,
+            ]);
+        }
+        else {
+            stdout.write(`systemctl unavailable; removed legacy unit file only: ${unit.name}.service\n`);
+        }
+        try {
+            await fs.unlink(unit.unitPath);
+            stdout.write(`Removed legacy systemd service: ${unit.unitPath}\n`);
+        }
+        catch {
+            stdout.write(`Legacy systemd unit not found at ${unit.unitPath}\n`);
+        }
+    }
+    return units;
+}

package/dist/discord/index.js

@@ -0,0 +1,2 @@
+export { monitorDiscordProvider } from "./monitor.js";
+export { sendMessageDiscord, sendPollDiscord } from "./send.js";