@runium/core 0.0.1

package/index.d.ts

@@ -0,0 +1,387 @@
+import { EventEmitter } from 'node:events';
+
+export declare function applyMacros(text: string, macros: MacrosCollection): string;
+
+export declare class EventTrigger extends RuniumTrigger<EventTriggerOptions> {
+    constructor(options: EventTriggerOptions, project: RuniumTriggerProjectAccessible);
+    enable(): void;
+    disable(): void;
+}
+
+export declare interface EventTriggerOptions extends RuniumTriggerOptions {
+    event: string;
+}
+
+export declare function extendProjectSchema(schema: object, extensions: ProjectSchemaExtension): object;
+
+export declare enum FileErrorCode {
+    READ_JSON = "file-read-json",
+    WRITE_JSON = "file-write-json"
+}
+
+export declare function getProjectSchema(): object;
+
+export declare class IntervalTrigger extends RuniumTrigger<IntervalTriggerOptions> {
+    constructor(options: IntervalTriggerOptions, project: RuniumTriggerProjectAccessible);
+    enable(): void;
+    disable(): void;
+}
+
+export declare interface IntervalTriggerOptions extends RuniumTriggerOptions {
+    interval: number;
+}
+
+export declare function isCustomAction(action: ProjectAction): action is ProjectCustomAction;
+
+export declare function isCustomTrigger(trigger: ProjectTrigger): trigger is ProjectCustomTrigger;
+
+export declare function isProcessTaskAction(action: ProjectAction): action is ProjectActionProcessTask;
+
+export declare function isRuniumError(error: unknown): boolean;
+
+export declare function isToggleTriggerAction(action: ProjectAction): action is ProjectActionToggleTrigger;
+
+export declare interface JSONObject {
+    [x: string]: JSONValue;
+}
+
+export declare type JSONValue = string | number | boolean | JSONObject | JSONValue[];
+
+export declare type Macro = (...params: string[]) => string;
+
+export declare type MacrosCollection = Record<string, Macro>;
+
+export declare class Project extends EventEmitter {
+    constructor(config: ProjectConfig);
+    validate(): void;
+    getConfig(): ProjectConfig;
+    setConfig(config: ProjectConfig): void;
+    getState(): ProjectState;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    extendValidationSchema(extensions: ProjectSchemaExtension): void;
+    registerAction(type: string, processor: RuniumActionProcessor): void;
+    registerTask(type: string, processor: RuniumTaskConstructor<unknown, any>): void;
+    registerTrigger(type: string, processor: RuniumTriggerConstructor<any>): void;
+}
+
+export declare type ProjectAction = ProjectCustomAction | ProjectActionEmitEvent | ProjectActionProcessTask | ProjectActionStopProject | ProjectActionToggleTrigger;
+
+export declare interface ProjectActionEmitEvent {
+    type: ProjectActionType.EMIT_EVENT;
+    event: string;
+}
+
+export declare interface ProjectActionProcessTask {
+    type: ProjectActionType.START_TASK | ProjectActionType.RESTART_TASK | ProjectActionType.STOP_TASK;
+    taskId: string;
+}
+
+export declare interface ProjectActionStopProject {
+    type: ProjectActionType.STOP_PROJECT;
+}
+
+export declare interface ProjectActionToggleTrigger {
+    type: ProjectActionType.ENABLE_TRIGGER | ProjectActionType.DISABLE_TRIGGER;
+    triggerId: string;
+}
+
+export declare enum ProjectActionType {
+    EMIT_EVENT = "emit-event",
+    START_TASK = "start-task",
+    RESTART_TASK = "restart-task",
+    STOP_TASK = "stop-task",
+    STOP_PROJECT = "stop-project",
+    ENABLE_TRIGGER = "enable-trigger",
+    DISABLE_TRIGGER = "disable-trigger"
+}
+
+export declare interface ProjectConfig {
+    id: string;
+    name?: string;
+    tasks: ProjectTaskConfig[];
+    triggers?: ProjectTrigger[];
+}
+
+export declare enum ProjectConfigErrorCode {
+    INCORRECT_DATA = "project-config-incorrect-data",
+    TASKS_CIRCULAR_DEPENDENCY = "project-config-tasks-circular-dependency",
+    TASK_NOT_EXISTS = "project-config-task-not-exists",
+    TRIGGER_NOT_EXISTS = "project-config-trigger-not-exists"
+}
+
+export declare interface ProjectCustomAction {
+    type: string;
+    payload?: unknown;
+}
+
+export declare interface ProjectCustomTrigger extends ProjectTriggerBase {
+    type: string;
+    payload?: unknown;
+}
+
+export declare interface ProjectDefaultTaskConfig extends ProjectTaskConfig<TaskOptions> {
+    type?: ProjectTaskType.DEFAULT;
+}
+
+export declare enum ProjectErrorCode {
+    ACTION_PROCESSOR_ALREADY_REGISTERED = "project-action-processor-already-registered",
+    ACTION_PROCESSOR_INCORRECT = "project-action-processor-incorrect",
+    TASK_PROCESSOR_NOT_FOUND = "project-task-processor-not-found",
+    TASK_PROCESSOR_ALREADY_REGISTERED = "project-task-processor-already-registered",
+    TASK_PROCESSOR_INCORRECT = "project-task-processor-incorrect",
+    TRIGGER_PROCESSOR_ALREADY_REGISTERED = "project-trigger-processor-already-registered",
+    TRIGGER_PROCESSOR_INCORRECT = "project-trigger-processor-incorrect"
+}
+
+export declare enum ProjectEvent {
+    STATE_CHANGE = "state-change",
+    START_TASK = "start-task",
+    RESTART_TASK = "restart-task",
+    STOP_TASK = "stop-task",
+    PROCESS_ACTION = "process-action",
+    ENABLE_TRIGGER = "enable-trigger",
+    DISABLE_TRIGGER = "disable-trigger",
+    TASK_STATE_CHANGE = "task-state-change",
+    TASK_STDOUT = "task-stdout",
+    TASK_STDERR = "task-stderr"
+}
+
+export declare enum ProjectSchemaErrorCode {
+    ACTION_TYPE_ALREADY_USED = "project-schema-action-type-already-used",
+    TASK_TYPE_ALREADY_USED = "project-schema-task-type-already-used",
+    TRIGGER_TYPE_ALREADY_USED = "project-schema-trigger-type-already-used"
+}
+
+export declare interface ProjectSchemaExtension {
+    project?: {
+        properties: unknown;
+        required?: string[];
+    };
+    tasks?: Record<string, {
+        type: string;
+        options: unknown;
+    }>;
+    definitions?: Record<string, unknown>;
+    actions?: Record<string, {
+        type: string;
+        payload?: unknown;
+    }>;
+    triggers?: Record<string, {
+        type: string;
+        payload?: unknown;
+    }>;
+}
+
+export declare interface ProjectState {
+    status: ProjectStatus;
+    timestamp: number;
+}
+
+export declare enum ProjectStatus {
+    IDLE = "idle",
+    STARTING = "starting",
+    STARTED = "started",
+    STOPPING = "stopping",
+    STOPPED = "stopped"
+}
+
+export declare interface ProjectTaskConfig<Options = unknown> {
+    id: string;
+    options: Options;
+    type?: ProjectTaskType | string;
+    name?: string;
+    mode?: ProjectTaskStartMode;
+    dependencies?: ProjectTaskDependency[];
+    handlers?: ProjectTaskHandler[];
+    restart?: ProjectTaskRestartPolicy;
+}
+
+export declare interface ProjectTaskDependency {
+    taskId: string;
+    condition: ProjectTaskStateCondition;
+}
+
+export declare interface ProjectTaskHandler {
+    condition: ProjectTaskStateCondition;
+    action: ProjectAction;
+}
+
+export declare type ProjectTaskRestartPolicy = ProjectTaskRestartPolicyAlways | ProjectTaskRestartPolicyOnFailure;
+
+export declare interface ProjectTaskRestartPolicyAlways {
+    policy: ProjectTaskRestartPolicyType.ALWAYS;
+    delay?: number;
+}
+
+export declare interface ProjectTaskRestartPolicyOnFailure {
+    policy: ProjectTaskRestartPolicyType.ON_FAILURE;
+    delay?: number;
+    maxRetries?: number;
+}
+
+export declare enum ProjectTaskRestartPolicyType {
+    ALWAYS = "always",
+    ON_FAILURE = "on-failure"
+}
+
+export declare enum ProjectTaskStartMode {
+    IMMEDIATE = "immediate",
+    DEFERRED = "deferred"
+}
+
+export declare type ProjectTaskStateCondition = string | boolean | Partial<RuniumTaskState> | ((state: RuniumTaskState) => boolean);
+
+export declare enum ProjectTaskType {
+    DEFAULT = "default"
+}
+
+export declare type ProjectTrigger = ProjectTriggerEvent | ProjectTriggerInterval | ProjectTriggerTimeout | ProjectCustomTrigger;
+
+declare interface ProjectTriggerBase {
+    id: string;
+    type: ProjectTriggerType | string;
+    action: ProjectAction;
+    disabled?: boolean;
+}
+
+export declare interface ProjectTriggerEvent extends ProjectTriggerBase {
+    type: ProjectTriggerType.EVENT;
+    event: string;
+}
+
+export declare interface ProjectTriggerInterval extends ProjectTriggerBase {
+    type: ProjectTriggerType.INTERVAL;
+    interval: number;
+}
+
+export declare interface ProjectTriggerTimeout extends ProjectTriggerBase {
+    type: ProjectTriggerType.TIMEOUT;
+    timeout: number;
+}
+
+export declare enum ProjectTriggerType {
+    EVENT = "event",
+    TIMEOUT = "timeout",
+    INTERVAL = "interval"
+}
+
+export declare function readJsonFile<T = JSONValue>(path: string): Promise<T>;
+
+declare type RuniumActionProcessor = (payload: unknown) => void;
+
+export declare class RuniumError extends Error {
+    code: string;
+    payload: unknown;
+    constructor(message: string, code: string, payload?: unknown);
+}
+
+export declare abstract class RuniumTask<Options = unknown, State = RuniumTaskState> extends EventEmitter {
+    protected options: Options;
+    protected constructor(options: Options);
+    abstract getOptions(): Options;
+    abstract getState(): State;
+    abstract start(): Promise<void>;
+    abstract stop(): Promise<void>;
+    abstract restart(): Promise<void>;
+}
+
+export declare type RuniumTaskConstructor<Options = unknown, State extends RuniumTaskState = RuniumTaskState> = new (options: any) => RuniumTask<Options, State>;
+
+export declare interface RuniumTaskState {
+    status: TaskStatus;
+    timestamp: number;
+    iteration: number;
+    exitCode?: number;
+    error?: Error;
+}
+
+export declare abstract class RuniumTrigger<Options extends RuniumTriggerOptions> {
+    protected project: RuniumTriggerProjectAccessible;
+    protected id: string;
+    protected action: ProjectAction;
+    protected disabled: boolean;
+    constructor(options: Options, project: RuniumTriggerProjectAccessible);
+    abstract enable(): void;
+    abstract disable(): void;
+    getId(): string;
+    isDisabled(): boolean;
+}
+
+export declare type RuniumTriggerConstructor<Options extends RuniumTriggerOptions> = new (options: Options, project: RuniumTriggerProjectAccessible) => RuniumTrigger<Options>;
+
+export declare interface RuniumTriggerOptions {
+    id: string;
+    action: ProjectAction;
+    disabled?: boolean;
+}
+
+export declare interface RuniumTriggerProjectAccessible {
+    processAction(action: ProjectAction): void;
+    on: NodeJS.EventEmitter['on'];
+    off: NodeJS.EventEmitter['off'];
+}
+
+export declare const SILENT_EXIT_CODE = -1;
+
+export declare class Task extends RuniumTask<TaskOptions, TaskState> {
+    protected readonly options: TaskOptions;
+    constructor(options: TaskOptions);
+    getState(): TaskState;
+    getOptions(): TaskOptions;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    restart(): Promise<void>;
+}
+
+export declare enum TaskEvent {
+    STATE_CHANGE = "state-change",
+    STDOUT = "stdout",
+    STDERR = "stderr"
+}
+
+export declare interface TaskOptions {
+    command: string;
+    arguments?: string[];
+    shell?: boolean;
+    stopSignal?: string;
+    cwd?: string;
+    env?: {
+        [key: string]: string | number | boolean;
+    };
+    ttl?: number;
+    log?: {
+        stdout?: string | null;
+        stderr?: string | null;
+    };
+}
+
+export declare interface TaskState extends RuniumTaskState {
+    pid: number;
+}
+
+export declare enum TaskStatus {
+    IDLE = "idle",
+    STARTING = "starting",
+    STARTED = "started",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    STOPPING = "stopping",
+    STOPPED = "stopped"
+}
+
+export declare class TimeoutTrigger extends RuniumTrigger<TimeoutTriggerOptions> {
+    constructor(options: TimeoutTriggerOptions, project: RuniumTriggerProjectAccessible);
+    enable(): void;
+    disable(): void;
+}
+
+export declare interface TimeoutTriggerOptions extends RuniumTriggerOptions {
+    timeout: number;
+}
+
+export declare function validateProject(project: ProjectConfig, schema: object): void;
+
+export declare function writeJsonFile<T = JSONValue>(path: string, data: T): Promise<void>;
+
+export { }

package/index.js

@@ -0,0 +1,571 @@
+import { readFile as G, writeFile as x, mkdir as I } from "node:fs/promises";
+import { EventEmitter as b } from "node:events";
+import M from "bcx-expression-evaluator";
+import q from "ajv/dist/2020.js";
+import K from "ajv-keywords";
+import { spawn as U } from "node:child_process";
+import { createWriteStream as $ } from "node:fs";
+import { resolve as _, dirname as j } from "node:path";
+class d extends Error {
+  code;
+  payload;
+  constructor(t, s, r = null) {
+    super(t), this.code = s, this.payload = r;
+  }
+}
+function Et(e) {
+  return !!e && e instanceof d;
+}
+var F = ((e) => (e.READ_JSON = "file-read-json", e.WRITE_JSON = "file-write-json", e))(F || {});
+async function Rt(e) {
+  try {
+    const t = await G(e, { encoding: "utf-8" });
+    return JSON.parse(t);
+  } catch (t) {
+    throw new d(`Can not read JSON file ${e}`, "file-read-json", { path: e, original: t });
+  }
+}
+async function At(e, t) {
+  try {
+    await x(e, JSON.stringify(t, null, 2), { encoding: "utf-8" });
+  } catch (s) {
+    throw new d(`Can not write JSON file ${e}`, "file-write-json", { path: e, data: t, original: s });
+  }
+}
+const Y = String.raw`"\$unwrap\((.*)\)"`;
+function _t(e, t) {
+  const s = Object.keys(t), r = String.raw`\$(${s.join("|")})\(([^()]*(?:\([^()]*\)[^()]*)*)\)`, i = (o) => {
+    const a = new RegExp(r, "g");
+    let c = o, n = !0;
+    for (; n; ) n = !1, c = c.replace(a, (u, D, L) => {
+      n = !0;
+      const R = [];
+      let A = 0, m = "";
+      for (const l of L) l === "," && A === 0 ? (R.push(m.trim()), m = "") : (l === "(" && A++, l === ")" && A--, m += l);
+      R.push(m.trim());
+      const N = R.map((l) => l ? i(l) : "");
+      return t[D](...N);
+    });
+    return c;
+  };
+  return (function(o) {
+    const a = new RegExp(Y, "g");
+    return o.replace(a, (c, n) => n.trim());
+  })(s.length ? i(e) : e);
+}
+var k = ((e) => (e.IMMEDIATE = "immediate", e.DEFERRED = "deferred", e))(k || {}), p = ((e) => (e.EMIT_EVENT = "emit-event", e.START_TASK = "start-task", e.RESTART_TASK = "restart-task", e.STOP_TASK = "stop-task", e.STOP_PROJECT = "stop-project", e.ENABLE_TRIGGER = "enable-trigger", e.DISABLE_TRIGGER = "disable-trigger", e))(p || {}), f = ((e) => (e.DEFAULT = "default", e))(f || {}), h = ((e) => (e.EVENT = "event", e.TIMEOUT = "timeout", e.INTERVAL = "interval", e))(h || {}), T = ((e) => (e.ALWAYS = "always", e.ON_FAILURE = "on-failure", e))(T || {}), V = ((e) => (e.INCORRECT_DATA = "project-config-incorrect-data", e.TASKS_CIRCULAR_DEPENDENCY = "project-config-tasks-circular-dependency", e.TASK_NOT_EXISTS = "project-config-task-not-exists", e.TRIGGER_NOT_EXISTS = "project-config-trigger-not-exists", e))(V || {});
+const J = /* @__PURE__ */ new Set(["start-task", "restart-task", "stop-task"]), B = /* @__PURE__ */ new Set(["enable-trigger", "disable-trigger"]), H = new Set(Object.values(p)), W = new Set(Object.values(h));
+function w(e) {
+  return J.has(e.type);
+}
+function P(e) {
+  return B.has(e.type);
+}
+function X(e) {
+  return !H.has(e.type);
+}
+function z(e) {
+  return !W.has(e.type);
+}
+const O = new q({ allowUnionTypes: !0 });
+function Q(e) {
+  const t = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Set();
+  for (const i of e.tasks) s.add(i.id), t.set(i.id, []);
+  const r = new Set(e.triggers?.map((i) => i.id) || []);
+  for (const i of e.tasks) {
+    for (const o of i.dependencies || []) {
+      if (!s.has(o.taskId)) throw new d(`Task "${i.id}" depends on not existing task "${o.taskId}"`, "project-config-task-not-exists", { taskId: i.id, dependency: { ...o }, scope: "dependencies" });
+      t.get(o.taskId).push(i.id);
+    }
+    for (const o of i.handlers || []) {
+      if (w(o.action) && !s.has(o.action.taskId)) throw new d(`Task "${i.id}" handler action uses not existing task "${o.action.taskId}"`, "project-config-task-not-exists", { taskId: i.id, handler: { ...o }, scope: "handlers" });
+      if (P(o.action) && !r.has(o.action.triggerId)) throw new d(`Task "${i.id}" handler action uses not existing trigger "${o.action.triggerId}"`, "project-config-trigger-not-exists", { taskId: i.id, handler: { ...o }, scope: "handlers" });
+    }
+  }
+  for (const i of e.triggers || []) {
+    if (w(i.action) && !s.has(i.action.taskId)) throw new d(`Trigger "${i.id}" action uses not existing task "${i.action.taskId}"`, "project-config-task-not-exists", { trigger: { ...i }, scope: "triggers" });
+    if (P(i.action) && !r.has(i.action.triggerId)) throw new d(`Trigger "${i.id}" action uses not existing trigger "${i.action.triggerId}"`, "project-config-trigger-not-exists", { trigger: { ...i }, scope: "triggers" });
+  }
+  (function(i) {
+    const o = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set(), c = (n) => {
+      if (a.has(n)) {
+        const u = [...a, n].join(" -> ");
+        throw new d(`Project config tasks circular dependency detected ${u}`, "project-config-tasks-circular-dependency", { task: n, dependencies: [...a] });
+      }
+      if (!o.has(n)) {
+        a.add(n);
+        for (const u of i.get(n) || []) c(u);
+        a.delete(n), o.add(n);
+      }
+    };
+    for (const n of i.keys()) o.has(n) || c(n);
+  })(t);
+}
+function Z(e, t) {
+  (function(s, r) {
+    const i = O.compile(r || {});
+    if (!i(s)) throw new d("Incorrect project config data", "project-config-incorrect-data", { errors: i.errors });
+  })(e, t), Q(e);
+}
+K(O, ["uniqueItemProperties"]);
+var g = ((e) => (e.IDLE = "idle", e.STARTING = "starting", e.STARTED = "started", e.COMPLETED = "completed", e.FAILED = "failed", e.STOPPING = "stopping", e.STOPPED = "stopped", e))(g || {}), y = ((e) => (e.STATE_CHANGE = "state-change", e.STDOUT = "stdout", e.STDERR = "stderr", e))(y || {});
+const It = -1;
+class v extends b {
+  constructor(t) {
+    super(), this.options = t;
+  }
+}
+class tt extends v {
+  constructor(t) {
+    super(t), this.options = t, this.setMaxListeners(50), this.options.env = { ...process.env, ...t.env || {} }, this.options.cwd = _(process.cwd(), t.cwd || "");
+  }
+  state = { status: "idle", pid: -1, timestamp: Date.now(), iteration: 0 };
+  process = null;
+  stdoutStream = null;
+  stderrStream = null;
+  ttlTimer = null;
+  getState() {
+    return { ...this.state };
+  }
+  getOptions() {
+    return { ...this.options };
+  }
+  async start() {
+    const { status: t } = this.state;
+    if (t !== "started" && t !== "starting" && t !== "stopping") {
+      this.updateState({ status: "starting", iteration: this.state.iteration + 1, pid: -1, exitCode: void 0, error: void 0 });
+      try {
+        await this.initLogStreams();
+        const { cwd: s, command: r, arguments: i = [], env: o, shell: a = !0 } = this.options;
+        this.process = U(r, i, { cwd: s, env: o, shell: a, stdio: ["ignore", "pipe", "pipe"] }), this.addProcessListeners(), this.setTTLTimer(), this.updateState({ status: "started", pid: this.process.pid });
+      } catch (s) {
+        this.onError(s);
+      }
+    }
+  }
+  async stop() {
+    if (this.process && this.state.status !== "stopping" && this.state.status === "started") return this.updateState({ status: "stopping" }), new Promise((t) => {
+      const s = this.options.stopSignal || "SIGTERM";
+      this.process.kill(s), this.process.on("exit", () => {
+        t();
+      });
+    });
+  }
+  async restart() {
+    await this.stop(), this.start();
+  }
+  updateState(t) {
+    const s = { ...this.state, ...t, timestamp: Date.now() };
+    this.state = Object.fromEntries(Object.entries(s).filter(([r, i]) => i !== void 0)), this.emit("state-change", this.getState()), this.emit(this.state.status, this.getState());
+  }
+  async initLogStreams() {
+    const { stdout: t = null, stderr: s = null } = this.options.log || {};
+    if (t) {
+      const r = _(t);
+      await I(j(r), { recursive: !0 }), this.stdoutStream = $(t, { flags: "w" });
+    }
+    if (s) {
+      const r = _(s);
+      await I(j(r), { recursive: !0 }), this.stderrStream = $(s, { flags: "w" });
+    }
+  }
+  setTTLTimer() {
+    const { ttl: t } = this.options;
+    t && this.process && (this.ttlTimer = setTimeout(() => {
+      this.stop();
+    }, t));
+  }
+  addProcessListeners() {
+    this.process && (this.process.stdout?.on("data", (t) => this.onStdOutData(t)), this.process.stderr?.on("data", (t) => this.onStdErrData(t)), this.process.on("exit", (t) => this.onExit(t)), this.process.on("error", (t) => this.onError(t)));
+  }
+  onStdOutData(t) {
+    const s = t.toString();
+    this.emit("stdout", s), this.stdoutStream && this.stdoutStream.write(s);
+  }
+  onStdErrData(t) {
+    const s = t.toString();
+    this.emit("stderr", s), this.stderrStream && this.stderrStream.write(s);
+  }
+  onExit(t) {
+    const s = t !== null ? t : -1;
+    this.updateState({ status: s === 0 ? "completed" : s === -1 ? "stopped" : "failed", exitCode: s }), this.cleanup();
+  }
+  onError(t) {
+    this.updateState({ status: "failed", error: t }), this.cleanup();
+  }
+  cleanup() {
+    this.ttlTimer && (clearTimeout(this.ttlTimer), this.ttlTimer = null), this.process && (this.process.removeAllListeners(), this.process.stdout?.removeAllListeners(), this.process.stderr?.removeAllListeners(), this.process = null), this.stdoutStream && (this.stdoutStream.end(), this.stdoutStream = null), this.stderrStream && (this.stderrStream.end(), this.stderrStream = null);
+  }
+}
+var et = ((e) => (e.ACTION_TYPE_ALREADY_USED = "project-schema-action-type-already-used", e.TASK_TYPE_ALREADY_USED = "project-schema-task-type-already-used", e.TRIGGER_TYPE_ALREADY_USED = "project-schema-trigger-type-already-used", e))(et || {});
+const st = { id: { type: "string" }, name: { type: "string" }, type: { type: "string" }, mode: { $ref: "#/$defs/Runium_TaskStartMode" }, dependencies: { type: "array", items: { $ref: "#/$defs/Runium_TaskDependency" } }, handlers: { type: "array", items: { $ref: "#/$defs/Runium_TaskHandler" } }, restart: { $ref: "#/$defs/Runium_TaskRestartPolicy" } }, S = { id: { type: "string" }, action: { $ref: "#/$defs/Runium_Action" }, disabled: { type: "boolean" } };
+function C(e, t) {
+  return { type: "object", properties: { ...structuredClone(st), type: { const: e }, options: { ...structuredClone(t) } }, required: ["id", "options"], additionalProperties: !1 };
+}
+function rt(e, t) {
+  return { type: "object", properties: { type: { type: "string", const: e }, ...t ? { payload: t } : {} }, required: ["type", ...t ? ["payload"] : []], additionalProperties: !1 };
+}
+function it(e, t) {
+  const s = t ? { payload: t } : {}, r = t ? ["payload"] : [];
+  return { type: "object", properties: { ...structuredClone(S), type: { type: "string", const: e }, ...s }, required: ["id", "type", "action", ...r], additionalProperties: !1 };
+}
+function ot() {
+  const e = { $schema: "https://json-schema.org/draft/2020-12/schema", $id: "https://example.com/schemas/project.json", title: "Project", type: "object", properties: { id: { type: "string" }, name: { type: "string" }, tasks: { type: "array", items: { oneOf: [{ $ref: "#/$defs/Runium_TaskConfig" }] }, minItems: 1, uniqueItemProperties: ["id"] }, triggers: { type: "array", items: { $ref: "#/$defs/Runium_Trigger" }, uniqueItemProperties: ["id"] } }, required: ["id", "tasks"], additionalProperties: !1, $defs: { Runium_EnvValue: { type: ["string", "number", "boolean"] }, Runium_Env: { type: "object", additionalProperties: { $ref: "#/$defs/Runium_EnvValue" } }, Runium_TaskStartMode: { type: "string", enum: Object.values(k) }, Runium_TaskHandler: { type: "object", properties: { action: { $ref: "#/$defs/Runium_Action" }, condition: { $ref: "#/$defs/Runium_TaskStateCondition" } }, required: ["action", "condition"], additionalProperties: !1 }, Runium_TaskStateCondition: { oneOf: [{ type: "string" }, { type: "boolean" }, { $ref: "#/$defs/Runium_TaskState" }] }, Runium_TaskState: { type: "object", properties: { status: { $ref: "#/$defs/Runium_TaskStatus" }, iteration: { type: "number", minimum: 0 }, exitCode: { type: "number", minimum: 0 } }, additionalProperties: !1 }, Runium_TaskStatus: { type: "string", enum: Object.values(g) }, Runium_TaskDependency: { type: "object", properties: { taskId: { type: "string" }, condition: { $ref: "#/$defs/Runium_TaskStateCondition" } }, required: ["taskId", "condition"], additionalProperties: !1 }, Runium_Trigger: { oneOf: [{ $ref: "#/$defs/Runium_TriggerEvent" }, { $ref: "#/$defs/Runium_TriggerInterval" }, { $ref: "#/$defs/Runium_TriggerTimeout" }] }, Runium_TriggerEvent: { type: "object", properties: { ...structuredClone(S), type: { const: h.EVENT }, event: { type: "string" } }, required: ["id", "type", "event", "action"], additionalProperties: !1 }, Runium_TriggerInterval: { type: "object", properties: { ...structuredClone(S), type: { const: h.INTERVAL }, interval: { type: "number", minimum: 0 } }, required: ["id", "type", "interval", "action"], additionalProperties: !1 }, Runium_TriggerTimeout: { type: "object", properties: { ...structuredClone(S), type: { const: h.TIMEOUT }, timeout: { type: "number", minimum: 0 } }, required: ["id", "type", "timeout", "action"], additionalProperties: !1 }, Runium_Action: { oneOf: [{ $ref: "#/$defs/Runium_ActionEmitEvent" }, { $ref: "#/$defs/Runium_ActionProcessTask" }, { $ref: "#/$defs/Runium_ActionStopProject" }, { $ref: "#/$defs/Runium_ActionToggleTrigger" }] }, Runium_ActionEmitEvent: { type: "object", properties: { type: { type: "string", const: p.EMIT_EVENT }, event: { type: "string" } }, required: ["type", "event"], additionalProperties: !1 }, Runium_ActionProcessTask: { type: "object", properties: { type: { type: "string", enum: [p.START_TASK, p.RESTART_TASK, p.STOP_TASK] }, taskId: { type: "string" } }, required: ["type", "taskId"], additionalProperties: !1 }, Runium_ActionStopProject: { type: "object", properties: { type: { type: "string", const: p.STOP_PROJECT } }, required: ["type"], additionalProperties: !1 }, Runium_ActionToggleTrigger: { type: "object", properties: { type: { type: "string", enum: [p.ENABLE_TRIGGER, p.DISABLE_TRIGGER] }, triggerId: { type: "string" } }, required: ["type", "triggerId"], additionalProperties: !1 }, Runium_TaskConfig: { ...C(f.DEFAULT, { $ref: "#/$defs/Runium_TaskOptions" }) }, Runium_TaskOptions: { type: "object", properties: { command: { type: "string" }, arguments: { type: "array", items: { type: "string" } }, shell: { type: "boolean" }, cwd: { type: "string" }, env: { $ref: "#/$defs/Runium_Env" }, ttl: { type: "number" }, log: { $ref: "#/$defs/Runium_TaskLog" }, stopSignal: { type: "string" } }, required: ["command"], additionalProperties: !1 }, Runium_TaskRestartPolicy: { oneOf: [{ $ref: "#/$defs/Runium_TaskRestartPolicyAlways" }, { $ref: "#/$defs/Runium_TaskRestartPolicyOnFailure" }] }, Runium_TaskRestartPolicyAlways: { type: "object", required: ["policy"], properties: { policy: { const: T.ALWAYS }, delay: { type: "number" } }, additionalProperties: !1 }, Runium_TaskRestartPolicyOnFailure: { type: "object", required: ["policy"], properties: { policy: { const: T.ON_FAILURE }, delay: { type: "number" }, maxRetries: { type: "number" } }, additionalProperties: !1 }, Runium_TaskLog: { type: "object", properties: { stdout: { type: ["string", "null"] }, stderr: { type: ["string", "null"] } }, additionalProperties: !1 } } };
+  return Object.freeze(e);
+}
+function nt(e, t) {
+  let s = structuredClone(e);
+  return t.project && (s = (function(r, i) {
+    return i && (r.properties = { ...i.properties || {}, ...r.properties }, r.required = Array.from(/* @__PURE__ */ new Set([...r.required ?? [], ...i.required ?? []]))), r;
+  })(s, t.project)), t.definitions && (s = (function(r, i) {
+    return i && (r.$defs = { ...i, ...r.$defs }), r;
+  })(s, t.definitions)), t.tasks && (s = (function(r, i) {
+    if (i) {
+      const o = new Set(r.properties.tasks.items.oneOf.map((c) => {
+        const n = c.$ref.split("/").pop() || "";
+        return r.$defs[n]?.properties?.type?.const || f.DEFAULT;
+      })), a = {};
+      for (const [c, n] of Object.entries(i)) {
+        if (o.has(n.type)) throw new d(`Task type "${n.type}" already used in project schema`, "project-schema-task-type-already-used", { type: n.type });
+        a[c] = C(n.type, n.options), r.properties.tasks.items.oneOf.push({ $ref: `#/$defs/${c}` }), o.add(n.type);
+      }
+      r.$defs = { ...a, ...r.$defs };
+    }
+    return r;
+  })(s, t.tasks)), t.actions && (s = (function(r, i) {
+    if (i) {
+      const o = new Set(r.$defs.Runium_Action.oneOf.map((c) => {
+        const n = c.$ref.split("/").pop() || "", u = r.$defs[n]?.properties?.type;
+        return u?.enum || [u?.const];
+      }).flat()), a = {};
+      for (const [c, n] of Object.entries(i)) {
+        if (o.has(n.type)) throw new d(`Action type "${n.type}" already used in project schema`, "project-schema-action-type-already-used", { type: n.type });
+        a[c] = rt(n.type, n.payload), r.$defs.Runium_Action.oneOf.push({ $ref: `#/$defs/${c}` }), o.add(n.type);
+      }
+      r.$defs = { ...a, ...r.$defs };
+    }
+    return r;
+  })(s, t.actions)), t.triggers && (s = (function(r, i) {
+    if (i) {
+      const o = new Set(r.$defs.Runium_Trigger.oneOf.map((c) => {
+        const n = c.$ref.split("/").pop() || "";
+        return r.$defs[n]?.properties?.type?.const;
+      })), a = {};
+      for (const [c, n] of Object.entries(i)) {
+        if (o.has(n.type)) throw new d(`Trigger type "${n.type}" already used in project schema`, "project-schema-trigger-type-already-used", { type: n.type });
+        a[c] = it(n.type, n.payload), r.$defs.Runium_Trigger.oneOf.push({ $ref: `#/$defs/${c}` }), o.add(n.type);
+      }
+      r.$defs = { ...a, ...r.$defs };
+    }
+    return r;
+  })(s, t.triggers)), Object.freeze(s);
+}
+class E {
+  project;
+  id;
+  action;
+  disabled;
+  constructor(t, s) {
+    this.id = t.id, this.action = t.action, this.disabled = t.disabled ?? !1, this.project = s;
+  }
+  getId() {
+    return this.id;
+  }
+  isDisabled() {
+    return this.disabled;
+  }
+}
+class at extends E {
+  event;
+  constructor(t, s) {
+    super(t, s), this.event = t.event;
+  }
+  enable() {
+    this.project.on(this.event, this.handler), this.disabled = !1;
+  }
+  disable() {
+    this.project.off(this.event, this.handler), this.disabled = !0;
+  }
+  handler = () => {
+    this.project.processAction(this.action);
+  };
+}
+class ct extends E {
+  interval;
+  intervalId = null;
+  constructor(t, s) {
+    super(t, s), this.interval = t.interval;
+  }
+  enable() {
+    this.intervalId = setInterval(() => {
+      this.project.processAction(this.action);
+    }, this.interval), this.disabled = !1;
+  }
+  disable() {
+    this.intervalId && clearInterval(this.intervalId), this.disabled = !0, this.intervalId = null;
+  }
+}
+class dt extends E {
+  timeout;
+  timeoutId = null;
+  constructor(t, s) {
+    super(t, s), this.timeout = t.timeout;
+  }
+  enable() {
+    this.timeoutId = setTimeout(() => {
+      this.project.processAction(this.action);
+    }, this.timeout), this.disabled = !1;
+  }
+  disable() {
+    this.timeoutId && clearTimeout(this.timeoutId), this.disabled = !0, this.timeoutId = null;
+  }
+}
+var pt = ((e) => (e.STATE_CHANGE = "state-change", e.START_TASK = "start-task", e.RESTART_TASK = "restart-task", e.STOP_TASK = "stop-task", e.PROCESS_ACTION = "process-action", e.ENABLE_TRIGGER = "enable-trigger", e.DISABLE_TRIGGER = "disable-trigger", e.TASK_STATE_CHANGE = "task-state-change", e.TASK_STDOUT = "task-stdout", e.TASK_STDERR = "task-stderr", e))(pt || {}), ut = ((e) => (e.IDLE = "idle", e.STARTING = "starting", e.STARTED = "started", e.STOPPING = "stopping", e.STOPPED = "stopped", e))(ut || {}), gt = ((e) => (e.ACTION_PROCESSOR_ALREADY_REGISTERED = "project-action-processor-already-registered", e.ACTION_PROCESSOR_INCORRECT = "project-action-processor-incorrect", e.TASK_PROCESSOR_NOT_FOUND = "project-task-processor-not-found", e.TASK_PROCESSOR_ALREADY_REGISTERED = "project-task-processor-already-registered", e.TASK_PROCESSOR_INCORRECT = "project-task-processor-incorrect", e.TRIGGER_PROCESSOR_ALREADY_REGISTERED = "project-trigger-processor-already-registered", e.TRIGGER_PROCESSOR_INCORRECT = "project-trigger-processor-incorrect", e))(gt || {});
+class $t extends b {
+  constructor(t) {
+    super(), this.config = t;
+  }
+  schema = ot();
+  taskProcessors = /* @__PURE__ */ new Map([[f.DEFAULT, tt]]);
+  actionProcessors = /* @__PURE__ */ new Map();
+  triggerProcessors = /* @__PURE__ */ new Map();
+  tasks = /* @__PURE__ */ new Map();
+  triggers = /* @__PURE__ */ new Map();
+  state = { timestamp: Date.now(), status: "idle" };
+  validate() {
+    Z(this.config, this.schema);
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  setConfig(t) {
+    this.config = { ...t };
+  }
+  getState() {
+    return { ...this.state };
+  }
+  async start() {
+    if (this.state.status !== "idle" && this.state.status !== "stopped") return;
+    this.validate(), this.initTasks(), this.initTriggers(), this.updateState({ status: "starting" });
+    const t = this.getTasksStartOrder();
+    for (const s of t) if (this.tasks.has(s)) {
+      const { instance: r, config: i } = this.tasks.get(s), { mode: o = k.IMMEDIATE, dependencies: a = [] } = i;
+      o === k.IMMEDIATE && a.length === 0 && r.start();
+    }
+    this.updateState({ status: "started" });
+  }
+  async stop() {
+    if (this.state.status !== "started" && this.state.status !== "starting") return;
+    this.updateState({ status: "stopping" }), this.cleanupTriggers();
+    const t = this.getTasksStartOrder().reverse(), s = [];
+    for (const r of t) if (this.tasks.has(r)) {
+      const { instance: i } = this.tasks.get(r), { status: o } = i.getState();
+      o === g.STARTED && s.push(i.stop());
+    }
+    await Promise.allSettled(s), this.updateState({ status: "stopped" });
+  }
+  extendValidationSchema(t) {
+    this.schema = nt(this.schema, t);
+  }
+  registerAction(t, s) {
+    if (this.actionProcessors.has(t)) throw new d(`Action processor for type "${t}" already registered`, "project-action-processor-already-registered", { type: t });
+    if (typeof s != "function") throw new d(`Action processor for type "${t}" must be a function`, "project-action-processor-incorrect", { type: t });
+    this.actionProcessors.set(t, s);
+  }
+  registerTask(t, s) {
+    if (this.taskProcessors.has(t)) throw new d(`Task processor for type "${t}" already registered`, "project-task-processor-already-registered", { type: t });
+    if (!(s.prototype instanceof v)) throw new d(`Task processor for type "${t}" must be a subclass of "RuniumTask"`, "project-task-processor-incorrect", { type: t });
+    this.taskProcessors.set(t, s);
+  }
+  registerTrigger(t, s) {
+    if (this.triggerProcessors.has(t)) throw new d(`Trigger processor for type "${t}" already registered`, "project-trigger-processor-already-registered", { type: t });
+    if (!(s.prototype instanceof E)) throw new d(`Trigger processor for type "${t}" must be a subclass of "RuniumTrigger"`, "project-trigger-processor-incorrect", { type: t });
+    this.triggerProcessors.set(t, s);
+  }
+  updateState(t) {
+    this.state = { ...this.state, ...t, timestamp: Date.now() }, this.emit("state-change", this.getState()), this.emit(this.state.status, this.getState());
+  }
+  initTasks() {
+    this.tasks.clear();
+    for (const t of this.config.tasks) {
+      const s = t.type || f.DEFAULT, r = this.taskProcessors.get(s);
+      if (!r) throw new d(`Task processor for type "${s}" not found`, "project-task-processor-not-found", { type: s });
+      const i = new r(t.options);
+      i.on(y.STATE_CHANGE, (o) => {
+        this.emit("task-state-change", t.id, o), this.onTaskStateChange(t.id, o);
+      }), i.on(y.STDOUT, (o) => {
+        this.emit("task-stdout", t.id, o);
+      }), i.on(y.STDERR, (o) => {
+        this.emit("task-stderr", t.id, o);
+      }), this.tasks.set(t.id, { instance: i, config: t, dependencies: [...t.dependencies || []], dependents: null });
+    }
+  }
+  getTasksStartOrder() {
+    const t = [], s = /* @__PURE__ */ new Set(), r = (i) => {
+      if (s.has(i)) return;
+      s.add(i);
+      const { dependencies: o = [] } = this.tasks.get(i) || {};
+      for (const a of o) this.tasks.has(a.taskId) && r(a.taskId);
+      t.push(i);
+    };
+    for (const i of this.tasks.keys()) r(i);
+    return t;
+  }
+  onTaskStateChange(t, s) {
+    const { config: r, instance: i } = this.tasks.get(t), o = this.getDependentTasks(t);
+    for (const a of o) this.isDependentTaskReady(a) && this.startTask(a);
+    if (s.status === g.COMPLETED || s.status === g.FAILED) {
+      const { restart: a } = r;
+      if (a && s.exitCode !== -1) {
+        const { policy: c } = a;
+        if (c === T.ALWAYS || c === T.ON_FAILURE && s.exitCode !== 0) {
+          const { maxRetries: n = 1 / 0, delay: u = 0 } = a;
+          s.iteration <= n && setTimeout(i.restart.bind(i), u);
+        }
+      }
+    }
+    (r.handlers || []).forEach((a) => {
+      this.checkTaskStateCondition(a.condition, s) && this.processAction(a.action);
+    });
+  }
+  checkTaskStateCondition(t, s) {
+    return typeof t == "string" ? M.evaluate(t, s) === !0 : typeof t == "object" ? Object.entries(t).every(([r, i]) => s[r] === i) : typeof t == "boolean" && t;
+  }
+  async startTask(t) {
+    if (this.tasks.has(t)) {
+      const { instance: s } = this.tasks.get(t), { status: r } = s.getState();
+      if (r !== g.STARTED && r !== g.STARTING && r !== g.STOPPING) return this.emit("start-task", t), s.start();
+    }
+  }
+  async stopTask(t) {
+    if (this.tasks.has(t)) {
+      const { instance: s } = this.tasks.get(t), { status: r } = s.getState();
+      if (r === g.STARTED) return this.emit("stop-task", t), s.stop();
+    }
+  }
+  async restartTask(t) {
+    if (this.tasks.has(t)) {
+      const { instance: s } = this.tasks.get(t);
+      return this.emit("restart-task", t), s.restart();
+    }
+  }
+  isDependentTaskReady(t) {
+    if (this.tasks.has(t)) {
+      const { dependencies: s = [] } = this.tasks.get(t);
+      for (const { taskId: r, condition: i } of s) {
+        const { instance: o } = this.tasks.get(r);
+        if (!this.checkTaskStateCondition(i, o.getState())) return !1;
+      }
+      return !0;
+    }
+    return !1;
+  }
+  getDependentTasks(t) {
+    let s = [];
+    if (this.tasks.has(t)) {
+      const { dependents: r } = this.tasks.get(t);
+      if (r) s = r;
+      else {
+        for (const [i, { dependencies: o }] of this.tasks) for (const a of o) a.taskId === t && s.push(i);
+        this.tasks.get(t).dependents = s;
+      }
+    }
+    return s;
+  }
+  processAction(t) {
+    if (this.emit("process-action", t), X(t)) {
+      const s = this.actionProcessors.get(t.type);
+      s && s(t.payload || {});
+    } else switch (t.type) {
+      case p.START_TASK:
+        this.startTask(t.taskId);
+        break;
+      case p.RESTART_TASK:
+        this.restartTask(t.taskId);
+        break;
+      case p.STOP_TASK:
+        this.stopTask(t.taskId);
+        break;
+      case p.EMIT_EVENT:
+        this.emit(t.event);
+        break;
+      case p.STOP_PROJECT:
+        break;
+      case p.ENABLE_TRIGGER:
+        this.enableTrigger(t.triggerId);
+        break;
+      case p.DISABLE_TRIGGER:
+        this.disableTrigger(t.triggerId);
+    }
+  }
+  initTriggers() {
+    const t = { processAction: this.processAction.bind(this), on: this.on.bind(this), off: this.off.bind(this) };
+    let s = null;
+    for (const r of this.config.triggers || []) {
+      if (z(r)) {
+        const i = this.triggerProcessors.get(r.type);
+        i && (s = new i(r, t));
+      } else switch (r.type) {
+        case h.EVENT:
+          s = new at(r, t);
+          break;
+        case h.INTERVAL:
+          s = new ct(r, t);
+          break;
+        case h.TIMEOUT:
+          s = new dt(r, t);
+      }
+      s && (this.triggers.set(r.id, s), r.disabled !== !0 && s.enable());
+    }
+  }
+  cleanupTriggers() {
+    for (const t in this.triggers) {
+      const s = this.triggers.get(t);
+      s && s.disable();
+    }
+    this.triggers.clear();
+  }
+  enableTrigger(t) {
+    const s = this.triggers.get(t);
+    s && (this.emit("enable-trigger", t), s.enable());
+  }
+  disableTrigger(t) {
+    const s = this.triggers.get(t);
+    s && (this.emit("disable-trigger", t), s.disable());
+  }
+}
+export {
+  at as EventTrigger,
+  F as FileErrorCode,
+  ct as IntervalTrigger,
+  $t as Project,
+  p as ProjectActionType,
+  V as ProjectConfigErrorCode,
+  gt as ProjectErrorCode,
+  pt as ProjectEvent,
+  et as ProjectSchemaErrorCode,
+  ut as ProjectStatus,
+  T as ProjectTaskRestartPolicyType,
+  k as ProjectTaskStartMode,
+  f as ProjectTaskType,
+  h as ProjectTriggerType,
+  d as RuniumError,
+  v as RuniumTask,
+  E as RuniumTrigger,
+  It as SILENT_EXIT_CODE,
+  tt as Task,
+  y as TaskEvent,
+  g as TaskStatus,
+  dt as TimeoutTrigger,
+  _t as applyMacros,
+  nt as extendProjectSchema,
+  ot as getProjectSchema,
+  X as isCustomAction,
+  z as isCustomTrigger,
+  w as isProcessTaskAction,
+  Et as isRuniumError,
+  P as isToggleTriggerAction,
+  Rt as readJsonFile,
+  Z as validateProject,
+  At as writeJsonFile
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@runium/core",
+  "version": "0.0.1",
+  "description": "Runium Core",
+  "author": "TheBeastApp",
+  "license": "MIT",
+  "type": "module",
+  "types": "./index.d.ts",
+  "main": "./index.js",
+  "module": "./index.js",
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    }
+  },
+  "dependencies": {
+    "ajv": "^8.17.1",
+    "ajv-keywords": "^5.1.0",
+    "bcx-expression-evaluator": "^1.2.1"
+  }
+}