@plainconceptsplatform/loop-task 2.6.0

package/dist/daemon/server/index.js

@@ -0,0 +1,117 @@
+import net from "node:net";
+import { getSocketPath, removeSocketFile } from "../state/index.js";
+import { t } from "../../shared/i18n/index.js";
+import { send } from "../ipc/send.js";
+import { dispatch } from "./handlers/index.js";
+export class IpcServer {
+    constructor(manager, taskManager, settingsManager, telemetryManager) {
+        this.clients = new Set();
+        this.subscribers = new Set();
+        this.manager = manager;
+        this.taskManager = taskManager;
+        this.settingsManager = settingsManager;
+        this.telemetryManager = telemetryManager;
+        this.socketPath = getSocketPath();
+        this.server = net.createServer((socket) => this.handleConnection(socket));
+    }
+    async listen() {
+        removeSocketFile();
+        return new Promise((resolve, reject) => {
+            this.server.on("error", reject);
+            this.server.listen(this.socketPath, () => {
+                this.server.removeListener("error", reject);
+                resolve();
+            });
+        });
+    }
+    async close() {
+        for (const client of this.clients) {
+            client.destroy();
+        }
+        this.clients.clear();
+        this.subscribers.clear();
+        return new Promise((resolve) => {
+            this.server.close(() => {
+                removeSocketFile();
+                resolve();
+            });
+        });
+    }
+    pushEvent(event, data) {
+        for (const socket of this.subscribers) {
+            try {
+                send(socket, { type: "event", event, data });
+            }
+            catch {
+                this.subscribers.delete(socket);
+            }
+        }
+    }
+    handleConnection(socket) {
+        this.clients.add(socket);
+        socket.on("close", () => {
+            this.clients.delete(socket);
+            this.subscribers.delete(socket);
+        });
+        let buffer = "";
+        socket.on("data", (chunk) => {
+            buffer += chunk.toString();
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (line.trim()) {
+                    try {
+                        const request = JSON.parse(line);
+                        this.handleRequest(request, socket);
+                    }
+                    catch {
+                        send(socket, { type: "error", message: t("errors.invalidJson") });
+                    }
+                }
+            }
+        });
+        socket.on("close", () => {
+            this.clients.delete(socket);
+        });
+        socket.on("error", () => {
+            this.clients.delete(socket);
+        });
+    }
+    respondOk(socket, ok, id, data) {
+        if (!ok) {
+            send(socket, { type: "error", message: t("errors.loopNotFound", { id }) });
+        }
+        else if (data !== undefined) {
+            send(socket, { type: "ok", data });
+        }
+        else {
+            send(socket, { type: "ok" });
+        }
+    }
+    async handleRequest(request, socket) {
+        // Dispatch to extracted handlers
+        const handled = await dispatch(request, socket, {
+            manager: this.manager,
+            taskManager: this.taskManager,
+            settingsManager: this.settingsManager,
+            telemetryManager: this.telemetryManager,
+            respondOk: (s, ok, id, data) => this.respondOk(s, ok, id, data),
+        });
+        if (!handled) {
+            // Handle non-dispatchable cases inline
+            switch (request.type) {
+                case "subscribe": {
+                    this.subscribers.add(socket);
+                    send(socket, { type: "ok" });
+                    break;
+                }
+                case "shutdown": {
+                    send(socket, { type: "ok" });
+                    await this.manager.shutdown();
+                    await this.close();
+                    process.exit(0);
+                }
+            }
+        }
+    }
+}

package/dist/daemon/settings-manager.js

@@ -0,0 +1,73 @@
+import fs from "node:fs";
+import { settingsJson } from "../shared/config/paths.js";
+import { daemonLog } from "./daemon-log.js";
+const DEFAULTS = {
+    httpApiEnabled: true,
+    mcpApiEnabled: true,
+    // Binds to all interfaces by default: the daemon is meant to be reachable
+    // (e.g. over SSH/Tailscale/LAN). The API is unauthenticated, so securing
+    // access is the operator's job at the network layer; restrict the bind with
+    // `loop-task http-host <ip|local>` when you want loopback-only.
+    httpApiHost: "0.0.0.0",
+    telemetryEnabled: true,
+    telemetryEndpoint: "http://127.0.0.1:4318",
+    telemetryProtocol: "http/protobuf",
+    telemetryAutoInstrumentAgents: true,
+    telemetryCaptureContent: false,
+    telemetryCaptureCommandOutput: false,
+    telemetryServiceName: "loop-task",
+};
+export class SettingsManager {
+    constructor() {
+        this.settings = { ...DEFAULTS };
+        this.listeners = [];
+    }
+    load() {
+        try {
+            const raw = fs.readFileSync(settingsJson(), "utf-8");
+            const parsed = JSON.parse(raw);
+            if (typeof parsed === "object" && parsed !== null) {
+                this.settings = { ...DEFAULTS, ...parsed };
+            }
+        }
+        catch {
+            this.settings = { ...DEFAULTS };
+        }
+    }
+    save() {
+        const tmp = settingsJson() + ".tmp";
+        fs.writeFileSync(tmp, JSON.stringify(this.settings, null, 2));
+        fs.renameSync(tmp, settingsJson());
+    }
+    get() {
+        return { ...this.settings };
+    }
+    set(partial) {
+        this.settings = { ...this.settings, ...partial };
+        this.save();
+        for (const cb of this.listeners) {
+            try {
+                cb(this.get());
+            }
+            catch (err) {
+                daemonLog(`settings onChange error: ${String(err)}`);
+            }
+        }
+        return this.get();
+    }
+    getTelemetrySettings() {
+        const s = this.settings;
+        return {
+            enabled: s.telemetryEnabled,
+            endpoint: s.telemetryEndpoint,
+            protocol: s.telemetryProtocol,
+            autoInstrumentAgents: s.telemetryAutoInstrumentAgents,
+            captureContent: s.telemetryCaptureContent,
+            captureCommandOutput: s.telemetryCaptureCommandOutput,
+            serviceName: s.telemetryServiceName,
+        };
+    }
+    onChange(callback) {
+        this.listeners.push(callback);
+    }
+}

package/dist/daemon/spawner/index.js

@@ -0,0 +1,204 @@
+import { spawn, execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { readDaemonPid, isDaemonAlive, removeDaemonPid, removeDaemonSignature, readDaemonSignature, computeCodeSignature, getSocketPath, getDaemonStartLockFile, } from "../state/index.js";
+import { t } from "../../shared/i18n/index.js";
+import { DAEMON_POLL_MS, DAEMON_SPAWN_TIMEOUT_MS } from "../../shared/config/constants.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+let cachedSignature = null;
+const START_LOCK_TIMEOUT_MS = 5000;
+function currentCodeSignature() {
+    if (cachedSignature === null) {
+        cachedSignature = computeCodeSignature();
+    }
+    return cachedSignature;
+}
+function blockingWait(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function acquireStartLock() {
+    const lockPath = getDaemonStartLockFile();
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    const deadline = Date.now() + START_LOCK_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        try {
+            const fd = fs.openSync(lockPath, "wx");
+            fs.writeFileSync(fd, String(process.pid));
+            return fd;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST") {
+                throw error;
+            }
+            let ownerPid = null;
+            try {
+                const raw = fs.readFileSync(lockPath, "utf-8").trim();
+                const parsed = Number.parseInt(raw, 10);
+                ownerPid = Number.isNaN(parsed) ? null : parsed;
+            }
+            catch {
+                // The lock may be between creation and its owner PID write.
+            }
+            if (ownerPid !== null && !isDaemonAlive(ownerPid)) {
+                try {
+                    fs.unlinkSync(lockPath);
+                }
+                catch {
+                    // Another waiter may have removed or replaced the stale lock.
+                }
+            }
+            else {
+                blockingWait(DAEMON_POLL_MS);
+            }
+        }
+    }
+    throw new Error("Timed out waiting for another process to start the daemon");
+}
+function releaseStartLock(fd) {
+    fs.closeSync(fd);
+    try {
+        const lockPath = getDaemonStartLockFile();
+        if (fs.readFileSync(lockPath, "utf-8").trim() === String(process.pid)) {
+            fs.unlinkSync(lockPath);
+        }
+    }
+    catch {
+        // The lock may already have been cleaned up after an interrupted start.
+    }
+}
+/**
+ * Find PIDs of all running loop-task daemon processes, excluding the current
+ * process and optionally a tracked PID.
+ */
+function findOrphanedDaemonPids(excludePid) {
+    const pids = [];
+    try {
+        const platform = process.platform;
+        let output;
+        if (platform === "win32") {
+            // Use Get-CimInstance instead of wmic (removed in Windows 11 24H2).
+            // Output format: one line per process: "CommandLine <tab> ProcessId"
+            output = execSync(`powershell -NoProfile -Command "Get-CimInstance Win32_Process -Filter \\"Name='node.exe'\\" | Select-Object CommandLine,ProcessId | Format-Table -HideTableHeaders"`, { encoding: "utf-8", timeout: 5000 });
+            for (const line of output.split("\n")) {
+                if (line.includes("daemon/index.js") || line.includes("daemon/index.ts")) {
+                    const pid = parseInt(line.trim().split(/\s+/).pop() ?? "", 10);
+                    if (!Number.isNaN(pid) && pid !== process.pid && pid !== excludePid) {
+                        pids.push(pid);
+                    }
+                }
+            }
+        }
+        else {
+            output = execSync("pgrep -f 'daemon/index'", {
+                encoding: "utf-8",
+                timeout: 3000,
+            });
+            for (const line of output.split("\n")) {
+                const pid = parseInt(line.trim(), 10);
+                if (!Number.isNaN(pid) && pid !== process.pid && pid !== excludePid) {
+                    pids.push(pid);
+                }
+            }
+        }
+    }
+    catch {
+        // pgrep not available or no matches
+    }
+    return pids;
+}
+export function stopDaemon(pid) {
+    killDaemonPid(pid);
+    killOrphanedDaemons(pid);
+    removeDaemonPid();
+    removeDaemonSignature();
+}
+function killDaemonPid(pid) {
+    try {
+        process.kill(pid, "SIGTERM");
+    }
+    catch {
+        // already gone
+    }
+    const deadline = Date.now() + DAEMON_SPAWN_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        if (!isDaemonAlive(pid)) {
+            break;
+        }
+        blockingWait(DAEMON_POLL_MS);
+    }
+    if (isDaemonAlive(pid)) {
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch {
+            // best effort
+        }
+    }
+}
+function killOrphanedDaemons(excludePid) {
+    const orphans = findOrphanedDaemonPids(excludePid);
+    for (const orphanPid of orphans) {
+        try {
+            process.kill(orphanPid, "SIGTERM");
+        }
+        catch {
+            // already gone
+        }
+    }
+    blockingWait(1000);
+    for (const pid of findOrphanedDaemonPids(excludePid)) {
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch {
+            // best effort
+        }
+    }
+}
+export function ensureDaemon() {
+    const lockFd = acquireStartLock();
+    try {
+        const currentSignature = currentCodeSignature();
+        const pid = readDaemonPid();
+        if (pid !== null && isDaemonAlive(pid)) {
+            if (readDaemonSignature() === currentSignature) {
+                return;
+            }
+            stopDaemon(pid);
+        }
+        else if (pid !== null) {
+            removeDaemonPid();
+            removeDaemonSignature();
+        }
+        const daemonScript = path.resolve(__dirname, __filename.endsWith(".ts") ? "../index.ts" : "../index.js");
+        const args = __filename.endsWith(".ts")
+            ? process.execPath.includes("bun")
+                ? [daemonScript]
+                : ["--import", "tsx", daemonScript]
+            : [daemonScript];
+        const child = spawn(process.execPath, args, {
+            detached: true,
+            stdio: "ignore",
+        });
+        child.unref();
+        const deadline = Date.now() + DAEMON_SPAWN_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            const newPid = readDaemonPid();
+            if (newPid !== null &&
+                isDaemonAlive(newPid) &&
+                readDaemonSignature() === currentSignature) {
+                return;
+            }
+            blockingWait(DAEMON_POLL_MS);
+        }
+        throw new Error(t("errors.daemonFailedToStart"));
+    }
+    finally {
+        releaseStartLock(lockFd);
+    }
+}
+export function getSocket() {
+    return getSocketPath();
+}

package/dist/daemon/state/index.js

@@ -0,0 +1,209 @@
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { removeIfExists, writeFileAtomic } from "../../shared/fs-utils.js";
+import { getLoopsDir, getTasksDir, getLogsDir, logFile, getPidFile, getSignatureFile, getSocketPath, loopsJson, tasksJson, getDataDir, } from "../../shared/config/paths.js";
+export { getDataDir, getPidFile, getSocketPath, getDaemonStartLockFile } from "../../shared/config/paths.js";
+let selfWriteNotifier = null;
+export function setSelfWriteNotifier(notifier) {
+    selfWriteNotifier = notifier;
+}
+function ensureDirs() {
+    fs.mkdirSync(getDataDir(), { recursive: true });
+    fs.mkdirSync(getLogsDir(), { recursive: true });
+}
+function readJsonArray(filePath) {
+    if (!fs.existsSync(filePath))
+        return [];
+    try {
+        const raw = fs.readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+function writeJsonArray(filePath, items) {
+    ensureDirs();
+    const content = JSON.stringify(items, null, 2);
+    writeFileAtomic(filePath, content);
+    if (selfWriteNotifier)
+        selfWriteNotifier(filePath, content);
+}
+export function migrateLoopsToJson() {
+    ensureDirs();
+    const jsonFile = loopsJson();
+    if (fs.existsSync(jsonFile))
+        return;
+    const dir = getLoopsDir();
+    if (!fs.existsSync(dir))
+        return;
+    const files = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+    if (files.length === 0)
+        return;
+    const loops = [];
+    for (const file of files) {
+        try {
+            const raw = fs.readFileSync(path.join(dir, file), "utf-8");
+            loops.push(JSON.parse(raw));
+        }
+        catch {
+            // skip corrupted files
+        }
+    }
+    loops.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    writeJsonArray(jsonFile, loops);
+}
+export function migrateTasksToJson() {
+    ensureDirs();
+    const jsonFile = tasksJson();
+    if (fs.existsSync(jsonFile))
+        return;
+    const dir = getTasksDir();
+    if (!fs.existsSync(dir))
+        return;
+    const files = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+    if (files.length === 0)
+        return;
+    const tasks = [];
+    for (const file of files) {
+        try {
+            const raw = fs.readFileSync(path.join(dir, file), "utf-8");
+            tasks.push(JSON.parse(raw));
+        }
+        catch {
+            // skip corrupted files
+        }
+    }
+    tasks.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    writeJsonArray(jsonFile, tasks);
+}
+export function saveLoop(meta) {
+    const loops = readJsonArray(loopsJson());
+    const idx = loops.findIndex((l) => l.id === meta.id);
+    if (idx >= 0)
+        loops[idx] = meta;
+    else
+        loops.push(meta);
+    writeJsonArray(loopsJson(), loops);
+}
+export function loadLoop(id) {
+    const loops = readJsonArray(loopsJson());
+    return loops.find((l) => l.id === id) ?? null;
+}
+export function loadAllLoops() {
+    const loops = readJsonArray(loopsJson());
+    return loops.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+export function deleteLoop(id) {
+    const loops = readJsonArray(loopsJson());
+    const filtered = loops.filter((l) => l.id !== id);
+    if (filtered.length !== loops.length) {
+        writeJsonArray(loopsJson(), filtered);
+    }
+    removeIfExists(logFile(id));
+}
+export function saveTask(task) {
+    const tasks = readJsonArray(tasksJson());
+    const idx = tasks.findIndex((t) => t.id === task.id);
+    if (idx >= 0)
+        tasks[idx] = task;
+    else
+        tasks.push(task);
+    writeJsonArray(tasksJson(), tasks);
+}
+export function loadTask(id) {
+    const tasks = readJsonArray(tasksJson());
+    return tasks.find((t) => t.id === id) ?? null;
+}
+export function loadAllTasks() {
+    const tasks = readJsonArray(tasksJson());
+    return tasks.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+export function deleteTask(id) {
+    const tasks = readJsonArray(tasksJson());
+    const filtered = tasks.filter((t) => t.id !== id);
+    if (filtered.length !== tasks.length) {
+        writeJsonArray(tasksJson(), filtered);
+    }
+}
+export function getLogPath(id) {
+    ensureDirs();
+    return logFile(id);
+}
+export function computeCodeSignature() {
+    const srcDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+    let maxMtimeMs = 0;
+    let totalSize = 0;
+    let count = 0;
+    const walk = (dir) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(full);
+            }
+            else if (/\.(ts|tsx|js|jsx|json)$/.test(entry.name)) {
+                const stat = fs.statSync(full);
+                maxMtimeMs = Math.max(maxMtimeMs, stat.mtimeMs);
+                totalSize += stat.size;
+                count += 1;
+            }
+        }
+    };
+    try {
+        walk(srcDir);
+    }
+    catch {
+        return "unknown";
+    }
+    return crypto
+        .createHash("sha1")
+        .update(`${Math.round(maxMtimeMs)}:${totalSize}:${count}`)
+        .digest("hex")
+        .slice(0, 16);
+}
+export function readDaemonSignature() {
+    const file = getSignatureFile();
+    if (!fs.existsSync(file))
+        return null;
+    return fs.readFileSync(file, "utf-8").trim() || null;
+}
+export function writeDaemonSignature(signature) {
+    ensureDirs();
+    fs.writeFileSync(getSignatureFile(), signature);
+}
+export function removeDaemonSignature() {
+    removeIfExists(getSignatureFile());
+}
+export function removeSocketFile() {
+    if (process.platform === "win32") {
+        return;
+    }
+    removeIfExists(getSocketPath());
+}
+export function readDaemonPid() {
+    const file = getPidFile();
+    if (!fs.existsSync(file))
+        return null;
+    const raw = fs.readFileSync(file, "utf-8").trim();
+    const pid = parseInt(raw, 10);
+    return isNaN(pid) ? null : pid;
+}
+export function writeDaemonPid(pid) {
+    ensureDirs();
+    fs.writeFileSync(getPidFile(), String(pid));
+}
+export function removeDaemonPid() {
+    removeIfExists(getPidFile());
+}
+export function isDaemonAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/daemon/telemetry/agent-integrations/agent-integration.js

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

package/dist/daemon/telemetry/agent-integrations/claude-code-integration.js

@@ -0,0 +1,55 @@
+const CLAUDE_BINARIES = ["claude"];
+/**
+ * Detects `claude -p ...` or `claude --print ...` invocations and
+ * enables Claude Code's native telemetry, routing to loop-task's endpoint.
+ */
+export class ClaudeCodeTelemetryIntegration {
+    constructor() {
+        this.id = "claude-code";
+    }
+    matches(command, args) {
+        const basename = command.split("/").pop()?.replace(/\.exe$/, "").toLowerCase() ?? "";
+        if (!CLAUDE_BINARIES.includes(basename))
+            return false;
+        // Must have -p or --print flag
+        return args.includes("-p") || args.includes("--print");
+    }
+    prepare(invocation, _context) {
+        const env = { ...invocation.env };
+        // Enable Claude Code's telemetry
+        env.CLAUDE_CODE_ENABLE_TELEMETRY = "1";
+        // The standard OTEL_* env vars are already set by the adapter's
+        // prepareChildProcess. Claude Code reads these natively.
+        return { command: invocation.command, args: [...invocation.args], env };
+    }
+    parseUsage(result) {
+        if (!result.stdout)
+            return undefined;
+        try {
+            // Claude Code may output JSON with usage info
+            // Try to find JSON in the output
+            const jsonMatch = result.stdout.match(/\{[\s\S]*"usage"[\s\S]*\}/);
+            if (!jsonMatch)
+                return undefined;
+            const parsed = JSON.parse(jsonMatch[0]);
+            if (typeof parsed !== "object" || parsed === null)
+                return undefined;
+            const usageData = parsed.usage ?? parsed;
+            const usage = {};
+            if (typeof usageData.input_tokens === "number")
+                usage.inputTokens = usageData.input_tokens;
+            if (typeof usageData.output_tokens === "number")
+                usage.outputTokens = usageData.output_tokens;
+            if (typeof usageData.cache_read_input_tokens === "number")
+                usage.cacheReadTokens = usageData.cache_read_input_tokens;
+            if (typeof usageData.cache_creation_input_tokens === "number")
+                usage.cacheWriteTokens = usageData.cache_creation_input_tokens;
+            if (Object.keys(usage).length === 0)
+                return undefined;
+            return usage;
+        }
+        catch {
+            return undefined;
+        }
+    }
+}

package/dist/daemon/telemetry/agent-integrations/detect-agent-integration.js

@@ -0,0 +1,20 @@
+import { OpenCodeTelemetryIntegration } from "./opencode-integration.js";
+import { ClaudeCodeTelemetryIntegration } from "./claude-code-integration.js";
+/** Built-in agent integrations in priority order */
+const INTEGRATIONS = [
+    new OpenCodeTelemetryIntegration(),
+    new ClaudeCodeTelemetryIntegration(),
+];
+/**
+ * Detect which agent integration matches the given command.
+ * Returns the first matching integration, or undefined if none match.
+ */
+export function detectAgentIntegration(command, args) {
+    return INTEGRATIONS.find((integration) => integration.matches(command, args));
+}
+/**
+ * Get all registered integrations.
+ */
+export function getAgentIntegrations() {
+    return INTEGRATIONS;
+}

package/dist/daemon/telemetry/agent-integrations/index.js

@@ -0,0 +1,3 @@
+export { OpenCodeTelemetryIntegration } from "./opencode-integration.js";
+export { ClaudeCodeTelemetryIntegration } from "./claude-code-integration.js";
+export { detectAgentIntegration, getAgentIntegrations } from "./detect-agent-integration.js";