@plainconceptsplatform/loop-task 2.6.0 → 2.6.1

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

@@ -1,11 +1,24 @@
+import { execa } from "execa";
+import { daemonLog } from "../../daemon-log.js";
 const OPENCODE_BINARIES = ["opencode"];
+const SERVE_PORT = 4096;
+const SERVE_URL = `http://localhost:${SERVE_PORT}`;
+const HEALTH_CHECK_TIMEOUT_MS = 120_000;
+const HEALTH_CHECK_INTERVAL_MS = 1_000;
+const SHUTDOWN_TIMEOUT_MS = 5_000;
 /**
  * Detects `opencode run ...` invocations and enables OpenCode's
  * native OpenTelemetry support, routing to loop-task's endpoint.
+ *
+ * Also manages a persistent `opencode serve` sidecar process so that
+ * `opencode run` tasks delegate to a warm serve instance via `--attach`,
+ * eliminating per-task cold-start time.
  */
 export class OpenCodeTelemetryIntegration {
     constructor() {
         this.id = "opencode";
+        this.serveProcess = null;
+        this.serveInfo = null;
     }
     matches(command, args) {
         const basename = command.split("/").pop()?.replace(/\.exe$/, "").toLowerCase() ?? "";
@@ -15,19 +28,53 @@ export class OpenCodeTelemetryIntegration {
         const env = { ...invocation.env };
         // Enable OpenCode's experimental OpenTelemetry
         env.OPENCODE_EXPERIMENTAL_OPEN_TELEMETRY = "true";
-        // Adapt the OTLP endpoint/proprotocol from the parent context
-        // OpenCode currently reads the standard OTEL_* environment variables
-        // which are already set by the adapter's prepareChildProcess
-        // We just need to make sure the integration is activated.
         return { command: invocation.command, args: [...invocation.args], env };
     }
     parseUsage(result) {
         if (result.exitCode !== 0 || !result.stdout)
             return undefined;
         try {
-            // OpenCode may output JSON with --format json
-            // Try to parse structured output for usage data
+            // With --format json, opencode emits JSONL. The last step_finish event
+            // has token/cost info. Try parsing as JSONL first.
             const lines = result.stdout.trim().split("\n");
+            const jsonlLines = [];
+            let allJson = true;
+            for (const line of lines) {
+                try {
+                    jsonlLines.push(JSON.parse(line));
+                }
+                catch {
+                    allJson = false;
+                    break;
+                }
+            }
+            if (allJson && jsonlLines.length > 0) {
+                // Find the last step_finish event
+                let accumulated = {};
+                for (const evt of jsonlLines) {
+                    if (typeof evt === "object" && evt !== null && evt.type === "step_finish") {
+                        const part = evt.part;
+                        const tokens = part?.tokens;
+                        if (tokens) {
+                            accumulated.inputTokens = (accumulated.inputTokens ?? 0) + (typeof tokens.input === "number" ? tokens.input : 0);
+                            accumulated.outputTokens = (accumulated.outputTokens ?? 0) + (typeof tokens.output === "number" ? tokens.output : 0);
+                            const cache = tokens.cache;
+                            if (cache) {
+                                accumulated.cacheReadTokens = (accumulated.cacheReadTokens ?? 0) + (typeof cache.read === "number" ? cache.read : 0);
+                                accumulated.cacheWriteTokens = (accumulated.cacheWriteTokens ?? 0) + (typeof cache.write === "number" ? cache.write : 0);
+                            }
+                        }
+                        if (typeof part?.cost === "number") {
+                            accumulated.costUsd = (accumulated.costUsd ?? 0) + part.cost;
+                        }
+                    }
+                }
+                if (Object.keys(accumulated).length > 0) {
+                    accumulated.integration = "opencode";
+                    return accumulated;
+                }
+            }
+            // Fallback: try parsing the last line as JSON (legacy --format json without JSONL)
             const lastLine = lines[lines.length - 1];
             if (!lastLine)
                 return undefined;
@@ -63,10 +110,134 @@ export class OpenCodeTelemetryIntegration {
                 usage.sessionId = parsed.sessionId;
             if (Object.keys(usage).length === 0)
                 return undefined;
+            usage.integration = "opencode";
             return usage;
         }
         catch {
             return undefined;
         }
     }
+    async ensureServe(cwd, env) {
+        // Already running and healthy
+        if (this.serveInfo && this.isServeAlive()) {
+            return this.serveInfo;
+        }
+        try {
+            daemonLog("opencode-serve: starting opencode serve sidecar");
+            this.serveProcess = execa("opencode", [
+                "serve",
+                "--port", String(SERVE_PORT),
+                "--hostname", "127.0.0.1",
+            ], {
+                cwd,
+                env: { ...process.env, ...env },
+                stdout: "pipe",
+                stderr: "pipe",
+                buffer: false,
+                detached: false,
+            });
+            this.serveProcess.catch((err) => {
+                daemonLog(`opencode-serve: process error: ${String(err)}`);
+                this.serveProcess = null;
+                this.serveInfo = null;
+            });
+            this.serveProcess.on("exit", (code) => {
+                daemonLog(`opencode-serve: process exited with code ${code}`);
+                this.serveProcess = null;
+                this.serveInfo = null;
+            });
+            // Wait for health check
+            const healthy = await this.waitForHealth();
+            if (healthy) {
+                const pid = this.serveProcess?.pid;
+                if (pid) {
+                    this.serveInfo = { port: SERVE_PORT, pid, url: SERVE_URL };
+                    daemonLog(`opencode-serve: healthy, pid=${pid}, port=${SERVE_PORT}`);
+                    return this.serveInfo;
+                }
+            }
+            daemonLog("opencode-serve: health check timed out");
+            return;
+        }
+        catch (err) {
+            daemonLog(`opencode-serve: failed to start: ${String(err)}`);
+            this.serveProcess = null;
+            this.serveInfo = null;
+            return;
+        }
+    }
+    isServeAlive() {
+        // Fast check: if we don't have a process reference, serve is not alive
+        if (!this.serveProcess || !this.serveInfo)
+            return false;
+        return true;
+    }
+    prepareRunArgs(args, cwd) {
+        const modified = [...args];
+        // Inject --attach after "run" (args[0] === "run")
+        const runIndex = modified.indexOf("run");
+        if (runIndex === -1)
+            return modified;
+        // Check if --attach is already present
+        const hasAttach = modified.includes("--attach");
+        if (!hasAttach) {
+            modified.splice(runIndex + 1, 0, "--attach", SERVE_URL);
+        }
+        // Inject --dir so serve knows which directory to work in
+        const hasDir = modified.includes("--dir");
+        if (!hasDir && cwd) {
+            // Find the position after --attach (or after "run" if --attach wasn't added by us)
+            const attachIdx = modified.indexOf("--attach");
+            const insertPos = attachIdx >= 0 ? attachIdx + 2 : runIndex + 1;
+            modified.splice(insertPos, 0, "--dir", cwd);
+        }
+        return modified;
+    }
+    async shutdownServe() {
+        if (!this.serveProcess)
+            return;
+        daemonLog("opencode-serve: shutting down serve process");
+        const proc = this.serveProcess;
+        this.serveProcess = null;
+        this.serveInfo = null;
+        try {
+            proc.kill("SIGTERM");
+            await Promise.race([
+                proc,
+                new Promise((_, reject) => setTimeout(() => reject(new Error("shutdown timeout")), SHUTDOWN_TIMEOUT_MS)),
+            ]);
+        }
+        catch {
+            // Force kill if SIGTERM didn't work
+            try {
+                proc.kill("SIGKILL");
+            }
+            catch {
+                // best effort
+            }
+        }
+    }
+    async waitForHealth() {
+        const start = Date.now();
+        while (Date.now() - start < HEALTH_CHECK_TIMEOUT_MS) {
+            if (!this.serveProcess)
+                return false; // process exited
+            try {
+                const controller = new AbortController();
+                const timeout = setTimeout(() => controller.abort(), 3_000);
+                const res = await fetch(`${SERVE_URL}/global/health`, { signal: controller.signal });
+                clearTimeout(timeout);
+                if (res.ok) {
+                    const data = await res.json();
+                    if (data.healthy === true)
+                        return true;
+                }
+            }
+            catch {
+                // server not ready yet
+            }
+            await new Promise((r) => setTimeout(r, HEALTH_CHECK_INTERVAL_MS));
+        }
+        return false;
+    }
 }

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

@@ -0,0 +1,78 @@
+import { daemonLog } from "../daemon-log.js";
+import { getAgentIntegrations } from "./agent-integrations/index.js";
+/**
+ * Manages the lifecycle of persistent agent serve sidecars (e.g., opencode serve).
+ *
+ * On daemon boot, starts serve processes for integrations that support them.
+ * On daemon shutdown, gracefully stops all serve processes.
+ *
+ * The serve manager is the single owner of serve process lifecycle.
+ * The TelemetryManager and command-runner reference the integration's
+ * isServeAlive() to check state, but never start/stop serve processes directly.
+ */
+export class AgentServeManager {
+    constructor(settings, telemetryManager) {
+        this.settings = settings;
+        this.telemetryManager = telemetryManager;
+        this.integrations = [];
+        this.integrations = [...getAgentIntegrations()];
+    }
+    /**
+     * Start serve sidecars for all integrations that support them.
+     * Called on daemon boot.
+     */
+    async ensureAllServe(cwd) {
+        const endpoint = this.settings.telemetryEndpoint;
+        if (!endpoint) {
+            daemonLog("agent-serve-manager: no telemetry endpoint, skipping serve startup");
+            return;
+        }
+        // Build static OTEL env for serve processes
+        const serveEnv = {
+            OTEL_EXPORTER_OTLP_ENDPOINT: endpoint,
+            OTEL_EXPORTER_OTLP_PROTOCOL: this.settings.telemetryProtocol,
+            OTEL_TRACES_EXPORTER: "otlp",
+            OTEL_METRICS_EXPORTER: "otlp",
+            OTEL_LOGS_EXPORTER: "otlp",
+            OTEL_RESOURCE_ATTRIBUTES: `service.name=${this.settings.telemetryServiceName}`,
+        };
+        if (this.settings.telemetryAutoInstrumentAgents) {
+            serveEnv.OPENCODE_EXPERIMENTAL_OPEN_TELEMETRY = "true";
+            serveEnv.CLAUDE_CODE_ENABLE_TELEMETRY = "1";
+        }
+        for (const integration of this.integrations) {
+            if (!integration.ensureServe)
+                continue;
+            try {
+                daemonLog(`agent-serve-manager: ensuring serve for integration "${integration.id}"`);
+                const info = await integration.ensureServe(cwd, serveEnv);
+                if (info) {
+                    daemonLog(`agent-serve-manager: serve started for "${integration.id}", pid=${info.pid}, port=${info.port}`);
+                }
+                else {
+                    daemonLog(`agent-serve-manager: serve not started for "${integration.id}" (not supported or failed)`);
+                }
+            }
+            catch (err) {
+                daemonLog(`agent-serve-manager: failed to start serve for "${integration.id}": ${String(err)}`);
+            }
+        }
+    }
+    /**
+     * Gracefully shut down all managed serve processes.
+     * Called on daemon shutdown.
+     */
+    async shutdownAll() {
+        for (const integration of this.integrations) {
+            if (!integration.shutdownServe)
+                continue;
+            try {
+                daemonLog(`agent-serve-manager: shutting down serve for "${integration.id}"`);
+                await integration.shutdownServe();
+            }
+            catch (err) {
+                daemonLog(`agent-serve-manager: error shutting down "${integration.id}": ${String(err)}`);
+            }
+        }
+    }
+}

package/dist/daemon/telemetry/noop-telemetry-adapter.js

@@ -39,6 +39,7 @@ export class NoopTelemetryAdapter {
     recordRetry() { }
     recordFailure() { }
     recordAgentUsage() { }
+    logEvent() { }
     prepareChildProcess(_invocation, _context, _integrationOverride) {
         return { env: {} };
     }

package/dist/daemon/telemetry/open-telemetry-adapter.js

@@ -11,6 +11,10 @@ import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
 import { OTLPMetricExporter as OTLPMetricExporterGrpc } from "@opentelemetry/exporter-metrics-otlp-grpc";
 import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
 import { trace, context, propagation, metrics, SpanStatusCode, SpanKind } from "@opentelemetry/api";
+import { logs } from "@opentelemetry/api-logs";
+import { LoggerProvider, SimpleLogRecordProcessor } from "@opentelemetry/sdk-logs";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPLogExporter as OTLPLogExporterGrpc } from "@opentelemetry/exporter-logs-otlp-grpc";
 import { daemonLog } from "../daemon-log.js";
 class OtelSpan {
     constructor(span, ctx, onEnd) {
@@ -79,9 +83,11 @@ export class OpenTelemetryAdapter {
     constructor(settings) {
         this.sdk = null;
         this.tracerProvider = null;
+        this.loggerProvider = null;
         this.settings = settings;
         this.tracer = trace.getTracer("loop-task");
         this.meter = metrics.getMeter("loop-task");
+        this.logger = logs.getLogger("loop-task");
         this.status = {
             enabled: settings.telemetryEnabled,
             exporterConfigured: !!settings.telemetryEndpoint,
@@ -93,7 +99,12 @@ export class OpenTelemetryAdapter {
             captureCommandOutput: settings.telemetryCaptureCommandOutput,
             exporterState: this.resolveExporterState(settings),
         };
-        // Initialize metric instruments (always created — no-op when no SDK)
+        if (settings.telemetryEnabled && settings.telemetryEndpoint) {
+            this.initializeSdk(settings);
+        }
+        // Initialize metric instruments AFTER SDK startup so they bind to the
+        // real MeterProvider, not the default no-op one. When the SDK is not
+        // initialized, these still work — they bind to the API-level no-op meter.
         this.runCounter = this.meter.createCounter(METRIC_NAMES.RUNS);
         this.runDurationHistogram = this.meter.createHistogram(METRIC_NAMES.RUN_DURATION);
         this.taskCounter = this.meter.createCounter(METRIC_NAMES.TASKS);
@@ -109,9 +120,6 @@ export class OpenTelemetryAdapter {
         this.agentCacheWriteTokensCounter = this.meter.createCounter(METRIC_NAMES.AGENT_CACHE_WRITE_TOKENS);
         this.agentCostCounter = this.meter.createCounter(METRIC_NAMES.AGENT_COST);
         this.failureCounter = this.meter.createCounter(METRIC_NAMES.FAILURES);
-        if (settings.telemetryEnabled && settings.telemetryEndpoint) {
-            this.initializeSdk(settings);
-        }
     }
     resolveExporterState(settings) {
         if (!settings.telemetryEnabled)
@@ -162,7 +170,24 @@ export class OpenTelemetryAdapter {
                 instrumentations: [],
             });
             this.sdk.start();
+            // Re-obtain tracer and meter from the global API after SDK startup.
+            // The API now resolves to the real providers registered by NodeSDK.
             this.tracer = trace.getTracer(settings.telemetryServiceName);
+            this.meter = metrics.getMeter(settings.telemetryServiceName);
+            // Initialize OTLP log exporter
+            const logsUrl = endpoint.endsWith("/v1/logs")
+                ? endpoint
+                : `${endpoint}/v1/logs`;
+            const logExporter = isGrpc
+                ? new OTLPLogExporterGrpc({ url: settings.telemetryEndpoint })
+                : new OTLPLogExporter({ url: logsUrl, headers });
+            const loggerProvider = new LoggerProvider({
+                resource,
+                processors: [new SimpleLogRecordProcessor({ exporter: logExporter })],
+            });
+            logs.setGlobalLoggerProvider(loggerProvider);
+            this.loggerProvider = loggerProvider;
+            this.logger = logs.getLogger(settings.telemetryServiceName);
             this.status.exporterState = "configured";
             daemonLog(`telemetry: SDK initialized, endpoint=${settings.telemetryEndpoint}`);
         }
@@ -197,6 +222,24 @@ export class OpenTelemetryAdapter {
             return "http/protobuf";
         return this.settings.telemetryProtocol;
     }
+    /**
+     * Check if any agent serve sidecar is alive.
+     * When serve is alive, static OTEL config lives in the serve process
+     * and we skip per-task injection.
+     */
+    checkServeAlive() {
+        try {
+            const integrations = getAgentIntegrations();
+            for (const integration of integrations) {
+                if (integration.isServeAlive?.())
+                    return true;
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
     startLoop(input) {
         const span = this.tracer.startSpan(SPAN_NAMES.LOOP_RUN, { kind: SpanKind.SERVER });
         span.setAttributes({
@@ -324,6 +367,20 @@ export class OpenTelemetryAdapter {
             activeSpan.setAttribute("gen_ai.request.model", input.model);
         }
     }
+    logEvent(level, message, attributes) {
+        try {
+            const record = this.logger.emit({
+                body: message,
+                severityText: level,
+                attributes: attributes ?? {},
+            });
+            // Ensure the log record is flushed in a timely manner
+            void record;
+        }
+        catch (err) {
+            daemonLog(`telemetry: log emit failed: ${String(err)}`);
+        }
+    }
     prepareChildProcess(invocation, childContext, integrationOverride) {
         const env = {};
         const endpoint = this.resolveEndpoint();
@@ -337,25 +394,34 @@ export class OpenTelemetryAdapter {
                 env.TRACESTATE = childContext.traceState;
             }
         }
-        env.OTEL_EXPORTER_OTLP_ENDPOINT = endpoint;
-        env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT = endpoint;
-        env.OTEL_EXPORTER_OTLP_PROTOCOL = protocol;
-        env.OTEL_TRACES_EXPORTER = "otlp";
-        const authHeaders = process.env.OTEL_EXPORTER_OTLP_HEADERS
-            ?? process.env.OTEL_EXPORTER_OTLP_TRACES_HEADERS;
-        if (authHeaders) {
-            env.OTEL_EXPORTER_OTLP_HEADERS = authHeaders;
+        // Check if an agent serve sidecar is alive — if so, static OTEL config
+        // lives in the serve process env and we skip per-task injection.
+        const serveAlive = this.checkServeAlive();
+        if (!serveAlive) {
+            env.OTEL_EXPORTER_OTLP_ENDPOINT = endpoint;
+            env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT = endpoint;
+            env.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT = endpoint;
+            env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT = endpoint;
+            env.OTEL_EXPORTER_OTLP_PROTOCOL = protocol;
+            env.OTEL_TRACES_EXPORTER = "otlp";
+            env.OTEL_METRICS_EXPORTER = "otlp";
+            env.OTEL_LOGS_EXPORTER = "otlp";
+            const authHeaders = process.env.OTEL_EXPORTER_OTLP_HEADERS
+                ?? process.env.OTEL_EXPORTER_OTLP_TRACES_HEADERS;
+            if (authHeaders) {
+                env.OTEL_EXPORTER_OTLP_HEADERS = authHeaders;
+            }
+            const correlationAttrs = {
+                [CORRELATION_KEYS.RUN_ID]: childContext.runId,
+                [CORRELATION_KEYS.LOOP_ID]: childContext.loopId,
+            };
+            if (childContext.taskId)
+                correlationAttrs[CORRELATION_KEYS.TASK_ID] = childContext.taskId;
+            if (childContext.projectId)
+                correlationAttrs[CORRELATION_KEYS.PROJECT_ID] = childContext.projectId;
+            const mergedResourceAttrs = this.mergeResourceAttributes(process.env.OTEL_RESOURCE_ATTRIBUTES, correlationAttrs);
+            env.OTEL_RESOURCE_ATTRIBUTES = mergedResourceAttrs;
         }
-        const correlationAttrs = {
-            [CORRELATION_KEYS.RUN_ID]: childContext.runId,
-            [CORRELATION_KEYS.LOOP_ID]: childContext.loopId,
-        };
-        if (childContext.taskId)
-            correlationAttrs[CORRELATION_KEYS.TASK_ID] = childContext.taskId;
-        if (childContext.projectId)
-            correlationAttrs[CORRELATION_KEYS.PROJECT_ID] = childContext.projectId;
-        const mergedResourceAttrs = this.mergeResourceAttributes(process.env.OTEL_RESOURCE_ATTRIBUTES, correlationAttrs);
-        env.OTEL_RESOURCE_ATTRIBUTES = mergedResourceAttrs;
         // Apply agent-specific integrations when auto-instrumentation is enabled
         let integrationId;
         if (this.settings.telemetryAutoInstrumentAgents || integrationOverride) {
@@ -419,6 +485,9 @@ export class OpenTelemetryAdapter {
             if (this.tracerProvider) {
                 flushes.push(this.tracerProvider.forceFlush());
             }
+            if (this.loggerProvider) {
+                flushes.push(this.loggerProvider.forceFlush());
+            }
             const sdkInternals = this.sdk;
             if (typeof sdkInternals._meterProvider?.forceFlush === "function") {
                 flushes.push(sdkInternals._meterProvider.forceFlush());
@@ -450,6 +519,16 @@ export class OpenTelemetryAdapter {
             }
             this.tracerProvider = null;
         }
+        if (this.loggerProvider) {
+            try {
+                await this.loggerProvider.forceFlush();
+                await this.loggerProvider.shutdown();
+            }
+            catch {
+                // best effort
+            }
+            this.loggerProvider = null;
+        }
         if (!this.sdk)
             return;
         try {

package/dist/shared/i18n/en.json

@@ -460,7 +460,7 @@
     "project.wizard.directoryPrompt": "Working directory? (optional)",
     "project.wizard.directoryHint": "Default directory for loops in this project. Leave blank to inherit",
     "project.wizard.githubSourcePrompt": "GitHub Source? (optional)",
-    "project.wizard.githubSourceHint": "Repository in owner/repo format, e.g. CKGrafico/loop-task",
+    "project.wizard.githubSourceHint": "Repository in owner/repo format, e.g. PlainConceptsPlatform/loop-task",
     "project.error.updateFailed": "Failed to update project",
     "project.error.deleteFailed": "Failed to delete project",
     "project.toastCreated": "Project \"{name}\" created",