clawdbot 2026.1.4-1 → 2026.1.5

package/dist/daemon/service.js

@@ -1,60 +0,0 @@
-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

@@ -1,266 +0,0 @@
-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/imessage/client.js

@@ -1,165 +0,0 @@
-import { spawn } from "node:child_process";
-import { createInterface } from "node:readline";
-import { resolveUserPath } from "../utils.js";
-export class IMessageRpcClient {
-    cliPath;
-    dbPath;
-    runtime;
-    onNotification;
-    pending = new Map();
-    closed;
-    closedResolve = null;
-    child = null;
-    reader = null;
-    nextId = 1;
-    constructor(opts = {}) {
-        this.cliPath = opts.cliPath?.trim() || "imsg";
-        this.dbPath = opts.dbPath?.trim()
-            ? resolveUserPath(opts.dbPath)
-            : undefined;
-        this.runtime = opts.runtime;
-        this.onNotification = opts.onNotification;
-        this.closed = new Promise((resolve) => {
-            this.closedResolve = resolve;
-        });
-    }
-    async start() {
-        if (this.child)
-            return;
-        const args = ["rpc"];
-        if (this.dbPath) {
-            args.push("--db", this.dbPath);
-        }
-        const child = spawn(this.cliPath, args, {
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        this.child = child;
-        this.reader = createInterface({ input: child.stdout });
-        this.reader.on("line", (line) => {
-            const trimmed = line.trim();
-            if (!trimmed)
-                return;
-            this.handleLine(trimmed);
-        });
-        child.stderr?.on("data", (chunk) => {
-            const lines = chunk.toString().split(/\r?\n/);
-            for (const line of lines) {
-                if (!line.trim())
-                    continue;
-                this.runtime?.error?.(`imsg rpc: ${line.trim()}`);
-            }
-        });
-        child.on("error", (err) => {
-            this.failAll(err instanceof Error ? err : new Error(String(err)));
-            this.closedResolve?.();
-        });
-        child.on("close", (code, signal) => {
-            if (code !== 0 && code !== null) {
-                const reason = signal ? `signal ${signal}` : `code ${code}`;
-                this.failAll(new Error(`imsg rpc exited (${reason})`));
-            }
-            else {
-                this.failAll(new Error("imsg rpc closed"));
-            }
-            this.closedResolve?.();
-        });
-    }
-    async stop() {
-        if (!this.child)
-            return;
-        this.reader?.close();
-        this.reader = null;
-        this.child.stdin?.end();
-        const child = this.child;
-        this.child = null;
-        await Promise.race([
-            this.closed,
-            new Promise((resolve) => {
-                setTimeout(() => {
-                    if (!child.killed)
-                        child.kill("SIGTERM");
-                    resolve();
-                }, 500);
-            }),
-        ]);
-    }
-    async waitForClose() {
-        await this.closed;
-    }
-    async request(method, params, opts) {
-        if (!this.child || !this.child.stdin) {
-            throw new Error("imsg rpc not running");
-        }
-        const id = this.nextId++;
-        const payload = {
-            jsonrpc: "2.0",
-            id,
-            method,
-            params: params ?? {},
-        };
-        const line = `${JSON.stringify(payload)}\n`;
-        const timeoutMs = opts?.timeoutMs ?? 10_000;
-        const response = new Promise((resolve, reject) => {
-            const key = String(id);
-            const timer = timeoutMs > 0
-                ? setTimeout(() => {
-                    this.pending.delete(key);
-                    reject(new Error(`imsg rpc timeout (${method})`));
-                }, timeoutMs)
-                : undefined;
-            this.pending.set(key, {
-                resolve: (value) => resolve(value),
-                reject,
-                timer,
-            });
-        });
-        this.child.stdin.write(line);
-        return await response;
-    }
-    handleLine(line) {
-        let parsed;
-        try {
-            parsed = JSON.parse(line);
-        }
-        catch (err) {
-            const detail = err instanceof Error ? err.message : String(err);
-            this.runtime?.error?.(`imsg rpc: failed to parse ${line}: ${detail}`);
-            return;
-        }
-        if (parsed.id !== undefined && parsed.id !== null) {
-            const key = String(parsed.id);
-            const pending = this.pending.get(key);
-            if (!pending)
-                return;
-            if (pending.timer)
-                clearTimeout(pending.timer);
-            this.pending.delete(key);
-            if (parsed.error) {
-                const msg = parsed.error.message ?? "imsg rpc error";
-                pending.reject(new Error(msg));
-                return;
-            }
-            pending.resolve(parsed.result);
-            return;
-        }
-        if (parsed.method) {
-            this.onNotification?.({
-                method: parsed.method,
-                params: parsed.params,
-            });
-        }
-    }
-    failAll(err) {
-        for (const [key, pending] of this.pending.entries()) {
-            if (pending.timer)
-                clearTimeout(pending.timer);
-            pending.reject(err);
-            this.pending.delete(key);
-        }
-    }
-}
-export async function createIMessageRpcClient(opts = {}) {
-    const client = new IMessageRpcClient(opts);
-    await client.start();
-    return client;
-}

package/dist/imessage/index.js

@@ -1,3 +0,0 @@
-export { monitorIMessageProvider } from "./monitor.js";
-export { probeIMessage } from "./probe.js";
-export { sendMessageIMessage } from "./send.js";