@pipelab/core-node 1.0.1-beta.23 → 1.0.1-beta.25

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @pipelab/core-node
 
+## 1.0.1-beta.25
+
+### Patch Changes
+
+- sdsd
+- Updated dependencies
+  - @pipelab/constants@1.0.1-beta.21
+  - @pipelab/shared@2.0.1-beta.22
+
+## 1.0.1-beta.24
+
+### Patch Changes
+
+- gf
+- Updated dependencies
+  - @pipelab/constants@1.0.1-beta.20
+  - @pipelab/shared@2.0.1-beta.21
+
 ## 1.0.1-beta.23
 
 ### Patch Changes

package/dist/index.d.mts

@@ -1,24 +1,24 @@
 /// <reference types="node" />
 import { WebSocket } from "ws";
-import { Action, Agent, BlockCondition, Channels, Condition, End, Event as Event$1, Events, Expression, ExtractInputsFromAction, ExtractInputsFromCondition, ExtractInputsFromEvent, ExtractInputsFromExpression, ExtractInputsFromLoop, HandleListenerRendererSendFn, IpcMessage, Loop, Migrator, RendererChannels, RendererData, RendererEnd, RendererEvents, RendererMessage, RequestId, SetOutputActionFn, SetOutputExpressionFn, SetOutputLoopFn, UpdateStatus, WebSocketConnectionState, WebSocketEvent, WebSocketHandler, WebSocketSendFunction } from "@pipelab/shared";
+import { Action, Agent, BlockCondition, BuildHistoryEntry, Channels, Condition, End, Event as Event$1, Events, Expression, ExtractInputsFromAction, ExtractInputsFromCondition, ExtractInputsFromEvent, ExtractInputsFromExpression, ExtractInputsFromLoop, HandleListenerRendererSendFn, IBuildHistoryStorage, IpcMessage, Loop, Migrator, RendererChannels, RendererData, RendererEnd, RendererEvents, RendererMessage, RequestId, SetOutputActionFn, SetOutputExpressionFn, SetOutputLoopFn, UpdateStatus, Variable, WebSocketConnectionState, WebSocketEvent, WebSocketHandler, WebSocketSendFunction } from "@pipelab/shared";
 import * as execa$1 from "execa";
 import { Options as Options$1, Subprocess } from "execa";
 import * as http$1 from "http";
 import http from "http";
 
 //#region src/context.d.ts
-/**
- * Encapsulates the execution context of a Pipelab operation.
- * Must be passed explicitly to all functions that require context.
- */
-interface PipelabContext {
-  readonly isDev: boolean;
+declare const isDev: boolean;
+declare const projectRoot: string | null;
+interface PipelabContextOptions {
+  userDataPath: string;
+}
+declare class PipelabContext {
   readonly userDataPath: string;
-  readonly assetsPath: string;
+  constructor(options: PipelabContextOptions);
+  getPackagesPath(...subpaths: string[]): string;
+  getThirdPartyPath(...subpaths: string[]): string;
+  getConfigPath(...subpaths: string[]): string;
 }
-declare function createPipelabContext(options?: {
-  userDataPath?: string;
-}): PipelabContext;
 //#endregion
 //#region src/websocket-server.d.ts
 interface ConnectedClient {
@@ -66,10 +66,10 @@ declare const useAPI: () => {
 };
 //#endregion
 //#region src/handlers/shell.d.ts
-declare const registerShellHandlers: () => void;
+declare const registerShellHandlers: (_context: PipelabContext) => void;
 //#endregion
 //#region src/handlers/fs.d.ts
-declare const registerFsHandlers: () => void;
+declare const registerFsHandlers: (_context: PipelabContext) => void;
 //#endregion
 //#region src/handlers/config.d.ts
 declare const registerConfigHandlers: (context: PipelabContext) => void;
@@ -81,21 +81,58 @@ declare const registerHistoryHandlers: (context: PipelabContext) => void;
 declare const registerEngineHandlers: (context: PipelabContext) => void;
 //#endregion
 //#region src/handlers/agents.d.ts
-declare const registerAgentsHandlers: () => void;
+declare const registerAgentsHandlers: (_context: PipelabContext) => void;
+//#endregion
+//#region src/handlers/build-history.d.ts
+declare class BuildHistoryStorage implements IBuildHistoryStorage {
+  private context;
+  private logger;
+  constructor(context: PipelabContext);
+  private getStoragePath;
+  private getPipelinePath;
+  private ensureStoragePath;
+  private loadPipelineHistory;
+  private savePipelineHistory;
+  applyRetentionPolicy(): Promise<void>;
+  save(entry: BuildHistoryEntry): Promise<void>;
+  get(id: string, pipelineId?: string): Promise<BuildHistoryEntry | undefined>;
+  getAll(): Promise<BuildHistoryEntry[]>;
+  getByPipeline(pipelineId: string): Promise<BuildHistoryEntry[]>;
+  update(id: string, updates: Partial<BuildHistoryEntry>, pipelineId?: string): Promise<void>;
+  delete(id: string, pipelineId?: string): Promise<void>;
+  clear(): Promise<void>;
+  clearByPipeline(pipelineId: string): Promise<void>;
+  getStorageInfo(): Promise<{
+    totalEntries: number;
+    totalSize: number;
+    oldestEntry?: number;
+    newestEntry?: number;
+    numberOfPipelines: number;
+    cachePath: string;
+    userDataPath: string;
+    retentionPolicy: {
+      enabled: boolean;
+      maxEntries: number;
+      maxAge: number;
+    };
+  }>;
+  private getAllPipelineFiles;
+}
 //#endregion
 //#region src/handlers/index.d.ts
 declare const registerAllHandlers: (options: {
   version: string;
-  nodePath?: string;
-  pnpmPath?: string;
-}, context: PipelabContext) => Promise<void>;
+  context: PipelabContext;
+}) => Promise<void>;
 //#endregion
 //#region src/config.d.ts
 declare const getMigrator: <T>(name: string) => any;
-declare const setupConfigFile: <T>(name: string, customMigrator?: Migrator<T>, context?: PipelabContext) => Promise<{
-  getConfig: () => Promise<any>;
-  saveConfig: (json: T) => Promise<void>;
-  migrate: (json: any) => Promise<T>;
+declare const setupConfigFile: <T>(name: string, options: {
+  context: PipelabContext;
+  migrator?: Migrator<T>;
+}) => Promise<{
+  setConfig: (config: T) => Promise<boolean>;
+  getConfig: () => Promise<T>;
 }>;
 //#endregion
 //#region src/api.d.ts
@@ -110,38 +147,37 @@ declare const usePluginAPI: (browserWindow: any) => {
   execute: <KEY extends RendererChannels>(channel: KEY, data?: RendererData<KEY>, listener?: ListenerMain<KEY>) => Promise<RendererEnd<KEY>>;
 };
 type UseMainAPI = ReturnType<typeof usePluginAPI>;
-declare function createApiObject(context: PipelabContext): PipelabApi$1;
 //#endregion
 //#region src/handler-func.d.ts
 declare const handleConditionExecute: (nodeId: string, pluginId: string, params: BlockCondition["params"], cwd: string, context: PipelabContext) => Promise<End<"condition:execute">>;
 declare const handleActionExecute: (nodeId: string, pluginId: string, params: Record<string, string>, mainWindow: any | undefined, send: HandleListenerSendFn<"action:execute">, abortSignal: AbortSignal, cwd: string, cachePath: string, context: PipelabContext) => Promise<End<"action:execute">>;
 //#endregion
 //#region src/utils.d.ts
-declare const getFinalPlugins: () => any[];
+declare const getFinalPlugins: () => RendererPluginDefinition[];
 declare const executeGraphWithHistory: ({
   graph,
   variables,
   projectName,
   projectPath,
   pipelineId,
-  mainWindow,
   onNodeEnter,
   onNodeExit,
   onLog,
   abortSignal,
+  mainWindow,
   cachePath,
   context
 }: {
   graph: any;
-  variables: any;
+  variables: Variable[];
   projectName: string;
   projectPath: string;
   pipelineId: string;
-  mainWindow: any;
   onNodeEnter?: (node: any) => void;
   onNodeExit?: (node: any) => void;
-  onLog?: (data: any, node: any) => void;
+  onLog?: (data: any, node?: any) => void;
   abortSignal: AbortSignal;
+  mainWindow?: any;
   cachePath: string;
   context: PipelabContext;
 }) => Promise<{
@@ -151,23 +187,20 @@ declare const executeGraphWithHistory: ({
 //#endregion
 //#region src/plugins-registry.d.ts
 declare const builtInPlugins: (options: {
-  nodePath?: string;
-  pnpmPath?: string;
-} | undefined, context: PipelabContext) => Promise<any[]>;
+  context: PipelabContext;
+}) => Promise<any[]>;
 //#endregion
 //#region src/utils/remote.d.ts
 type FetchOptions = {
   installDeps?: boolean;
-  nodePath?: string;
-  pnpmPath?: string;
-  baseDir?: string;
   signal?: AbortSignal;
+  context: PipelabContext;
 };
 /**
  * Robust utility to fetch, cache, and resolve an NPM package.
  * Centralized in core-node to avoid circular dependencies.
  */
-declare function fetchPackage(packageName: string, versionOrRange: string | undefined, context: PipelabContext, options?: FetchOptions): Promise<{
+declare function fetchPackage(packageName: string, versionOrRange: string, options: FetchOptions): Promise<{
   packageDir: string;
   resolvedVersion: string;
   isLocal?: boolean;
@@ -176,14 +209,15 @@ declare function fetchPackage(packageName: string, versionOrRange: string | unde
 /**
  * Executes a pnpm install in a specific directory with a portable environment.
  */
-declare function runPnpm(cwd: string, context: PipelabContext, options?: {
+declare function runPnpm(cwd: string, options: {
   args?: string[];
   extraEnv?: Record<string, string>;
   signal?: AbortSignal;
+  context: PipelabContext;
 }): Promise<execa$1.Result<{
   cwd: string;
   all: true;
-  signal: AbortSignal | undefined;
+  cancelSignal: AbortSignal | undefined;
   env: {
     NODE_ENV: string;
     PATH: string | undefined;
@@ -193,18 +227,22 @@ declare function runPnpm(cwd: string, context: PipelabContext, options?: {
 /**
  * Installs a specific version of Node.js if not already present.
  */
-declare function ensureNodeJS(version: string, context: PipelabContext): Promise<string>;
+declare function ensureNodeJS(version: string, options: {
+  context: PipelabContext;
+}): Promise<string>;
 /**
  * Installs the PNPM package from npm if not already present.
  */
-declare function ensurePNPM(context: PipelabContext, version?: string): Promise<string>;
-declare function fetchPipelabAsset(packageName: string, context: PipelabContext, versionOrRange?: string, options?: FetchOptions): Promise<string>;
-declare function fetchPipelabPlugin(pluginName: string, context: PipelabContext, versionOrRange?: string, options?: FetchOptions): Promise<{
+declare function ensurePNPM(version: string | undefined, options: {
+  context: PipelabContext;
+}): Promise<string>;
+declare function fetchPipelabAsset(packageName: string, versionOrRange: string, options: FetchOptions): Promise<string>;
+declare function fetchPipelabPlugin(pluginName: string, versionOrRange: string, options: FetchOptions): Promise<{
   packageDir: string;
   entryPoint: string;
   isLocal: boolean;
 }>;
-declare function fetchPipelabCli(context: PipelabContext, versionOrRange?: string, options?: FetchOptions): Promise<{
+declare function fetchPipelabCli(versionOrRange: string, options: FetchOptions): Promise<{
   packageDir: string;
   entryPoint: string;
   isLocal: boolean;
@@ -280,48 +318,68 @@ type RunnerCallbackFnArgument = {
   log: (...args: Parameters<(typeof console)["log"]>) => void;
 };
 type ActionRunnerData<ACTION extends Action> = {
+  log: typeof console.log;
   setOutput: SetOutputActionFn<ACTION>;
   inputs: ExtractInputsFromAction<ACTION>;
   setMeta: (callback: (data: ACTION["meta"]) => ACTION["meta"]) => void;
   meta: ACTION["meta"];
+  cwd: string;
+  paths: {
+    cache: string;
+    pnpm: string;
+    node: string;
+    userData: string;
+    modules: string;
+    thirdparty: string;
+  };
   browserWindow: BrowserWindow$1;
   abortSignal: AbortSignal;
+  context: PipelabContext;
 };
-type ActionRunner<ACTION extends Action> = (api: PipelabApi, data: ActionRunnerData<ACTION>) => Promise<void>;
-type ConditionRunnerData<CONDITION extends Condition> = {
+type ActionRunner<ACTION extends Action> = (data: ActionRunnerData<ACTION>) => Promise<void>;
+type ConditionRunner<CONDITION extends Condition> = (data: {
+  log: typeof console.log;
   inputs: ExtractInputsFromCondition<CONDITION>;
   setMeta: (callback: (data: CONDITION["meta"]) => CONDITION["meta"]) => void;
   meta: CONDITION["meta"];
-};
-type ConditionRunner<CONDITION extends Condition> = (api: PipelabApi, data: ConditionRunnerData<CONDITION>) => Promise<boolean>;
-type LoopRunnerData<LOOP extends Loop> = {
+  cwd: string;
+  context: PipelabContext;
+}) => Promise<boolean>;
+type LoopRunner<LOOP extends Loop> = (data: {
+  log: typeof console.log;
   setOutput: SetOutputLoopFn<LOOP>;
   inputs: ExtractInputsFromLoop<LOOP>;
   setMeta: (callback: (data: LOOP["meta"]) => LOOP["meta"]) => void;
   meta: LOOP["meta"];
-};
-type LoopRunner<LOOP extends Loop> = (api: PipelabApi, data: LoopRunnerData<LOOP>) => Promise<"step" | "exit">;
-type ExpressionRunnerData<EXPRESSION extends Expression> = {
+  cwd: string;
+  context: PipelabContext;
+}) => Promise<"step" | "exit">;
+type ExpressionRunner<EXPRESSION extends Expression> = (data: {
+  log: typeof console.log;
   setOutput: SetOutputExpressionFn<EXPRESSION>;
   inputs: ExtractInputsFromExpression<EXPRESSION>;
   setMeta: (callback: (data: EXPRESSION["meta"]) => EXPRESSION["meta"]) => void;
   meta: EXPRESSION["meta"];
-};
-type ExpressionRunner<EXPRESSION extends Expression> = (api: PipelabApi, data: ExpressionRunnerData<EXPRESSION>) => Promise<string>;
-type EventRunnerData<EVENT extends Event$1> = {
+  cwd: string;
+  context: PipelabContext;
+}) => Promise<string>;
+type EventRunner<EVENT extends Event$1> = (data: {
+  log: typeof console.log;
   inputs: ExtractInputsFromEvent<EVENT>;
   setMeta: (callback: (data: EVENT["meta"]) => EVENT["meta"]) => void;
   meta: EVENT["meta"];
-};
-type EventRunner<EVENT extends Event$1> = (api: PipelabApi, data: EventRunnerData<EVENT>) => Promise<void>;
+  cwd: string;
+  context: PipelabContext;
+}) => Promise<void>;
 type Runner = ActionRunner<any> | LoopRunner<any> | EventRunner<any> | ConditionRunner<any>;
 //#endregion
 //#region src/runner.d.ts
-declare function runPipelineCommand(file: string, options: {
+interface RunOptions {
+  userData?: string;
   variables?: string;
   output?: string;
-  userData?: string;
-}, version: string, context: PipelabContext): Promise<any>;
+}
+declare function runPipelineCommand(file: string, options: RunOptions, version: string): Promise<any>;
 //#endregion
 //#region src/migrations.d.ts
 /**
@@ -338,7 +396,7 @@ interface ServeOptions {
   nodePath?: string;
   pnpmPath?: string;
 }
-declare function serveCommand(options: ServeOptions, version: string, dirname: string, context: PipelabContext): Promise<http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>>;
+declare function serveCommand(options: ServeOptions, version: string, _dirname: string): Promise<http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>>;
 //#endregion
-export { type Action, ActionRunner, ActionRunnerData, type Condition, ConditionRunner, ConditionRunnerData, ConnectedClient, DownloadHooks, type Event$1 as Event, EventRunner, EventRunnerData, type Expression, ExpressionRunner, ExpressionRunnerData, type ExtractInputsFromAction, type ExtractInputsFromCondition, type ExtractInputsFromEvent, type ExtractInputsFromExpression, type ExtractInputsFromLoop, FetchOptions, HandleListener, HandleListenerRenderer, type HandleListenerRendererSendFn, HandleListenerSendFn, ListenerMain, type Loop, LoopRunner, LoopRunnerData, PipelabContext, type RendererChannels, type RendererData, type RendererEnd, type RendererEvents, type RendererMessage, type RequestId, Runner, RunnerCallbackFnArgument, ServeOptions, type SetOutputActionFn, type SetOutputExpressionFn, type SetOutputLoopFn, type UpdateStatus, UseMainAPI, WebSocketServer, WsEvent, builtInPlugins, createApiObject, createPipelabContext, downloadFile, ensure, ensureNodeJS, ensurePNPM, executeGraphWithHistory, extractTarGz, extractZip, fetchPackage, fetchPipelabAsset, fetchPipelabCli, fetchPipelabPlugin, generateTempFolder, getFinalPlugins, getMigrator, handleActionExecute, handleConditionExecute, registerAgentsHandlers, registerAllHandlers, registerConfigHandlers, registerEngineHandlers, registerFsHandlers, registerHistoryHandlers, registerMigrationHandlers, registerShellHandlers, runPipelineCommand, runPnpm, runWithLiveLogs, serveCommand, setupConfigFile, useAPI, usePluginAPI, webSocketServer, zipFolder };
+export { type Action, ActionRunner, ActionRunnerData, BuildHistoryStorage, type Condition, ConditionRunner, ConnectedClient, DownloadHooks, type Event$1 as Event, EventRunner, type Expression, ExpressionRunner, type ExtractInputsFromAction, type ExtractInputsFromCondition, type ExtractInputsFromEvent, type ExtractInputsFromExpression, type ExtractInputsFromLoop, FetchOptions, HandleListener, HandleListenerRenderer, type HandleListenerRendererSendFn, HandleListenerSendFn, ListenerMain, type Loop, LoopRunner, PipelabContext, PipelabContextOptions, type RendererChannels, type RendererData, type RendererEnd, type RendererEvents, type RendererMessage, type RequestId, RunOptions, Runner, RunnerCallbackFnArgument, ServeOptions, type SetOutputActionFn, type SetOutputExpressionFn, type SetOutputLoopFn, type UpdateStatus, UseMainAPI, WebSocketServer, WsEvent, builtInPlugins, downloadFile, ensure, ensureNodeJS, ensurePNPM, executeGraphWithHistory, extractTarGz, extractZip, fetchPackage, fetchPipelabAsset, fetchPipelabCli, fetchPipelabPlugin, generateTempFolder, getFinalPlugins, getMigrator, handleActionExecute, handleConditionExecute, isDev, projectRoot, registerAgentsHandlers, registerAllHandlers, registerConfigHandlers, registerEngineHandlers, registerFsHandlers, registerHistoryHandlers, registerMigrationHandlers, registerShellHandlers, runPipelineCommand, runPnpm, runWithLiveLogs, serveCommand, setupConfigFile, useAPI, usePluginAPI, webSocketServer, zipFolder };
 //# sourceMappingURL=index.d.mts.map