@orkify/cli 1.0.0-beta.5

package/dist/config/schema.d.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+export declare const startOptionsSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    workers: z.ZodDefault<z.ZodNumber>;
+    watch: z.ZodDefault<z.ZodBoolean>;
+    watchPaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    cwd: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    nodeArgs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    args: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    killTimeout: z.ZodDefault<z.ZodNumber>;
+    maxRestarts: z.ZodDefault<z.ZodNumber>;
+    minUptime: z.ZodDefault<z.ZodNumber>;
+    restartDelay: z.ZodDefault<z.ZodNumber>;
+    sticky: z.ZodDefault<z.ZodBoolean>;
+    port: z.ZodOptional<z.ZodNumber>;
+    reloadRetries: z.ZodDefault<z.ZodNumber>;
+    healthCheck: z.ZodOptional<z.ZodString>;
+    logMaxSize: z.ZodDefault<z.ZodNumber>;
+    logMaxFiles: z.ZodDefault<z.ZodNumber>;
+    logMaxAge: z.ZodDefault<z.ZodNumber>;
+    restartOnMemory: z.ZodOptional<z.ZodNumber>;
+    framework: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    workers: number;
+    watch: boolean;
+    nodeArgs: string[];
+    args: string[];
+    killTimeout: number;
+    maxRestarts: number;
+    minUptime: number;
+    restartDelay: number;
+    sticky: boolean;
+    reloadRetries: number;
+    logMaxSize: number;
+    logMaxFiles: number;
+    logMaxAge: number;
+    env?: Record<string, string> | undefined;
+    name?: string | undefined;
+    watchPaths?: string[] | undefined;
+    cwd?: string | undefined;
+    port?: number | undefined;
+    healthCheck?: string | undefined;
+    restartOnMemory?: number | undefined;
+    framework?: string | undefined;
+}, {
+    env?: Record<string, string> | undefined;
+    name?: string | undefined;
+    workers?: number | undefined;
+    watch?: boolean | undefined;
+    watchPaths?: string[] | undefined;
+    cwd?: string | undefined;
+    nodeArgs?: string[] | undefined;
+    args?: string[] | undefined;
+    killTimeout?: number | undefined;
+    maxRestarts?: number | undefined;
+    minUptime?: number | undefined;
+    restartDelay?: number | undefined;
+    sticky?: boolean | undefined;
+    port?: number | undefined;
+    reloadRetries?: number | undefined;
+    healthCheck?: string | undefined;
+    logMaxSize?: number | undefined;
+    logMaxFiles?: number | undefined;
+    logMaxAge?: number | undefined;
+    restartOnMemory?: number | undefined;
+    framework?: string | undefined;
+}>;
+export type StartOptions = z.infer<typeof startOptionsSchema>;
+export declare const targetSchema: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodLiteral<"all">]>;
+export type Target = z.infer<typeof targetSchema>;
+export declare const logsOptionsSchema: z.ZodObject<{
+    lines: z.ZodDefault<z.ZodNumber>;
+    follow: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    follow: boolean;
+    lines: number;
+}, {
+    follow?: boolean | undefined;
+    lines?: number | undefined;
+}>;
+export type LogsOptions = z.infer<typeof logsOptionsSchema>;
+export declare function validateStartOptions(options: unknown): StartOptions;
+export declare function validateTarget(target: unknown): Target;
+export declare function validateLogsOptions(options: unknown): LogsOptions;
+export declare const mcpStateSchema: z.ZodObject<{
+    transport: z.ZodLiteral<"simple-http">;
+    port: z.ZodNumber;
+    bind: z.ZodString;
+    cors: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    port: number;
+    transport: "simple-http";
+    bind: string;
+    cors?: string | undefined;
+}, {
+    port: number;
+    transport: "simple-http";
+    bind: string;
+    cors?: string | undefined;
+}>;
+export declare function validateMcpState(value: unknown): value is z.infer<typeof mcpStateSchema>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/config/schema.js

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { DEFAULT_LOG_MAX_AGE, DEFAULT_LOG_MAX_FILES, DEFAULT_LOG_MAX_SIZE, DEFAULT_MAX_RESTARTS, DEFAULT_MIN_UPTIME, DEFAULT_RELOAD_RETRIES, DEFAULT_RESTART_DELAY, DEFAULT_WORKERS, KILL_TIMEOUT, MIN_LOG_MAX_SIZE, } from '../constants.js';
+export const startOptionsSchema = z.object({
+    name: z.string().optional(),
+    workers: z.number().int().positive().default(DEFAULT_WORKERS),
+    watch: z.boolean().default(false),
+    watchPaths: z.array(z.string()).optional(),
+    cwd: z.string().optional(),
+    env: z.record(z.string()).optional(),
+    nodeArgs: z.array(z.string()).default([]),
+    args: z.array(z.string()).default([]),
+    killTimeout: z.number().int().positive().default(KILL_TIMEOUT),
+    maxRestarts: z.number().int().nonnegative().default(DEFAULT_MAX_RESTARTS),
+    minUptime: z.number().int().nonnegative().default(DEFAULT_MIN_UPTIME),
+    restartDelay: z.number().int().nonnegative().default(DEFAULT_RESTART_DELAY),
+    sticky: z.boolean().default(false),
+    port: z.number().int().positive().optional(),
+    reloadRetries: z.number().int().min(0).max(3).default(DEFAULT_RELOAD_RETRIES),
+    healthCheck: z.string().startsWith('/').optional(),
+    logMaxSize: z.number().int().min(MIN_LOG_MAX_SIZE).default(DEFAULT_LOG_MAX_SIZE),
+    logMaxFiles: z.number().int().min(0).max(10000).default(DEFAULT_LOG_MAX_FILES),
+    logMaxAge: z.number().int().nonnegative().default(DEFAULT_LOG_MAX_AGE),
+    restartOnMemory: z.number().int().nonnegative().optional(),
+    framework: z.string().optional(),
+});
+export const targetSchema = z.union([z.string(), z.number().int().nonnegative(), z.literal('all')]);
+export const logsOptionsSchema = z.object({
+    lines: z.number().int().positive().default(100),
+    follow: z.boolean().default(false),
+});
+export function validateStartOptions(options) {
+    return startOptionsSchema.parse(options);
+}
+export function validateTarget(target) {
+    return targetSchema.parse(target);
+}
+export function validateLogsOptions(options) {
+    return logsOptionsSchema.parse(options);
+}
+export const mcpStateSchema = z.object({
+    transport: z.literal('simple-http'),
+    port: z.number().int().positive(),
+    bind: z.string().min(1),
+    cors: z.string().optional(),
+});
+export function validateMcpState(value) {
+    return mcpStateSchema.safeParse(value).success;
+}
+//# sourceMappingURL=schema.js.map

package/dist/constants.d.ts

@@ -0,0 +1,83 @@
+export declare const ORKIFY_HOME: string;
+export declare const SNAPSHOT_FILE: string;
+export declare const DAEMON_PID_FILE: string;
+export declare const DAEMON_LOCK_FILE: string;
+export declare const DAEMON_LOG_FILE: string;
+export declare const LOGS_DIR: string;
+export declare const AGENT_NAME_FILE: string;
+export declare const SOCKET_PATH: string;
+export declare const DAEMON_STARTUP_TIMEOUT = 5000;
+export declare const KILL_TIMEOUT = 5000;
+export declare const LAUNCH_TIMEOUT = 30000;
+export declare const IPC_CONNECT_TIMEOUT = 3000;
+export declare const IPC_RESPONSE_TIMEOUT = 120000;
+export declare const IPC_DEPLOY_TIMEOUT = 600000;
+export declare const DEFAULT_WORKERS = 1;
+export declare const DEFAULT_MAX_RESTARTS = 10;
+export declare const DEFAULT_MIN_UPTIME = 1000;
+export declare const DEFAULT_RESTART_DELAY = 100;
+export declare const DEFAULT_RELOAD_RETRIES = 3;
+export declare const MIN_LOG_MAX_SIZE = 1024;
+export declare const DEFAULT_LOG_MAX_SIZE: number;
+export declare const DEFAULT_LOG_MAX_FILES = 90;
+export declare const DEFAULT_LOG_MAX_AGE: number;
+export declare const MEMORY_RESTART_COOLDOWN = 30000;
+export declare const ProcessStatus: {
+    readonly ONLINE: "online";
+    readonly STOPPING: "stopping";
+    readonly STOPPED: "stopped";
+    readonly ERRORED: "errored";
+    readonly LAUNCHING: "launching";
+};
+export type ProcessStatusType = (typeof ProcessStatus)[keyof typeof ProcessStatus];
+export declare const ExecMode: {
+    readonly FORK: "fork";
+    readonly CLUSTER: "cluster";
+};
+export type ExecModeType = (typeof ExecMode)[keyof typeof ExecMode];
+export declare const IPCMessageType: {
+    readonly UP: "up";
+    readonly DOWN: "down";
+    readonly RESTART: "restart";
+    readonly RELOAD: "reload";
+    readonly DELETE: "delete";
+    readonly LIST: "list";
+    readonly LOGS: "logs";
+    readonly SNAP: "snap";
+    readonly RESTORE: "restore";
+    readonly RESTORE_CONFIGS: "restore_configs";
+    readonly DEPLOY_LOCAL: "deploy_local";
+    readonly DEPLOY_RESTORE: "deploy_restore";
+    readonly KILL_DAEMON: "kill_daemon";
+    readonly CONFIGURE_TELEMETRY: "configure_telemetry";
+    readonly PING: "ping";
+    readonly CRASH_TEST: "crash_test";
+    readonly FLUSH: "flush";
+    readonly MCP_START: "mcp_start";
+    readonly MCP_STOP: "mcp_stop";
+    readonly MCP_STATUS: "mcp_status";
+    readonly SUCCESS: "success";
+    readonly ERROR: "error";
+    readonly PROCESS_LIST: "process_list";
+    readonly LOG_DATA: "log_data";
+    readonly DEPLOY_PROGRESS: "deploy_progress";
+    readonly PONG: "pong";
+};
+export type IPCMessageTypeType = (typeof IPCMessageType)[keyof typeof IPCMessageType];
+export declare const METRICS_PROBE_IMPORT: string;
+export declare const MCP_CONFIG_FILE: string;
+export declare const MCP_DEFAULT_PORT = 8787;
+export declare const MCP_TOKEN_PREFIX = "orkify_mcp_";
+export declare const ORKIFY_DEPLOYS_DIR: string;
+export declare const DEPLOY_META_FILE = "orkify-deploy-meta.json";
+export declare const DEPLOY_CRASH_WINDOW_DEFAULT = 30;
+export declare const ORKIFY_CONFIG_FILE = "orkify.yml";
+export declare const TELEMETRY_DEFAULT_API_HOST = "https://api.orkify.com";
+export declare const TELEMETRY_METRICS_INTERVAL = 10000;
+export declare const TELEMETRY_FLUSH_TIMEOUT = 5000;
+export declare const TELEMETRY_MAX_BATCH_SIZE = 100;
+export declare const TELEMETRY_REQUEST_TIMEOUT = 10000;
+export declare const TELEMETRY_LOG_RING_SIZE = 50;
+export declare const TELEMETRY_LOG_FLUSH_MAX_LINES = 20;
+export declare const TELEMETRY_LOG_MAX_LINE_LENGTH = 4000;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -0,0 +1,289 @@
+import { homedir, userInfo } from 'node:os';
+import { join } from 'node:path';
+// Base paths
+export const ORKIFY_HOME = join(homedir(), '.orkify');
+export const SNAPSHOT_FILE = join(ORKIFY_HOME, 'snapshot.yml');
+export const DAEMON_PID_FILE = join(ORKIFY_HOME, 'daemon.pid');
+export const DAEMON_LOCK_FILE = join(ORKIFY_HOME, 'daemon.lock');
+export const DAEMON_LOG_FILE = join(ORKIFY_HOME, 'daemon.log');
+export const LOGS_DIR = join(ORKIFY_HOME, 'logs');
+export const AGENT_NAME_FILE = join(ORKIFY_HOME, 'agent-name');
+// IPC socket path - cross-platform (Unix sockets on Linux/macOS, Named Pipes on Windows)
+// Include username to support multi-user setups
+function getSocketPath() {
+    const username = userInfo().username;
+    if (process.platform === 'win32') {
+        // Windows Named Pipe - namespaced per user
+        return `\\\\.\\pipe\\orkify-${username}`;
+    }
+    // Unix socket in user's home directory
+    return join(ORKIFY_HOME, 'orkify.sock');
+}
+export const SOCKET_PATH = getSocketPath();
+// Timeouts (in milliseconds)
+export const DAEMON_STARTUP_TIMEOUT = 5000;
+export const KILL_TIMEOUT = 5000;
+export const LAUNCH_TIMEOUT = 30_000;
+export const IPC_CONNECT_TIMEOUT = 3000;
+export const IPC_RESPONSE_TIMEOUT = 120000; // 2 minutes for long operations like reload
+export const IPC_DEPLOY_TIMEOUT = 600000; // 10 minutes for deploy (install + build)
+// Defaults
+export const DEFAULT_WORKERS = 1;
+export const DEFAULT_MAX_RESTARTS = 10;
+export const DEFAULT_MIN_UPTIME = 1000;
+export const DEFAULT_RESTART_DELAY = 100;
+export const DEFAULT_RELOAD_RETRIES = 3;
+export const MIN_LOG_MAX_SIZE = 1024; // 1 KB floor
+export const DEFAULT_LOG_MAX_SIZE = 100 * 1024 * 1024; // 100 MB
+export const DEFAULT_LOG_MAX_FILES = 90;
+export const DEFAULT_LOG_MAX_AGE = 90 * 24 * 60 * 60 * 1000; // 90 days in ms
+export const MEMORY_RESTART_COOLDOWN = 30_000; // 30s cooldown after memory-triggered restart
+// Process status
+export const ProcessStatus = {
+    ONLINE: 'online',
+    STOPPING: 'stopping',
+    STOPPED: 'stopped',
+    ERRORED: 'errored',
+    LAUNCHING: 'launching',
+};
+// Execution modes
+export const ExecMode = {
+    FORK: 'fork',
+    CLUSTER: 'cluster',
+};
+// IPC message types
+export const IPCMessageType = {
+    // Commands
+    UP: 'up',
+    DOWN: 'down',
+    RESTART: 'restart',
+    RELOAD: 'reload',
+    DELETE: 'delete',
+    LIST: 'list',
+    LOGS: 'logs',
+    SNAP: 'snap',
+    RESTORE: 'restore',
+    RESTORE_CONFIGS: 'restore_configs',
+    DEPLOY_LOCAL: 'deploy_local',
+    DEPLOY_RESTORE: 'deploy_restore',
+    KILL_DAEMON: 'kill_daemon',
+    CONFIGURE_TELEMETRY: 'configure_telemetry',
+    PING: 'ping',
+    CRASH_TEST: 'crash_test',
+    FLUSH: 'flush',
+    MCP_START: 'mcp_start',
+    MCP_STOP: 'mcp_stop',
+    MCP_STATUS: 'mcp_status',
+    // Responses
+    SUCCESS: 'success',
+    ERROR: 'error',
+    PROCESS_LIST: 'process_list',
+    LOG_DATA: 'log_data',
+    DEPLOY_PROGRESS: 'deploy_progress',
+    PONG: 'pong',
+};
+// Metrics probe — injected into child processes via --import data URL.
+// Wrapped in try/catch so a probe failure never crashes the child process.
+const METRICS_PROBE_SRC = `
+try {
+  if (typeof process.send === "function") {
+    // Buffer IPC cache messages globally BEFORE any await so that snapshots
+    // sent on the 'online' event are captured even if cache/index.ts hasn't
+    // loaded yet. The CacheClient constructor drains this buffer on creation.
+    const _buf = globalThis.__orkifyCacheBuffer = [];
+    const _el = (msg) => {
+      if (msg?.__orkify && msg.type?.startsWith("cache:")) _buf.push(msg);
+    };
+    process.on("message", _el);
+    globalThis.__orkifyCacheBufferCleanup = () => process.removeListener("message", _el);
+
+    const { monitorEventLoopDelay } = await import("node:perf_hooks");
+    const { readFileSync } = await import("node:fs");
+    const { createHash } = await import("node:crypto");
+    const { fileURLToPath } = await import("node:url");
+    const { resolve: resolvePath } = await import("node:path");
+    const v8 = await import("node:v8");
+    const os = await import("node:os");
+    const h = monitorEventLoopDelay({ resolution: 100 });
+    h.enable();
+    const s = process.send.bind(process);
+    const t = setInterval(() => {
+      try {
+        const m = process.memoryUsage();
+        const data = {
+          heapUsed: m.heapUsed, heapTotal: m.heapTotal,
+          external: m.external, arrayBuffers: m.arrayBuffers,
+          eventLoopLag: h.mean / 1e6, eventLoopLagP95: h.percentile(95) / 1e6,
+          activeHandles: process._getActiveHandles().length
+        };
+        const _cacheStats = globalThis.__orkifyCacheStats;
+        if (typeof _cacheStats === "function") {
+          try {
+            const cs = _cacheStats();
+            data.cacheSize = cs.size;
+            data.cacheTotalBytes = cs.totalBytes;
+            data.cacheHits = cs.hits;
+            data.cacheMisses = cs.misses;
+            data.cacheHitRate = cs.hitRate;
+          } catch {}
+        }
+        s({ __orkify: true, type: "metrics", data });
+        h.reset();
+      } catch {}
+    }, 2000);
+    t.unref();
+
+    // Port auto-detection for fork mode: hook net.Server.listen to report
+    // the first port the child binds, mirroring cluster mode's worker:listening.
+    // Falls back to PORT env var if the monkey-patch fails.
+    try {
+      const net = await import("node:net");
+      const _origListen = net.Server.prototype.listen;
+      let _portReported = false;
+      net.Server.prototype.listen = function(...args) {
+        if (!_portReported) {
+          this.once("listening", () => {
+            if (!_portReported) {
+              const addr = this.address();
+              if (addr && typeof addr === "object" && addr.port) {
+                _portReported = true;
+                s({ __orkify: true, type: "listening", data: { port: addr.port } });
+              }
+            }
+          });
+        }
+        return _origListen.apply(this, args);
+      };
+    } catch {
+      const envPort = parseInt(process.env.PORT || "", 10);
+      if (envPort > 0) {
+        s({ __orkify: true, type: "listening", data: { port: envPort } });
+      }
+    }
+
+    // CVE-2025-29927 / CVE-2024-46982: strip dangerous headers from external requests
+    try {
+      const _stripHeaders = ["x-middleware-subrequest", "x-now-route-matches"];
+      const _isLoopback = (a) => a === "127.0.0.1" || a === "::1" || a === "::ffff:127.0.0.1";
+      function _wrapEmit(Server) {
+        const orig = Server.prototype.emit;
+        Server.prototype.emit = function(event, ...args) {
+          if (event === "request") {
+            const req = args[0];
+            if (!_isLoopback(req?.socket?.remoteAddress || "")) {
+              for (const h of _stripHeaders) delete req.headers[h];
+            }
+          }
+          return orig.apply(this, [event, ...args]);
+        };
+      }
+      const _http = await import("node:http");
+      _wrapEmit(_http.Server);
+      try { const _https = await import("node:https"); _wrapEmit(_https.Server); } catch {}
+    } catch {}
+
+    // Mirrors parseUserFrames() in src/probe/parse-frames.ts — keep in sync
+    function _orkifyParseUserFrames(stack) {
+      const frames = [];
+      if (!stack) return frames;
+      for (const l of stack.split("\\n")) {
+        const m = l.match(/at\\s+(?:.*?\\s+)?\\(?(.+?):(\\d+):(\\d+)\\)?$/);
+        if (m) {
+          let file = m[1];
+          if (file.startsWith("file://")) {
+            try { file = fileURLToPath(file); } catch {}
+          } else if (file.startsWith("webpack-internal://") || file.startsWith("webpack://")) {
+            const wp = file.replace(/^webpack(?:-internal)?:\\/\\/\\/(?:[^/]*\\/)?/, "");
+            file = resolvePath(process.cwd(), wp);
+          } else if (/^[a-z][a-z0-9+.-]+:/i.test(file)) {
+            continue;
+          }
+          if (!file.startsWith("node:") && !file.includes("node_modules")) {
+            frames.push({ file, line: parseInt(m[2],10), column: parseInt(m[3],10) });
+            if (frames.length >= 10) break;
+          }
+        }
+      }
+      return frames;
+    }
+
+    function _orkifyCaptureError(err, type) {
+      try {
+        const message = err?.message || String(err);
+        const stack = err?.stack || "";
+        const frames = _orkifyParseUserFrames(stack);
+        const topFrame = frames.length > 0 ? frames[0] : null;
+        const sourceContextArr = [];
+        for (const frame of frames) {
+          try {
+            const lines = readFileSync(frame.file, "utf8").split("\\n");
+            const start = Math.max(0, frame.line - 6);
+            const end = Math.min(lines.length, frame.line + 5);
+            sourceContextArr.push({ file: frame.file, line: frame.line, column: frame.column,
+              pre: lines.slice(start, frame.line - 1),
+              target: lines[frame.line - 1] || "",
+              post: lines.slice(frame.line, end) });
+          } catch {}
+        }
+        const sourceContext = sourceContextArr.length > 0 ? sourceContextArr : null;
+        let diagnostics = null;
+        try {
+          const mem = process.memoryUsage();
+          const heap = v8.getHeapStatistics();
+          diagnostics = {
+            memoryUsage: { rss: mem.rss, heapTotal: mem.heapTotal, heapUsed: mem.heapUsed,
+              external: mem.external, arrayBuffers: mem.arrayBuffers },
+            processUptime: process.uptime(),
+            heapStatistics: { totalHeapSize: heap.total_heap_size, usedHeapSize: heap.used_heap_size,
+              heapSizeLimit: heap.heap_size_limit, totalAvailableSize: heap.total_available_size,
+              totalPhysicalSize: heap.total_physical_size },
+            osFreeMemory: os.freemem(),
+            osLoadAvg: os.loadavg(),
+            activeResources: typeof process.getActiveResourcesInfo === "function"
+              ? process.getActiveResourcesInfo() : []
+          };
+        } catch {}
+        const raw = message + (topFrame ? topFrame.file + ":" + topFrame.line : "");
+        const fingerprint = createHash("sha256").update(raw).digest("hex").slice(0, 32);
+        s({ __orkify: true, type: "error", data: {
+          errorType: type, name: err?.name || "Error", message, stack, fingerprint,
+          sourceContext, topFrame, diagnostics, timestamp: Date.now(),
+          nodeVersion: process.version, pid: process.pid
+        }});
+      } catch {}
+    }
+
+    process.on("uncaughtException", (err) => {
+      _orkifyCaptureError(err, "uncaughtException");
+      if (process.listenerCount("uncaughtException") === 1) {
+        process.exit(1);
+      }
+    });
+
+    process.on("unhandledRejection", (reason) => {
+      _orkifyCaptureError(reason instanceof Error ? reason : new Error(String(reason)),
+        "unhandledRejection");
+    });
+  }
+} catch {}
+`.trim();
+export const METRICS_PROBE_IMPORT = `--import=data:text/javascript;base64,${Buffer.from(METRICS_PROBE_SRC).toString('base64')}`;
+// MCP HTTP
+export const MCP_CONFIG_FILE = join(ORKIFY_HOME, 'mcp.yml');
+export const MCP_DEFAULT_PORT = 8787;
+export const MCP_TOKEN_PREFIX = 'orkify_mcp_';
+// Deploy
+export const ORKIFY_DEPLOYS_DIR = join(ORKIFY_HOME, 'deploys');
+export const DEPLOY_META_FILE = 'orkify-deploy-meta.json';
+export const DEPLOY_CRASH_WINDOW_DEFAULT = 30; // seconds
+export const ORKIFY_CONFIG_FILE = 'orkify.yml';
+// Telemetry
+export const TELEMETRY_DEFAULT_API_HOST = 'https://api.orkify.com';
+export const TELEMETRY_METRICS_INTERVAL = 10_000;
+export const TELEMETRY_FLUSH_TIMEOUT = 5_000;
+export const TELEMETRY_MAX_BATCH_SIZE = 100;
+export const TELEMETRY_REQUEST_TIMEOUT = 10_000;
+export const TELEMETRY_LOG_RING_SIZE = 50;
+export const TELEMETRY_LOG_FLUSH_MAX_LINES = 20;
+export const TELEMETRY_LOG_MAX_LINE_LENGTH = 4000;
+//# sourceMappingURL=constants.js.map

package/dist/cron/CronScheduler.d.ts

@@ -0,0 +1,25 @@
+import type { Orchestrator } from '../daemon/Orchestrator.js';
+import type { CronJob } from '../types/index.js';
+/**
+ * Validate a cron schedule string. Returns null if valid,
+ * or an error message if invalid, sub-minute, or > 24h.
+ */
+export declare function validateCronSchedule(schedule: string): null | string;
+/**
+ * Validate a cron job path. Must be a clean local route path
+ * (e.g. "/api/cron/heartbeat-check") — no URLs, hosts, or query strings.
+ */
+export declare function validateCronPath(path: string): null | string;
+export declare class CronScheduler {
+    private orchestrator;
+    private jobs;
+    private timer;
+    constructor(orchestrator: Orchestrator);
+    register(processName: string, jobs: CronJob[]): void;
+    unregister(processName: string): void;
+    shutdown(): void;
+    private tick;
+    private dispatch;
+    private computeNextRun;
+}
+//# sourceMappingURL=CronScheduler.d.ts.map