@plainconceptsplatform/loop-task 2.6.0

package/dist/daemon/telemetry/telemetry-manager.js

@@ -0,0 +1,147 @@
+import { NoopTelemetryAdapter } from "./noop-telemetry-adapter.js";
+import { OpenTelemetryAdapter } from "./open-telemetry-adapter.js";
+import { daemonLog } from "../daemon-log.js";
+/**
+ * Manages the lifecycle of the telemetry system.
+ * Responds to runtime settings changes by switching between
+ * NoopTelemetryAdapter and OpenTelemetryAdapter.
+ *
+ * This is the single entry point the daemon uses for telemetry.
+ */
+export class TelemetryManager {
+    constructor(settings) {
+        this.settings = settings;
+        this.adapter = this.createAdapter(settings);
+    }
+    createAdapter(settings) {
+        if (!settings.telemetryEnabled) {
+            return new NoopTelemetryAdapter({
+                enabled: false,
+                exporterState: "disabled",
+                protocol: settings.telemetryProtocol,
+                serviceName: settings.telemetryServiceName,
+            });
+        }
+        if (!settings.telemetryEndpoint) {
+            // Enabled but no endpoint: no-op that reports "not-configured"
+            return new NoopTelemetryAdapter({
+                enabled: true,
+                exporterConfigured: false,
+                exporterState: "not-configured",
+                protocol: settings.telemetryProtocol,
+                serviceName: settings.telemetryServiceName,
+                autoInstrumentAgents: settings.telemetryAutoInstrumentAgents,
+                captureContent: settings.telemetryCaptureContent,
+                captureCommandOutput: settings.telemetryCaptureCommandOutput,
+            });
+        }
+        return new OpenTelemetryAdapter(settings);
+    }
+    /**
+     * Called when daemon settings change at runtime.
+     * May replace the adapter if telemetry settings changed.
+     */
+    onSettingsChanged(newSettings) {
+        const oldSettings = this.settings;
+        this.settings = newSettings;
+        const telemetryChanged = oldSettings.telemetryEnabled !== newSettings.telemetryEnabled ||
+            oldSettings.telemetryEndpoint !== newSettings.telemetryEndpoint ||
+            oldSettings.telemetryProtocol !== newSettings.telemetryProtocol ||
+            oldSettings.telemetryServiceName !== newSettings.telemetryServiceName;
+        if (!telemetryChanged)
+            return;
+        daemonLog(`telemetry: settings changed, reconfiguring adapter`);
+        // Flush and shutdown old adapter before creating new one
+        const oldAdapter = this.adapter;
+        (async () => {
+            try {
+                await oldAdapter.flush();
+                await oldAdapter.shutdown();
+            }
+            catch (err) {
+                daemonLog(`telemetry: flush/shutdown during reconfigure failed: ${String(err)}`);
+            }
+        })();
+        // Create new adapter with updated settings
+        this.adapter = this.createAdapter(newSettings);
+    }
+    /** Get the current telemetry adapter */
+    getAdapter() {
+        return this.adapter;
+    }
+    /** Get telemetry status */
+    getStatus() {
+        return this.adapter.getStatus();
+    }
+    /**
+     * Test the telemetry connection by emitting a diagnostic span
+     * and attempting a flush. Returns success or error message.
+     */
+    async testConnection() {
+        const firstAttempt = await this.testAdapterConnection();
+        if (firstAttempt.success || firstAttempt.message === "OpenTelemetry is disabled" || firstAttempt.message === "No endpoint configured") {
+            return firstAttempt;
+        }
+        // Recreate the exporter once so a first-run or collector startup race does not
+        // require the user to toggle telemetry off and on manually.
+        daemonLog(`telemetry: connection test failed, recreating adapter before retry: ${firstAttempt.message}`);
+        await this.recreateAdapter();
+        return this.testAdapterConnection();
+    }
+    async testAdapterConnection() {
+        const status = this.adapter.getStatus();
+        if (!status.enabled) {
+            return { success: false, message: "OpenTelemetry is disabled" };
+        }
+        if (!status.endpoint) {
+            return { success: false, message: "No endpoint configured" };
+        }
+        try {
+            // Start and end a diagnostic span
+            const span = this.adapter.startLoop({
+                loopId: "diagnostic",
+                loopName: "connection-test",
+                runId: `test-${Date.now()}`,
+            });
+            span.setAttribute("loop_task.diagnostic", true);
+            span.ok();
+            // Attempt a bounded flush
+            await Promise.race([
+                this.adapter.flush(),
+                new Promise((_, reject) => setTimeout(() => reject(new Error("flush timeout")), 5000)),
+            ]);
+            return { success: true, message: status.endpoint };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return { success: false, message: msg };
+        }
+    }
+    async recreateAdapter() {
+        const oldAdapter = this.adapter;
+        try {
+            await oldAdapter.shutdown();
+        }
+        catch (err) {
+            daemonLog(`telemetry: adapter recreation shutdown failed: ${String(err)}`);
+        }
+        this.adapter = this.createAdapter(this.settings);
+    }
+    /** Flush pending telemetry */
+    async flush() {
+        await this.adapter.flush();
+    }
+    /** Shutdown telemetry gracefully */
+    async shutdown() {
+        try {
+            await Promise.race([
+                this.adapter.flush(),
+                new Promise((_, reject) => setTimeout(() => reject(new Error("flush timeout")), 5000)),
+            ]);
+        }
+        catch (err) {
+            daemonLog(`telemetry: flush during shutdown failed: ${String(err)}`);
+        }
+        await this.adapter.shutdown();
+    }
+}

package/dist/daemon/telemetry/telemetry-redaction.js

@@ -0,0 +1,67 @@
+/**
+ * Redaction utilities for telemetry.
+ * Ensures secrets, prompts, and sensitive content are never exported.
+ */
+/** Patterns that indicate a secret or authentication value */
+const SECRET_PATTERNS = [
+    /api[_-]?key/i,
+    /auth(orization)?/i,
+    /token/i,
+    /secret/i,
+    /password/i,
+    /credential/i,
+    /otlp[_-]?header/i,
+];
+/** Environment variables that should never be captured in telemetry */
+const SENSITIVE_ENV_VARS = new Set([
+    "OTEL_EXPORTER_OTLP_HEADERS",
+    "OTEL_EXPORTER_OTLP_TRACES_HEADERS",
+    "OTEL_EXPORTER_OTLP_METRICS_HEADERS",
+    "OTEL_EXPORTER_OTLP_LOGS_HEADERS",
+]);
+/**
+ * Sanitize command arguments for telemetry.
+ * Removes prompt content, preserves argument count and structure.
+ */
+export function sanitizeCommandArgs(args, captureContent) {
+    if (captureContent) {
+        return { argumentCount: args.length, sanitizedArgs: args };
+    }
+    return {
+        argumentCount: args.length,
+        sanitizedArgs: args.map(() => "<redacted>"),
+    };
+}
+/**
+ * Check if an environment variable name is safe to include in telemetry.
+ */
+export function isSafeEnvVar(name) {
+    if (SENSITIVE_ENV_VARS.has(name))
+        return false;
+    return !SECRET_PATTERNS.some((p) => p.test(name));
+}
+/**
+ * Sanitize environment variables for telemetry output.
+ * Returns only the names of safe variables, never values.
+ */
+export function sanitizeEnvVarNames(names) {
+    return names.filter(isSafeEnvVar);
+}
+/**
+ * Redact header values for display. Never expose actual values.
+ */
+export function redactHeaders(headers) {
+    if (Object.keys(headers).length === 0)
+        return "not configured";
+    return "configured";
+}
+/**
+ * Sanitize a command line for telemetry display.
+ * Replaces quoted strings (likely prompts) with a placeholder.
+ */
+export function sanitizeCommandLine(command, captureContent) {
+    if (captureContent)
+        return command;
+    // Replace content in quotes with <redacted>
+    return command.replace(/"([^"\\]|\\.)*"/g, '"<redacted>"').replace(/'([^'\\]|\\.)*'/g, "'<redacted>'");
+}

package/dist/daemon/telemetry/telemetry-types.js

@@ -0,0 +1,45 @@
+/**
+ * Internal telemetry types used by the daemon telemetry system.
+ * These are NOT the same as DaemonSettings telemetry fields — they are
+ * the runtime representations used by TelemetryManager and adapters.
+ */
+/** Stable span names — never include dynamic identifiers */
+export const SPAN_NAMES = {
+    LOOP_RUN: "loop_task.loop.run",
+    LOOP_RESOLVE: "loop_task.loop.resolve",
+    TASK_EXECUTE: "loop_task.task.execute",
+    COMMAND_EXECUTE: "loop_task.command.execute",
+    AGENT_EXECUTE: "loop_task.agent.execute",
+    GIT_COMMIT: "loop_task.git.commit",
+    GITHUB_ISSUE_UPDATE: "loop_task.github.issue.update",
+    GITHUB_PR_CREATE: "loop_task.github.pull_request.create",
+};
+/** Correlation attribute keys */
+export const CORRELATION_KEYS = {
+    RUN_ID: "loop_task.run.id",
+    LOOP_ID: "loop_task.loop.id",
+    LOOP_NAME: "loop_task.loop.name",
+    TASK_ID: "loop_task.task.id",
+    TASK_NAME: "loop_task.task.name",
+    PROJECT_ID: "loop_task.project.id",
+    PROJECT_NAME: "loop_task.project.name",
+    AGENT_INTEGRATION: "loop_task.agent.integration",
+};
+/** Metric names — bounded cardinality */
+export const METRIC_NAMES = {
+    RUNS: "loop_task.runs",
+    RUN_DURATION: "loop_task.run.duration",
+    TASKS: "loop_task.tasks",
+    TASK_DURATION: "loop_task.task.duration",
+    TASK_RETRIES: "loop_task.task.retries",
+    COMMANDS: "loop_task.commands",
+    COMMAND_DURATION: "loop_task.command.duration",
+    AGENT_EXECUTIONS: "loop_task.agent.executions",
+    AGENT_DURATION: "loop_task.agent.duration",
+    AGENT_INPUT_TOKENS: "loop_task.agent.input_tokens",
+    AGENT_OUTPUT_TOKENS: "loop_task.agent.output_tokens",
+    AGENT_CACHE_READ_TOKENS: "loop_task.agent.cache_read_tokens",
+    AGENT_CACHE_WRITE_TOKENS: "loop_task.agent.cache_write_tokens",
+    AGENT_COST: "loop_task.agent.cost",
+    FAILURES: "loop_task.failures",
+};

package/dist/daemon/telemetry/telemetry.js

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

package/dist/daemon/watcher/index.js

@@ -0,0 +1,250 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { loopsJson, tasksJson, projectsJson } from "../../shared/config/paths.js";
+const DEBOUNCE_MS = 300;
+const MTIME_POLL_MS = 2000;
+export class FileWatcher {
+    constructor() {
+        this.watchers = new Map();
+        this.mtimeTimers = new Map();
+        this.dirWatchers = new Map();
+        this.loopManager = null;
+        this.taskManager = null;
+        this.projectManager = null;
+        this.recipeScanner = null;
+        this.deferredReload = null;
+    }
+    setManagers(loopManager, taskManager, projectManager) {
+        this.loopManager = loopManager;
+        this.taskManager = taskManager;
+        this.projectManager = projectManager;
+    }
+    setRecipeScanner(scanner, deferredReload) {
+        this.recipeScanner = scanner;
+        this.deferredReload = deferredReload;
+    }
+    start() {
+        this.watch(loopsJson(), (content) => this.handleLoopsChange(content));
+        this.watch(tasksJson(), (content) => this.handleTasksChange(content));
+        this.watch(projectsJson(), (content) => this.handleProjectsChange(content));
+    }
+    stop() {
+        for (const [, entry] of this.watchers) {
+            if (entry.debounceTimer)
+                clearTimeout(entry.debounceTimer);
+        }
+        for (const [, timer] of this.mtimeTimers) {
+            clearInterval(timer);
+        }
+        this.watchers.clear();
+        this.mtimeTimers.clear();
+    }
+    registerSelfWrite(filePath, content) {
+        const hash = this.hash(content);
+        const entry = this.watchers.get(filePath);
+        if (entry) {
+            entry.lastHash = hash;
+        }
+    }
+    watch(filePath, onChange) {
+        const dir = path.dirname(filePath);
+        const basename = path.basename(filePath);
+        this.watchers.set(filePath, {
+            lastHash: "",
+            debounceTimer: null,
+            lastMtime: 0,
+        });
+        try {
+            const initialContent = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf-8") : "";
+            this.watchers.get(filePath).lastHash = this.hash(initialContent);
+            this.watchers.get(filePath).lastMtime = fs.statSync(filePath).mtimeMs;
+        }
+        catch {
+            // file doesn't exist yet
+        }
+        try {
+            fs.watch(dir, (eventType, filename) => {
+                if (filename !== basename)
+                    return;
+                this.handleFileEvent(filePath, onChange);
+            });
+        }
+        catch {
+            // fs.watch not available, mtime polling will handle it
+        }
+        const mtimeTimer = setInterval(() => {
+            this.checkMtime(filePath, onChange);
+        }, MTIME_POLL_MS);
+        this.mtimeTimers.set(filePath, mtimeTimer);
+    }
+    handleFileEvent(filePath, onChange) {
+        const entry = this.watchers.get(filePath);
+        if (!entry)
+            return;
+        if (entry.debounceTimer) {
+            clearTimeout(entry.debounceTimer);
+        }
+        entry.debounceTimer = setTimeout(() => {
+            this.processChange(filePath, onChange);
+            entry.debounceTimer = null;
+        }, DEBOUNCE_MS);
+    }
+    checkMtime(filePath, onChange) {
+        const entry = this.watchers.get(filePath);
+        if (!entry)
+            return;
+        try {
+            const stat = fs.statSync(filePath);
+            if (stat.mtimeMs > entry.lastMtime) {
+                entry.lastMtime = stat.mtimeMs;
+                this.handleFileEvent(filePath, onChange);
+            }
+        }
+        catch {
+            // file might not exist
+        }
+    }
+    processChange(filePath, onChange) {
+        const entry = this.watchers.get(filePath);
+        if (!entry)
+            return;
+        let content;
+        try {
+            content = fs.readFileSync(filePath, "utf-8");
+        }
+        catch {
+            return;
+        }
+        const fileHash = this.hash(content);
+        if (fileHash === entry.lastHash) {
+            return;
+        }
+        entry.lastHash = fileHash;
+        try {
+            const stat = fs.statSync(filePath);
+            entry.lastMtime = stat.mtimeMs;
+        }
+        catch {
+            // ignore
+        }
+        try {
+            onChange(content);
+        }
+        catch (error) {
+            console.error(`[file-watcher] Error processing change to ${filePath}:`, error);
+        }
+    }
+    hash(content) {
+        return createHash("sha1").update(content).digest("hex").slice(0, 16);
+    }
+    handleLoopsChange(content) {
+        if (!this.loopManager)
+            return;
+        let newLoops;
+        try {
+            newLoops = JSON.parse(content);
+        }
+        catch {
+            console.error("[file-watcher] Malformed loops.json, keeping old state");
+            return;
+        }
+        this.loopManager.reconcile(newLoops);
+    }
+    handleTasksChange(content) {
+        if (!this.taskManager)
+            return;
+        let newTasks;
+        try {
+            newTasks = JSON.parse(content);
+        }
+        catch {
+            console.error("[file-watcher] Malformed tasks.json, keeping old state");
+            return;
+        }
+        this.taskManager.reload(newTasks);
+    }
+    handleProjectsChange(content) {
+        if (!this.projectManager)
+            return;
+        let newProjects;
+        try {
+            newProjects = JSON.parse(content);
+        }
+        catch {
+            console.error("[file-watcher] Malformed projects.json, keeping old state");
+            return;
+        }
+        this.projectManager.reload(newProjects);
+    }
+    watchRecipeDirectory(projectId, recipesDir) {
+        if (this.dirWatchers.has(recipesDir))
+            return;
+        this.dirWatchers.set(recipesDir, { debounceTimer: null });
+        try {
+            fs.mkdirSync(recipesDir, { recursive: true });
+        }
+        catch {
+            // directory may not be creatable (remote fs, permissions)
+        }
+        try {
+            fs.watch(recipesDir, (eventType, filename) => {
+                if (!filename || (!filename.endsWith(".yaml") && !filename.endsWith(".yml")))
+                    return;
+                this.handleRecipeFileEvent(projectId, recipesDir, filename);
+            });
+        }
+        catch {
+            // fs.watch not available on this path
+        }
+    }
+    stopWatchingRecipeDirectory(recipesDir) {
+        const entry = this.dirWatchers.get(recipesDir);
+        if (entry?.debounceTimer) {
+            clearTimeout(entry.debounceTimer);
+        }
+        this.dirWatchers.delete(recipesDir);
+    }
+    handleRecipeFileEvent(projectId, recipesDir, filename) {
+        if (!this.recipeScanner)
+            return;
+        const entry = this.dirWatchers.get(recipesDir);
+        if (!entry)
+            return;
+        if (entry.debounceTimer) {
+            clearTimeout(entry.debounceTimer);
+        }
+        entry.debounceTimer = setTimeout(() => {
+            entry.debounceTimer = null;
+            this.processRecipeFileChange(projectId, recipesDir, filename);
+        }, DEBOUNCE_MS);
+    }
+    processRecipeFileChange(projectId, recipesDir, filename) {
+        if (!this.recipeScanner || !this.loopManager)
+            return;
+        const filePath = path.join(recipesDir, filename);
+        const existingRecipe = this.recipeScanner.findRecipeByPath(filePath);
+        if (!fs.existsSync(filePath)) {
+            if (existingRecipe) {
+                this.recipeScanner.unloadRecipe(existingRecipe.id);
+                this.deferredReload?.cancelReload(existingRecipe.id);
+            }
+            return;
+        }
+        if (existingRecipe) {
+            const isRunning = this.loopManager.isRunning(existingRecipe.id);
+            if (isRunning && this.deferredReload) {
+                const entry = this.loopManager["recipes"].get(existingRecipe.id);
+                if (entry) {
+                    this.deferredReload.requestReload(existingRecipe.id, filePath, entry.controller);
+                }
+            }
+            else {
+                this.recipeScanner.reloadRecipe(existingRecipe.id);
+            }
+        }
+        else {
+            this.recipeScanner.loadRecipe(projectId, filePath, filename);
+        }
+    }
+}

package/dist/duration.js

@@ -0,0 +1,24 @@
+import ms from "ms";
+import { t } from "./shared/i18n/index.js";
+export function parseDuration(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        throw new Error(t("errors.durationEmpty"));
+    }
+    if (trimmed === "manual" || trimmed === "0") {
+        return 0;
+    }
+    const result = ms(trimmed);
+    if (typeof result !== "number" || isNaN(result)) {
+        throw new Error(t("errors.durationInvalid", { input }));
+    }
+    if (result <= 0) {
+        throw new Error(t("errors.durationNotPositive", { input }));
+    }
+    return result;
+}
+export function formatDuration(value) {
+    if (value === 0)
+        return t("format.durationManual");
+    return ms(value, { long: true });
+}

package/dist/entities/loops/filters.js

@@ -0,0 +1,109 @@
+export const defaultFilters = {
+    status: "all",
+    intervalBucket: "all",
+    recentActivity: "all",
+    query: "",
+};
+const statusOrder = {
+    running: 0,
+    waiting: 1,
+    paused: 2,
+    idle: 3,
+    stopped: 4,
+};
+function intervalBucketOf(interval) {
+    if (interval === 0)
+        return "manual";
+    if (interval <= 60_000)
+        return "short";
+    if (interval <= 3_600_000)
+        return "medium";
+    return "long";
+}
+function activityBucketOf(loop) {
+    const baseline = loop.lastRunAt ?? loop.createdAt;
+    const ageMs = Date.now() - new Date(baseline).getTime();
+    return ageMs <= 15 * 60_000 ? "active" : "stale";
+}
+function matches(loop, filters) {
+    if (filters.status !== "all" && loop.status !== filters.status) {
+        return false;
+    }
+    if (filters.intervalBucket !== "all" &&
+        intervalBucketOf(loop.interval) !== filters.intervalBucket) {
+        return false;
+    }
+    if (filters.recentActivity !== "all" &&
+        activityBucketOf(loop) !== filters.recentActivity) {
+        return false;
+    }
+    const query = filters.query.trim().toLowerCase();
+    if (!query) {
+        return true;
+    }
+    const haystack = [
+        loop.id,
+        loop.command,
+        ...loop.commandArgs,
+        loop.description ?? "",
+        loop.status,
+        loop.intervalHuman,
+    ]
+        .join(" ")
+        .toLowerCase();
+    return haystack.includes(query);
+}
+function describeLoop(loop) {
+    return loop.description?.trim() || [loop.command, ...loop.commandArgs].join(" ").trim();
+}
+function projectSortName(loop, projects) {
+    if (!loop.projectId)
+        return "\uFFFF";
+    const proj = projects.find((p) => p.id === loop.projectId);
+    return proj?.name ?? "\uFFFF";
+}
+function compare(left, right, sort, projects) {
+    if (sort === "description") {
+        const byProject = projectSortName(left, projects).localeCompare(projectSortName(right, projects));
+        if (byProject !== 0)
+            return byProject;
+        return describeLoop(left).localeCompare(describeLoop(right));
+    }
+    if (sort === "created") {
+        return right.createdAt.localeCompare(left.createdAt);
+    }
+    if (sort === "recent") {
+        return (right.lastRunAt ?? right.createdAt).localeCompare(left.lastRunAt ?? left.createdAt);
+    }
+    const byStatus = statusOrder[left.status] - statusOrder[right.status];
+    if (byStatus !== 0) {
+        return byStatus;
+    }
+    const leftNext = left.nextRunAt ?? left.lastRunAt ?? left.createdAt;
+    const rightNext = right.nextRunAt ?? right.lastRunAt ?? right.createdAt;
+    return rightNext.localeCompare(leftNext);
+}
+export function applyLoopFilters(loops, filters, sort, projects = []) {
+    return loops
+        .filter((loop) => matches(loop, filters))
+        .sort((left, right) => compare(left, right, sort, projects));
+}
+const SORT_CYCLE = {
+    description: "status",
+    status: "recent",
+    recent: "created",
+    created: "description",
+};
+export function cycleSortMode(mode) {
+    return SORT_CYCLE[mode];
+}
+const STATUS_CYCLE = {
+    all: "running",
+    running: "waiting",
+    waiting: "paused",
+    paused: "idle",
+    idle: "all",
+};
+export function cycleStatusFilter(status) {
+    return STATUS_CYCLE[status];
+}

package/dist/entities/loops/index.js

@@ -0,0 +1 @@
+export { defaultFilters, applyLoopFilters, cycleSortMode, cycleStatusFilter, } from "./filters.js";