@orkify/cli 1.0.0-beta.5

package/dist/probe/resolve-sourcemaps.js

@@ -0,0 +1,281 @@
+import { extractContext } from '@orkify/next/utils';
+import { closeSync, existsSync, openSync, readFileSync, readSync, statSync } from 'node:fs';
+import { dirname, isAbsolute, join } from 'node:path';
+import { SourceMapConsumer } from 'source-map-js';
+const SOURCEMAP_URL_RE = /\/[/*]#\s*sourceMappingURL=(\S+)\s*(?:\*\/)?$/;
+/** Protocol prefixes used by bundlers in source map `sources` entries. */
+const SOURCE_PROTOCOL_RE = /^(?:webpack:\/\/\/|webpack-internal:\/\/\/|webpack:\/\/[^/]*\/|vite-[\w-]+:\/\/)/;
+/** Max bytes to read from the tail of a file to find sourceMappingURL. */
+const TAIL_BYTES = 512;
+/**
+ * Parse a base64-encoded inline source map from a data: URL.
+ * Returns the parsed JSON object, or null if parsing fails.
+ */
+function parseInlineSourceMap(dataUrl) {
+    try {
+        const base64Idx = dataUrl.indexOf('base64,');
+        if (base64Idx === -1)
+            return null;
+        const raw = Buffer.from(dataUrl.slice(base64Idx + 7), 'base64').toString('utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Scan lines (newest-first) for a sourceMappingURL comment.
+ * Returns the URL string or null.
+ */
+function scanForSourceMapUrl(content) {
+    const lines = content.split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const match = lines[i].match(SOURCEMAP_URL_RE);
+        if (match)
+            return match[1];
+    }
+    return null;
+}
+function findSourceMap(filePath) {
+    try {
+        const stat = statSync(filePath);
+        const size = stat.size;
+        if (size === 0)
+            return null;
+        // Read only the tail of the file first (sourceMappingURL is always at the end).
+        // This is enough for external .map references (~40 chars).
+        const readSize = Math.min(size, TAIL_BYTES);
+        const buf = Buffer.alloc(readSize);
+        const fd = openSync(filePath, 'r');
+        try {
+            readSync(fd, buf, 0, readSize, size - readSize);
+        }
+        finally {
+            closeSync(fd);
+        }
+        const tail = buf.toString('utf8');
+        let url = scanForSourceMapUrl(tail);
+        // If no match in the tail but we didn't read the whole file, the comment
+        // might be a long inline data: URL whose "//# sourceMappingURL=" prefix
+        // falls outside our 512-byte window. Fall back to full read.
+        if (!url && readSize < size) {
+            const full = readFileSync(filePath, 'utf8');
+            url = scanForSourceMapUrl(full);
+        }
+        if (!url)
+            return null;
+        if (url.startsWith('data:')) {
+            const data = parseInlineSourceMap(url);
+            return data ? { type: 'inline', data } : null;
+        }
+        // External .map file
+        const resolvedPath = isAbsolute(url) ? url : join(dirname(filePath), url);
+        return { type: 'file', path: resolvedPath };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Strip bundler protocol prefixes from source paths.
+ * e.g. "webpack:///src/app.ts" → "src/app.ts"
+ *      "webpack-internal:///./src/app.ts" → "./src/app.ts"
+ *      "vite-node:///src/app.ts" → "src/app.ts"
+ */
+function stripSourceProtocol(source) {
+    return source.replace(SOURCE_PROTOCOL_RE, '');
+}
+/**
+ * Resolve a source file path for display.
+ *
+ * For standalone bundler output (webpack/vite), `join(mapDir, source)` typically
+ * points to the real file. For Next.js, the source is relative to the project
+ * root (e.g. "src/app/page.tsx") but the .map lives deep inside .next/, so the
+ * naive join produces a wrong path. We walk up from the map directory looking
+ * for a package.json (project root marker) and resolve relative to that.
+ */
+function resolveDisplayPath(cleanSource, mapDir) {
+    if (isAbsolute(cleanSource))
+        return cleanSource;
+    // Fast path: source exists relative to the map directory (standalone bundles)
+    const naiveJoin = join(mapDir, cleanSource);
+    if (existsSync(naiveJoin))
+        return naiveJoin;
+    // Walk up to find the project root (package.json), then resolve relative to it
+    let dir = mapDir;
+    const root = dirname(dir) === dir ? dir : '/'; // filesystem root
+    while (dir !== root) {
+        if (existsSync(join(dir, 'package.json'))) {
+            const candidate = join(dir, cleanSource);
+            if (existsSync(candidate))
+                return candidate;
+        }
+        dir = dirname(dir);
+    }
+    // Fallback: return the clean relative source as-is (still readable)
+    return cleanSource;
+}
+/**
+ * Try to resolve a single frame using its source map.
+ * Returns the resolved frame or null if resolution fails.
+ */
+function resolveFrame(frame, consumerCache) {
+    // Find the source map (external file or inline data: URL)
+    const sourceMap = findSourceMap(frame.file);
+    let consumer;
+    let mapDir = dirname(frame.file);
+    if (sourceMap) {
+        if (sourceMap.type === 'inline') {
+            // Inline source map — create consumer directly from parsed data
+            try {
+                consumer = new SourceMapConsumer(sourceMap.data);
+            }
+            catch {
+                consumer = null;
+            }
+        }
+        else {
+            // External .map file — use cache
+            mapDir = dirname(sourceMap.path);
+            consumer = consumerCache.get(sourceMap.path);
+            if (consumer === undefined) {
+                try {
+                    const raw = readFileSync(sourceMap.path, 'utf8');
+                    consumer = new SourceMapConsumer(JSON.parse(raw));
+                    consumerCache.set(sourceMap.path, consumer);
+                }
+                catch {
+                    consumerCache.set(sourceMap.path, null);
+                    return null;
+                }
+            }
+        }
+    }
+    else {
+        // Fallback: try <file>.map
+        const fallback = frame.file + '.map';
+        if (existsSync(fallback)) {
+            mapDir = dirname(fallback);
+            consumer = consumerCache.get(fallback);
+            if (consumer === undefined) {
+                try {
+                    const raw = readFileSync(fallback, 'utf8');
+                    consumer = new SourceMapConsumer(JSON.parse(raw));
+                    consumerCache.set(fallback, consumer);
+                }
+                catch {
+                    consumerCache.set(fallback, null);
+                    return null;
+                }
+            }
+        }
+        else {
+            return null;
+        }
+    }
+    if (!consumer)
+        return null;
+    // Resolve the original position
+    const pos = consumer.originalPositionFor({
+        line: frame.line,
+        column: Math.max(0, (frame.column || 1) - 1),
+    });
+    if (!pos.source || !pos.line)
+        return null;
+    // Strip bundler protocol prefixes (webpack:///, vite-node://, etc.)
+    const cleanSource = stripSourceProtocol(pos.source);
+    // Get source content — prefer sourcesContent from the map, fall back to disk
+    let sourceContent = null;
+    try {
+        sourceContent = consumer.sourceContentFor(pos.source);
+    }
+    catch {
+        // Not available in sourcesContent
+    }
+    if (!sourceContent) {
+        // Try reading from disk using the cleaned source path
+        const displayPath = resolveDisplayPath(cleanSource, mapDir);
+        try {
+            sourceContent = readFileSync(displayPath, 'utf8');
+        }
+        catch {
+            return null;
+        }
+    }
+    const context = extractContext(sourceContent, pos.line);
+    if (!context)
+        return null;
+    // Resolve the display file path from the cleaned source
+    const file = resolveDisplayPath(cleanSource, mapDir);
+    return {
+        frame: {
+            file,
+            line: pos.line,
+            column: (pos.column ?? 0) + 1,
+            pre: context.pre,
+            target: context.target,
+            post: context.post,
+        },
+        functionName: pos.name || null,
+    };
+}
+/**
+ * Resolve source maps for all frames in an error's source context.
+ *
+ * For each frame, attempts to find and parse the corresponding .map file,
+ * then replaces the minified location with the original source location.
+ * Frames that can't be resolved are kept as-is.
+ *
+ * Returns the resolved function name from the source map (if available)
+ * so the caller can use it for fingerprinting.
+ */
+export function resolveSourceMaps(sourceContext, topFrame) {
+    if (!sourceContext || sourceContext.length === 0) {
+        return { sourceContext, topFrame, resolvedFunctionName: null, resolved: false };
+    }
+    try {
+        const consumerCache = new Map();
+        const resolvedFrames = [];
+        let anyResolved = false;
+        let resolvedTopFrame = null;
+        let resolvedFunctionName = null;
+        for (const frame of sourceContext) {
+            try {
+                const result = resolveFrame(frame, consumerCache);
+                if (result) {
+                    resolvedFrames.push(result.frame);
+                    anyResolved = true;
+                    if (!resolvedTopFrame) {
+                        resolvedTopFrame = {
+                            file: result.frame.file,
+                            line: result.frame.line,
+                            column: result.frame.column,
+                        };
+                        resolvedFunctionName = result.functionName;
+                    }
+                }
+                else {
+                    resolvedFrames.push(frame);
+                }
+            }
+            catch {
+                // Per-frame try/catch: one bad frame doesn't block others
+                resolvedFrames.push(frame);
+            }
+        }
+        if (!anyResolved) {
+            return { sourceContext, topFrame, resolvedFunctionName: null, resolved: false };
+        }
+        return {
+            sourceContext: resolvedFrames,
+            topFrame: resolvedTopFrame ?? topFrame,
+            resolvedFunctionName,
+            resolved: true,
+        };
+    }
+    catch {
+        // Never crash the daemon — return original data
+        return { sourceContext, topFrame, resolvedFunctionName: null, resolved: false };
+    }
+}
+//# sourceMappingURL=resolve-sourcemaps.js.map

package/dist/state/StateStore.d.ts

@@ -0,0 +1,11 @@
+import type { McpStartPayload, ProcessConfig, SavedState } from '../types/index.js';
+export declare class StateStore {
+    private filePath;
+    constructor(filePath?: string);
+    save(processes: ProcessConfig[], mcp?: McpStartPayload): Promise<void>;
+    load(): Promise<ProcessConfig[]>;
+    loadFull(): Promise<SavedState>;
+    clear(): Promise<void>;
+    exists(): Promise<boolean>;
+}
+//# sourceMappingURL=StateStore.d.ts.map

package/dist/state/StateStore.js

@@ -0,0 +1,78 @@
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { parse, stringify } from 'yaml';
+import { validateMcpState } from '../config/schema.js';
+import { SNAPSHOT_FILE } from '../constants.js';
+const STATE_VERSION = 1;
+export class StateStore {
+    filePath;
+    constructor(filePath = SNAPSHOT_FILE) {
+        this.filePath = filePath;
+    }
+    async save(processes, mcp) {
+        const state = {
+            version: STATE_VERSION,
+            processes,
+            ...(mcp ? { mcp } : {}),
+        };
+        // Ensure directory exists
+        const dir = dirname(this.filePath);
+        if (!existsSync(dir)) {
+            await mkdir(dir, { recursive: true });
+        }
+        // Atomic write: write to temp file then rename to prevent corruption
+        // if the process crashes mid-write
+        const tmpPath = this.filePath + '.tmp';
+        await writeFile(tmpPath, stringify(state, { defaultStringType: 'QUOTE_DOUBLE' }), 'utf-8');
+        await rename(tmpPath, this.filePath);
+    }
+    async load() {
+        const state = await this.loadFull();
+        return state.processes;
+    }
+    async loadFull() {
+        if (!existsSync(this.filePath)) {
+            return { processes: [] };
+        }
+        try {
+            const content = await readFile(this.filePath, 'utf-8');
+            const state = parse(content);
+            const version = state?.version ?? 1;
+            if (version !== STATE_VERSION) {
+                console.warn(`Snapshot file version mismatch: expected ${STATE_VERSION}, got ${version}`);
+            }
+            const processes = state?.processes || [];
+            // Coerce env values to strings — YAML parses unquoted values like
+            // `PORT: 3000` as numbers and `VERBOSE: yes` as booleans.  Environment
+            // variables must always be strings.
+            for (const proc of processes) {
+                if (proc.env && typeof proc.env === 'object') {
+                    for (const [key, value] of Object.entries(proc.env)) {
+                        if (typeof value !== 'string') {
+                            proc.env[key] = value === null || value === undefined ? '' : String(value);
+                        }
+                    }
+                }
+            }
+            const mcp = validateMcpState(state?.mcp) ? state.mcp : undefined;
+            if (state?.mcp && !mcp) {
+                console.warn('Snapshot contains invalid mcp section — ignoring');
+            }
+            return { ...state, processes, mcp };
+        }
+        catch (err) {
+            console.error('Failed to load snapshot:', err);
+            return { processes: [] };
+        }
+    }
+    async clear() {
+        if (existsSync(this.filePath)) {
+            await writeFile(this.filePath, stringify({ version: STATE_VERSION, processes: [] }, { defaultStringType: 'QUOTE_DOUBLE' }), 'utf-8');
+        }
+    }
+    async exists() {
+        return existsSync(this.filePath);
+    }
+}
+//# sourceMappingURL=StateStore.js.map

package/dist/telemetry/TelemetryReporter.d.ts

@@ -0,0 +1,49 @@
+import { EventEmitter } from 'node:events';
+import type { AlertEvaluator } from '../alerts/AlertEvaluator.js';
+import type { ConfigStore } from '../config/ConfigStore.js';
+import type { Orchestrator } from '../daemon/Orchestrator.js';
+import type { DeployStatus, TelemetryConfig, TelemetryEventType } from '../types/index.js';
+export declare class TelemetryReporter extends EventEmitter {
+    private config;
+    private orchestrator;
+    private events;
+    private metrics;
+    private errors;
+    private logRings;
+    private logFlushBuffer;
+    private logFlushDropped;
+    private timer;
+    private hostName;
+    private agentName;
+    private machineId;
+    private hostInfo;
+    private _deployStatus;
+    private configStore;
+    private alertEvaluator;
+    private mcpCapable;
+    /** Previous cumulative cache counters per worker — keyed by "processName:workerId" */
+    private prevCacheCounters;
+    constructor(config: TelemetryConfig, orchestrator: Orchestrator, configStore?: ConfigStore | null, alertEvaluator?: AlertEvaluator | null);
+    start(): void;
+    shutdown(): Promise<void>;
+    private bindEvents;
+    /**
+     * Get logs for a specific worker. In cluster mode, worker stdout/stderr flows
+     * through the primary process (workerId -1), so if the worker-specific ring
+     * is empty we fall back to the primary's ring.
+     */
+    private getWorkerLogs;
+    private clearWorkerLogs;
+    private pushEvent;
+    emitEvent(type: TelemetryEventType, processName: string, fields?: Record<string, unknown>): void;
+    setDeployStatus(status: DeployStatus | null): void;
+    setMcpCapable(v: boolean): void;
+    private collectAndFlush;
+    /**
+     * Drain the log flush buffer, capping at TELEMETRY_LOG_FLUSH_MAX_LINES per
+     * worker. When lines are dropped, prepend a truncation marker.
+     */
+    private drainLogFlushBuffer;
+    private restoreBuffers;
+}
+//# sourceMappingURL=TelemetryReporter.d.ts.map