claude-code-discord-presence 1.0.0

package/dist/remote/tunnel-manager.js

@@ -0,0 +1,83 @@
+import { spawn } from "node:child_process";
+import { createLogger } from "../util/logger.js";
+const log = createLogger("remote-tunnel");
+const BACKOFFS_MS = [5_000, 15_000, 60_000];
+const SSH_ALIAS = /^[a-z0-9](?:[a-z0-9._-]{0,252}[a-z0-9])?$/i;
+export function isSafeSshAlias(value) {
+    return SSH_ALIAS.test(value);
+}
+export function remoteForwardArguments(host, localPort, remotePort) {
+    if (!isSafeSshAlias(host))
+        throw new Error(`Unsafe SSH alias: ${JSON.stringify(host)}`);
+    return [
+        "-N",
+        "-o", "BatchMode=yes",
+        "-o", "ExitOnForwardFailure=yes",
+        "-o", "ConnectTimeout=10",
+        "-o", "ServerAliveInterval=30",
+        "-o", "ServerAliveCountMax=3",
+        "-R", `127.0.0.1:${remotePort}:127.0.0.1:${localPort}`,
+        host,
+    ];
+}
+export class RemoteTunnelManager {
+    hosts;
+    localPort;
+    remotePort;
+    stopped = false;
+    children = new Map();
+    timers = new Set();
+    constructor(hosts, localPort, remotePort) {
+        this.hosts = hosts;
+        this.localPort = localPort;
+        this.remotePort = remotePort;
+    }
+    start() {
+        this.stopped = false;
+        for (const host of this.hosts)
+            this.connect(host, 0);
+    }
+    stop() {
+        this.stopped = true;
+        for (const timer of this.timers)
+            clearTimeout(timer);
+        this.timers.clear();
+        for (const child of this.children.values())
+            child.kill();
+        this.children.clear();
+    }
+    connect(host, attempt) {
+        if (this.stopped)
+            return;
+        const child = spawn("ssh", remoteForwardArguments(host, this.localPort, this.remotePort), {
+            shell: false,
+            windowsHide: true,
+            stdio: ["ignore", "ignore", "pipe"],
+        });
+        this.children.set(host, child);
+        let stderr = "";
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => {
+            stderr = (stderr + chunk).slice(-2_048);
+        });
+        let settled = false;
+        const reconnect = (reason) => {
+            if (settled)
+                return;
+            settled = true;
+            this.children.delete(host);
+            if (this.stopped)
+                return;
+            if (attempt === 0)
+                log.warn(`SSH tunnel to ${host} stopped (${reason}); reconnecting`);
+            const delay = BACKOFFS_MS[Math.min(attempt, BACKOFFS_MS.length - 1)];
+            const timer = setTimeout(() => {
+                this.timers.delete(timer);
+                this.connect(host, attempt + 1);
+            }, delay);
+            this.timers.add(timer);
+        };
+        child.once("error", (err) => reconnect(err.message));
+        child.once("exit", (code) => reconnect(stderr.trim() || `exit ${code ?? "unknown"}`));
+    }
+}

package/dist/server/http-server.js

@@ -0,0 +1,89 @@
+import { createServer } from "node:http";
+import { createLogger } from "../util/logger.js";
+const log = createLogger("server");
+const MAX_BODY_BYTES = 512 * 1024;
+function respond(response, status, body = "") {
+    response.writeHead(status, {
+        "content-type": "text/plain; charset=utf-8",
+        "cache-control": "no-store",
+        "x-content-type-options": "nosniff",
+    });
+    response.end(body);
+}
+async function readJson(request) {
+    const contentLength = Number(request.headers["content-length"] ?? 0);
+    if (Number.isFinite(contentLength) && contentLength > MAX_BODY_BYTES) {
+        request.resume();
+        throw new RangeError("request body is too large");
+    }
+    const chunks = [];
+    let length = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        length += buffer.length;
+        if (length > MAX_BODY_BYTES)
+            throw new RangeError("request body is too large");
+        chunks.push(buffer);
+    }
+    try {
+        const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function handle(request, response, handlers) {
+    const path = new URL(request.url ?? "/", "http://127.0.0.1").pathname;
+    if (path === "/health") {
+        if (request.method !== "GET")
+            return respond(response, 405, "method not allowed");
+        return respond(response, 200, "ok");
+    }
+    if (path !== "/hook" && path !== "/statusline")
+        return respond(response, 404, "not found");
+    if (request.method !== "POST")
+        return respond(response, 405, "method not allowed");
+    try {
+        const payload = await readJson(request);
+        if (!payload)
+            return respond(response, 400, "invalid JSON object");
+        try {
+            if (path === "/hook")
+                handlers.onHook(payload);
+            else
+                handlers.onStatusline(payload);
+        }
+        catch (err) {
+            log.error(`${path.slice(1)} handler failed: ${err.message}`);
+            return respond(response, 500, "handler failed");
+        }
+        return respond(response, 204);
+    }
+    catch (err) {
+        if (err instanceof RangeError)
+            return respond(response, 413, "payload too large");
+        log.warn(`request failed: ${err.message}`);
+        return respond(response, 400, "bad request");
+    }
+}
+export function startServer(port, handlers) {
+    const server = createServer((request, response) => {
+        void handle(request, response, handlers).catch((err) => {
+            log.error(`request crashed: ${err.message}`);
+            if (!response.headersSent)
+                respond(response, 500, "internal error");
+            else
+                response.destroy();
+        });
+    });
+    server.requestTimeout = 5_000;
+    server.headersTimeout = 5_000;
+    server.maxHeadersCount = 32;
+    server.listen(port, "127.0.0.1");
+    server.on("listening", () => log.info(`listening on http://127.0.0.1:${port}`));
+    server.on("error", (err) => log.error(`server error: ${err.message}`));
+    return server;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/util/autostart.js

@@ -0,0 +1,73 @@
+function xml(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&apos;");
+}
+function systemdQuote(value) {
+    return `"${value.replaceAll("%", "%%").replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+export function createLaunchAgentPlist(definition) {
+    const args = [
+        definition.nodePath,
+        "--disable-warning=ExperimentalWarning",
+        ...(definition.envFile ? [`--env-file=${definition.envFile}`] : []),
+        "--enable-source-maps",
+        definition.entryPoint,
+    ];
+    const renderedArgs = args.map((arg) => `      <string>${xml(arg)}</string>`).join("\n");
+    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>${xml(definition.label)}</string>
+    <key>ProgramArguments</key>
+    <array>
+${renderedArgs}
+    </array>
+    <key>WorkingDirectory</key>
+    <string>${xml(definition.projectDir)}</string>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>ThrottleInterval</key>
+    <integer>10</integer>
+    <key>StandardOutPath</key>
+    <string>/dev/null</string>
+    <key>StandardErrorPath</key>
+    <string>/dev/null</string>
+  </dict>
+</plist>
+`;
+}
+export function createSystemdUserUnit(definition) {
+    const command = [
+        definition.nodePath,
+        "--disable-warning=ExperimentalWarning",
+        ...(definition.envFile ? [`--env-file=${definition.envFile}`] : []),
+        "--enable-source-maps",
+        definition.entryPoint,
+    ]
+        .map(systemdQuote)
+        .join(" ");
+    return `[Unit]
+Description=${definition.description}
+After=graphical-session.target
+
+[Service]
+Type=simple
+WorkingDirectory=${systemdQuote(definition.projectDir)}
+ExecStart=${command}
+Restart=on-failure
+RestartSec=10
+StandardOutput=null
+StandardError=null
+
+[Install]
+WantedBy=default.target
+`;
+}

package/dist/util/logger.js

@@ -0,0 +1,74 @@
+import { appendFileSync, existsSync, mkdirSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { dirname } from "node:path";
+const PRIORITY = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+    silent: 50,
+};
+const DEFAULT_MAX_LOG_BYTES = 1024 * 1024;
+export function resolveLogLevel(env = process.env) {
+    const configured = env.RPC_LOG_LEVEL?.trim().toLowerCase();
+    if (configured && configured in PRIORITY)
+        return configured;
+    return env.RPC_DEBUG === "1" || env.RPC_DEBUG?.toLowerCase() === "true" ? "debug" : "warn";
+}
+function resolveMaxLogBytes() {
+    const parsed = Number.parseInt(process.env.RPC_LOG_MAX_BYTES ?? "", 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_LOG_BYTES;
+}
+const LOG_LEVEL = resolveLogLevel();
+const MAX_LOG_BYTES = resolveMaxLogBytes();
+let logFile;
+export function rotateLogFile(path, maxBytes, incomingBytes = 0) {
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+        if (!existsSync(path) || statSync(path).size + incomingBytes <= maxBytes)
+            return;
+        const archive = `${path}.1`;
+        rmSync(archive, { force: true });
+        renameSync(path, archive);
+    }
+    catch {
+        try {
+            writeFileSync(path, "");
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+export function configureLogger(path) {
+    logFile = path;
+    rotateLogFile(path, MAX_LOG_BYTES);
+}
+export function getLogFile() {
+    return logFile;
+}
+function emit(level, scope, message, extra) {
+    if (PRIORITY[level] < PRIORITY[LOG_LEVEL])
+        return;
+    const line = `${new Date().toISOString()} [${level}] [${scope}] ${message}`;
+    const rendered = extra === undefined ? line : `${line} ${String(extra)}`;
+    const stream = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
+    stream(rendered);
+    if (!logFile)
+        return;
+    try {
+        const output = `${rendered}\n`;
+        rotateLogFile(logFile, MAX_LOG_BYTES, Buffer.byteLength(output));
+        appendFileSync(logFile, output);
+    }
+    catch {
+        /* ignore */
+    }
+}
+export function createLogger(scope) {
+    return {
+        debug: (message, extra) => emit("debug", scope, message, extra),
+        info: (message, extra) => emit("info", scope, message, extra),
+        warn: (message, extra) => emit("warn", scope, message, extra),
+        error: (message, extra) => emit("error", scope, message, extra),
+    };
+}

package/dist/util/process-liveness.js

@@ -0,0 +1,231 @@
+import { execFile } from "node:child_process";
+import { createLogger } from "./logger.js";
+const log = createLogger("proc-liveness");
+const POLL_MS = 20_000;
+const SCAN_TIMEOUT_MS = 10_000;
+const DEAD_CONFIRMATIONS = 2;
+export const CLAUDE_WINDOWS_PROCESS_RULES = [
+    { name: /^claude$/i, path: /\\WindowsApps\\Claude_/i, hasMainWindow: true },
+    { name: /^claude$/i, path: /^(?!.*\\WindowsApps\\Claude_).+$/i },
+];
+export const CODEX_WINDOWS_PROCESS_RULES = [
+    { name: /^ChatGPT$/i, path: /\\WindowsApps\\OpenAI\.Codex_/i, hasMainWindow: true },
+    { name: /^codex$/i, commandLine: /^(?!.*\bapp-server\b).+$/i },
+];
+function regexMatches(pattern, value) {
+    pattern.lastIndex = 0;
+    return pattern.test(value);
+}
+export function parseElapsedTimeSeconds(value) {
+    const trimmed = value.trim();
+    if (/^\d+$/.test(trimmed))
+        return Number(trimmed);
+    const dayParts = trimmed.split("-");
+    if (dayParts.length > 2)
+        return undefined;
+    const days = dayParts.length === 2 ? Number(dayParts[0]) : 0;
+    const clock = dayParts.at(-1)?.split(":") ?? [];
+    if (clock.length < 2 || clock.length > 3 || clock.some((part) => !/^\d+$/.test(part))) {
+        return undefined;
+    }
+    const numbers = clock.map(Number);
+    const seconds = numbers.at(-1);
+    const minutes = numbers.at(-2);
+    const hours = numbers.length === 3 ? numbers[0] : 0;
+    if (seconds >= 60 || minutes >= 60 || (dayParts.length === 2 && hours >= 24))
+        return undefined;
+    return days * 86_400 + hours * 3_600 + minutes * 60 + seconds;
+}
+export function processCommandName(command) {
+    return command.trim().split(/[\\/]/).at(-1)?.replace(/\.exe$/i, "") ?? "";
+}
+export function parsePosixProcessList(raw, pattern, now = Date.now()) {
+    let alive = false;
+    let earliestStartedAt;
+    let pid;
+    for (const line of raw.split("\n")) {
+        const match = line.trim().match(/^(\d+)\s+(\S+)\s+(.+)$/);
+        if (!match || !regexMatches(pattern, processCommandName(match[3])))
+            continue;
+        const elapsedSeconds = parseElapsedTimeSeconds(match[2]);
+        if (elapsedSeconds === undefined)
+            continue;
+        alive = true;
+        const startedAt = now - elapsedSeconds * 1000;
+        if (earliestStartedAt === undefined || startedAt < earliestStartedAt) {
+            earliestStartedAt = startedAt;
+            pid = Number(match[1]);
+        }
+    }
+    return { alive, earliestStartedAt, pid };
+}
+export function matchesWindowsProcess(info, rule) {
+    if (!regexMatches(rule.name, info.name))
+        return false;
+    if (rule.path && !regexMatches(rule.path, info.path))
+        return false;
+    if (rule.commandLine && !regexMatches(rule.commandLine, info.commandLine))
+        return false;
+    if (rule.hasMainWindow !== undefined && rule.hasMainWindow !== info.hasMainWindow)
+        return false;
+    return true;
+}
+function parseWindowsProcesses(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return undefined;
+        const result = [];
+        for (const value of parsed) {
+            if (!value || typeof value !== "object")
+                return undefined;
+            const item = value;
+            if (typeof item.name !== "string" ||
+                typeof item.pid !== "number" ||
+                !Number.isInteger(item.pid) ||
+                item.pid <= 0 ||
+                typeof item.path !== "string" ||
+                typeof item.commandLine !== "string" ||
+                typeof item.hasMainWindow !== "boolean" ||
+                typeof item.startedAt !== "number" ||
+                !Number.isFinite(item.startedAt)) {
+                return undefined;
+            }
+            result.push({
+                pid: item.pid,
+                name: item.name,
+                path: item.path,
+                commandLine: item.commandLine,
+                hasMainWindow: item.hasMainWindow,
+                startedAt: item.startedAt,
+            });
+        }
+        return result;
+    }
+    catch {
+        return undefined;
+    }
+}
+export class ProcessLiveness {
+    pattern;
+    onUpdate;
+    options;
+    timer;
+    scanning = false;
+    stopped = false;
+    lastAlive;
+    deadStreak = 0;
+    constructor(pattern, onUpdate, options = {}) {
+        this.pattern = pattern;
+        this.onUpdate = onUpdate;
+        this.options = options;
+    }
+    start() {
+        void this.scan();
+        this.timer = setInterval(() => void this.scan(), this.options.pollIntervalMs ?? POLL_MS);
+    }
+    stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearInterval(this.timer);
+    }
+    async run(cmd) {
+        const [executable, ...args] = cmd;
+        if (!executable)
+            return undefined;
+        try {
+            return await new Promise((resolve) => {
+                execFile(executable, args, {
+                    encoding: "utf8",
+                    maxBuffer: 4 * 1024 * 1024,
+                    windowsHide: true,
+                    timeout: SCAN_TIMEOUT_MS,
+                    killSignal: "SIGKILL",
+                }, (error, stdout) => resolve(error ? undefined : stdout));
+            });
+        }
+        catch (err) {
+            log.debug(`process list failed: ${err.message}`);
+            return undefined;
+        }
+    }
+    async matches() {
+        if (process.platform === "win32") {
+            const rules = this.options.windowsRules ?? [{ name: this.pattern }];
+            const namePredicate = rules
+                .map((rule) => `$processName -match '${rule.name.source.replace(/'/g, "''")}'`)
+                .join(" -or ");
+            const text = await this.run([
+                "powershell",
+                "-NoProfile",
+                "-NonInteractive",
+                "-Command",
+                `$items = @(Get-CimInstance Win32_Process | ForEach-Object { $processName = [System.IO.Path]::GetFileNameWithoutExtension([string]$_.Name); if (${namePredicate}) { $hasMainWindow = $false; try { $hasMainWindow = (Get-Process -Id $_.ProcessId -ErrorAction Stop).MainWindowHandle -ne 0 } catch {}; $startedAt = 0; try { $startedAt = ([DateTimeOffset]$_.CreationDate).ToUnixTimeMilliseconds() } catch {}; [PSCustomObject]@{ pid = [int]$_.ProcessId; name = $processName; path = [string]$_.ExecutablePath; commandLine = [string]$_.CommandLine; hasMainWindow = $hasMainWindow; startedAt = $startedAt } } }); ConvertTo-Json -InputObject @($items) -Compress`,
+            ]);
+            if (text === undefined)
+                return undefined;
+            const processes = parseWindowsProcesses(text);
+            if (!processes) {
+                log.debug("process list returned invalid JSON");
+                return undefined;
+            }
+            let alive = false;
+            let earliest;
+            let pid;
+            for (const info of processes) {
+                if (!rules.some((rule) => matchesWindowsProcess(info, rule)))
+                    continue;
+                alive = true;
+                const ms = info.startedAt;
+                if (Number.isFinite(ms) && ms > 0 && (earliest === undefined || ms < earliest)) {
+                    earliest = ms;
+                    pid = info.pid;
+                }
+                else if (pid === undefined) {
+                    pid = info.pid;
+                }
+            }
+            return { alive, earliestStartedAt: earliest, pid };
+        }
+        const elapsedColumn = process.platform === "darwin" ? "etime=" : "etimes=";
+        const withStart = await this.run(["ps", "-A", "-o", `pid=,${elapsedColumn},comm=`]);
+        if (withStart !== undefined) {
+            return parsePosixProcessList(withStart, this.pattern);
+        }
+        const namesOnly = await this.run(["ps", "-A", "-o", "comm="]);
+        if (namesOnly === undefined)
+            return undefined;
+        const alive = namesOnly
+            .split("\n")
+            .some((line) => regexMatches(this.pattern, processCommandName(line)));
+        return { alive };
+    }
+    async scan() {
+        if (this.stopped || this.scanning)
+            return;
+        this.scanning = true;
+        try {
+            const result = await this.matches();
+            if (result === undefined)
+                return;
+            if (result.alive) {
+                this.deadStreak = 0;
+            }
+            else {
+                this.deadStreak++;
+                if (this.lastAlive === true && this.deadStreak < DEAD_CONFIRMATIONS)
+                    return;
+            }
+            if (result.alive !== this.lastAlive) {
+                this.lastAlive = result.alive;
+                log.debug(`processes matching ${this.pattern} alive=${result.alive}` +
+                    (result.earliestStartedAt !== undefined ? ` earliestStartedAt=${result.earliestStartedAt}` : "") +
+                    (result.pid !== undefined ? ` pid=${result.pid}` : ""));
+            }
+            this.onUpdate(result.alive, result.earliestStartedAt, result.pid);
+        }
+        finally {
+            this.scanning = false;
+        }
+    }
+}