clawdbot 2026.1.4-1

package/dist/daemon/service.js

@@ -0,0 +1,60 @@
+import { installLaunchAgent, isLaunchAgentLoaded, readLaunchAgentProgramArguments, restartLaunchAgent, uninstallLaunchAgent, } from "./launchd.js";
+import { installScheduledTask, isScheduledTaskInstalled, readScheduledTaskCommand, restartScheduledTask, uninstallScheduledTask, } from "./schtasks.js";
+import { installSystemdService, isSystemdServiceEnabled, readSystemdServiceExecStart, restartSystemdService, 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);
+            },
+            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);
+            },
+            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);
+            },
+            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,266 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+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 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=Clawdbot 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 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 } from "./send.js";