@runium/core 0.0.2 → 0.0.4

package/index.d.ts

@@ -0,0 +1,409 @@
+import { ChildProcessWithoutNullStreams } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import { WriteStream } from 'node:fs';
+
+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 enum MacrosErrorCode {
+    MACRO_APPLY_ERROR = "macro-apply-error"
+}
+
+export declare class Project extends EventEmitter {
+    constructor(config: ProjectConfig);
+    validate(): void;
+    getConfig(): ProjectConfig;
+    setConfig(config: ProjectConfig): void;
+    getState(): ProjectState;
+    start(): Promise<void>;
+    stop(reason?: string): 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;
+    reason?: string;
+}
+
+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(reason?: string): 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;
+    reason?: string;
+}
+
+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;
+    protected state: TaskState;
+    protected process: ChildProcessWithoutNullStreams | null;
+    protected stdoutStream: WriteStream | null;
+    protected stderrStream: WriteStream | null;
+    protected ttlTimer: NodeJS.Timeout | null;
+    constructor(options: TaskOptions);
+    getState(): TaskState;
+    getOptions(): TaskOptions;
+    start(): Promise<void>;
+    stop(reason?: string): Promise<void>;
+    restart(): Promise<void>;
+    protected updateState(state: Partial<TaskState>): void;
+    protected initLogStreams(): Promise<void>;
+    protected setTTLTimer(): void;
+    protected addProcessListeners(): void;
+    protected onStdOutData(data: Buffer): void;
+    protected onStdErrData(data: Buffer): void;
+    protected onExit(code: number | null): void;
+    protected onError(error: Error): void;
+    protected cleanup(): 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

@@ -148,16 +148,16 @@ class et extends C {
       }
     }
   }
-  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 stop(t = "") {
+    if (this.process && this.state.status !== "stopping" && this.state.status === "started") return this.updateState({ status: "stopping", reason: t }), new Promise((s) => {
+      const r = this.options.stopSignal || "SIGTERM";
+      this.process.kill(r), this.process.on("exit", () => {
+        s();
       });
     });
   }
   async restart() {
-    await this.stop(), this.start();
+    await this.stop("restart"), this.start();
   }
   updateState(t) {
     const s = { ...this.state, ...t, timestamp: Date.now() };
@@ -177,7 +177,7 @@ class et extends C {
   setTTLTimer() {
     const { ttl: t } = this.options;
     t && this.process && (this.ttlTimer = setTimeout(() => {
-      this.stop();
+      this.stop("ttl");
     }, t));
   }
   addProcessListeners() {
@@ -215,7 +215,7 @@ function ot(e, t) {
   return { type: "object", properties: { ...structuredClone(k), type: { type: "string", const: e }, ...s }, required: ["id", "type", "action", ...r], additionalProperties: !1 };
 }
 function nt() {
-  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(R) }, 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(h) }, 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(k), type: { const: l.EVENT }, event: { type: "string" } }, required: ["id", "type", "event", "action"], additionalProperties: !1 }, Runium_TriggerInterval: { type: "object", properties: { ...structuredClone(k), type: { const: l.INTERVAL }, interval: { type: "number", minimum: 0 } }, required: ["id", "type", "interval", "action"], additionalProperties: !1 }, Runium_TriggerTimeout: { type: "object", properties: { ...structuredClone(k), type: { const: l.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: d.EMIT_EVENT }, event: { type: "string" } }, required: ["type", "event"], additionalProperties: !1 }, Runium_ActionProcessTask: { type: "object", properties: { type: { type: "string", enum: [d.START_TASK, d.RESTART_TASK, d.STOP_TASK] }, taskId: { type: "string" } }, required: ["type", "taskId"], additionalProperties: !1 }, Runium_ActionStopProject: { type: "object", properties: { type: { type: "string", const: d.STOP_PROJECT } }, required: ["type"], additionalProperties: !1 }, Runium_ActionToggleTrigger: { type: "object", properties: { type: { type: "string", enum: [d.ENABLE_TRIGGER, d.DISABLE_TRIGGER] }, triggerId: { type: "string" } }, required: ["type", "triggerId"], additionalProperties: !1 }, Runium_TaskConfig: { ...D(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 } } };
+  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(R) }, 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 }, reason: { type: "string" } }, additionalProperties: !1 }, Runium_TaskStatus: { type: "string", enum: Object.values(h) }, 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(k), type: { const: l.EVENT }, event: { type: "string" } }, required: ["id", "type", "event", "action"], additionalProperties: !1 }, Runium_TriggerInterval: { type: "object", properties: { ...structuredClone(k), type: { const: l.INTERVAL }, interval: { type: "number", minimum: 0 } }, required: ["id", "type", "interval", "action"], additionalProperties: !1 }, Runium_TriggerTimeout: { type: "object", properties: { ...structuredClone(k), type: { const: l.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: d.EMIT_EVENT }, event: { type: "string" } }, required: ["type", "event"], additionalProperties: !1 }, Runium_ActionProcessTask: { type: "object", properties: { type: { type: "string", enum: [d.START_TASK, d.RESTART_TASK, d.STOP_TASK] }, taskId: { type: "string" } }, required: ["type", "taskId"], additionalProperties: !1 }, Runium_ActionStopProject: { type: "object", properties: { type: { type: "string", const: d.STOP_PROJECT } }, required: ["type"], additionalProperties: !1 }, Runium_ActionToggleTrigger: { type: "object", properties: { type: { type: "string", enum: [d.ENABLE_TRIGGER, d.DISABLE_TRIGGER] }, triggerId: { type: "string" } }, required: ["type", "triggerId"], additionalProperties: !1 }, Runium_TaskConfig: { ...D(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 at(e, t) {
@@ -359,15 +359,15 @@ class jt extends O {
     }
     this.updateState({ status: "started" });
   }
-  async stop() {
+  async stop(t = "") {
     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 === h.STARTED && s.push(i.stop());
+    this.updateState({ status: "stopping", reason: t }), this.cleanupTriggers();
+    const s = this.getTasksStartOrder().reverse(), r = [];
+    for (const i of s) if (this.tasks.has(i)) {
+      const { instance: o } = this.tasks.get(i), { status: a } = o.getState();
+      a === h.STARTED && r.push(o.stop("project-stop"));
     }
-    await Promise.allSettled(s), this.updateState({ status: "stopped" });
+    await Promise.allSettled(r), this.updateState({ status: "stopped" });
   }
   extendValidationSchema(t) {
     this.schema = at(this.schema, t);
@@ -445,7 +445,7 @@ class jt extends O {
   async stopTask(t) {
     if (this.tasks.has(t)) {
       const { instance: s } = this.tasks.get(t), { status: r } = s.getState();
-      if (r === h.STARTED) return this.emit("stop-task", t), s.stop();
+      if (r === h.STARTED) return this.emit("stop-task", t), s.stop("action-stop");
     }
   }
   async restartTask(t) {

package/package.json

@@ -1,17 +1,20 @@
 {
   "name": "@runium/core",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Runium Core",
   "author": "TheBeastApp",
   "license": "MIT",
   "type": "module",
+  "types": "./index.d.ts",
   "main": "./index.js",
   "module": "./index.js",
   "files": [
-    "index.js"
+    "index.js",
+    "index.d.ts"
   ],
   "exports": {
     ".": {
+      "types": "./index.d.ts",
       "import": "./index.js"
     }
   },