@pipelab/core-node 1.0.0-beta.26 → 1.0.0-beta.30

package/dist/index.d.cts

@@ -0,0 +1,774 @@
+/// <reference types="node" />
+import { DEFAULT_NODE_VERSION, DEFAULT_PNPM_VERSION, SandboxFolder } from "@pipelab/constants";
+import * as http$1 from "http";
+import http from "http";
+import { WebSocket } from "ws";
+import * as _pipelab_shared0 from "@pipelab/shared";
+import { Action, Agent, BuildHistoryEntry, Channels, End, Event as Event$1, Events, Expression, ExtractInputsFromAction, ExtractInputsFromEvent, ExtractInputsFromExpression, HandleListenerRendererSendFn, IBuildHistoryStorage, IpcMessage, RendererChannels, RendererData, RendererEnd, RendererEvents, RendererMessage, RendererPluginDefinition, RequestId, SetOutputActionFn, SetOutputExpressionFn, UpdateStatus, Variable, WebSocketConnectionState, WebSocketEvent, WebSocketHandler, WebSocketSendFunction } from "@pipelab/shared";
+import * as execa from "execa";
+import { Options as Options$1, Subprocess } from "execa";
+
+//#region src/context.d.ts
+declare const isDev: boolean;
+type PipelabEnv = "dev" | "beta" | "prod";
+declare const getDefaultUserDataPath: (env?: PipelabEnv) => string;
+declare const projectRoot: string | null;
+declare const CacheFolder: {
+  readonly Actions: "actions";
+  readonly Pipelines: "pipelines";
+  readonly Pacote: "pacote";
+};
+type CacheFolderType = (typeof CacheFolder)[keyof typeof CacheFolder];
+interface PipelabContextOptions {
+  userDataPath: string;
+  releaseTag?: string;
+}
+type Join<T extends string[], D extends string> = T extends [] ? "" : T extends [infer F extends string] ? F : T extends [infer F extends string, ...infer R extends string[]] ? `${F}${D}${Join<R, D>}` : string;
+declare class PipelabContext {
+  readonly userDataPath: string;
+  readonly releaseTag: string;
+  constructor(options: PipelabContextOptions);
+  getPackagesPath<S extends string[]>(...subpaths: S): `PACKAGES/${Join<S, "/">}`;
+  getThirdPartyPath<S extends string[]>(...subpaths: S): `THIRDPARTY/${Join<S, "/">}`;
+  getConfigPath<S extends string[]>(...subpaths: S): `CONFIG/${Join<S, "/">}`;
+  getSettingsPath(): `CONFIG/settings.json`;
+  getConnectionsPath(): `CONFIG/connections.json`;
+  getProjectsPath(): `CONFIG/projects.json`;
+  private _cachedSettings;
+  private _cachedSettingsTime;
+  private getSettings;
+  getTempPath<S extends string[]>(...subpaths: S): `TEMP/${Join<S, "/">}`;
+  createTempFolder<T extends string = "pipelab-">(prefix?: T): Promise<`TEMP/${T}${string}`>;
+  getCachePath(): `CACHE/`;
+  getCachePath<F extends CacheFolderType, S extends string[]>(folder: F, ...subpaths: S): `CACHE/${F}/${Join<S, "/">}`;
+  getPnpmPath<S extends string[]>(...subpaths: S): `PNPM/${Join<S, "/">}`;
+  getBuildHistoryPath<S extends string[]>(...subpaths: S): `BUILD_HISTORY/${Join<S, "/">}`;
+  getNodePath<V extends string = typeof DEFAULT_NODE_VERSION>(version?: V): `THIRDPARTY/node/${V}/${string}`;
+  getPnpmBinPath<V extends string = typeof DEFAULT_PNPM_VERSION>(version?: V): `PACKAGES/pnpm/${V}/bin/pnpm.cjs`;
+  getSandboxFolders(): Array<{
+    name: SandboxFolder;
+    label: string;
+    path: string;
+  }>;
+}
+//#endregion
+//#region src/websocket-server.d.ts
+interface ConnectedClient {
+  id: string;
+  name: string;
+  ws: WebSocket;
+  connectedAt: number;
+}
+declare class WebSocketServer {
+  private wss;
+  private server;
+  private isReady;
+  private readyResolve;
+  private connectionState;
+  private clients;
+  private lastBroadcasts;
+  start(port?: number, existingServer?: http$1.Server): Promise<void>;
+  private handleWebSocketMessage;
+  private sendError;
+  stop(): Promise<void>;
+  waitForReady(): Promise<void>;
+  isServerReady(): boolean;
+  getConnectionState(): WebSocketConnectionState;
+  getAgents(): Agent[];
+  getClient(ws: WebSocket): ConnectedClient | undefined;
+  /**
+   * Broadcasts a message to all connected clients.
+   * Useful for push notifications like auth state changes.
+   */
+  broadcast<KEY extends Channels>(channel: KEY, data: Events<KEY>): void;
+}
+declare const webSocketServer: WebSocketServer;
+//#endregion
+//#region src/ipc-core.d.ts
+type HandleListenerSendFn<KEY extends Channels> = WebSocketSendFunction<KEY>;
+type WsEvent = WebSocketEvent;
+type HandleListener<KEY extends Channels> = WebSocketHandler<KEY>;
+declare const useAPI: () => {
+  handle: <KEY extends Channels>(channel: KEY, listener: WebSocketHandler<KEY>) => {
+    channel: KEY;
+    listener: WebSocketHandler<KEY>;
+  };
+  processWebSocketMessage: (ws: WebSocket, channel: string, message: IpcMessage) => Promise<void> | undefined;
+  handlers: Record<string, WebSocketHandler<any>>;
+};
+//#endregion
+//#region src/handlers/shell.d.ts
+declare const registerShellHandlers: (_context: PipelabContext) => void;
+//#endregion
+//#region src/handlers/fs.d.ts
+declare const registerFsHandlers: (_context: PipelabContext) => void;
+//#endregion
+//#region src/handlers/config.d.ts
+declare const registerConfigHandlers: (context: PipelabContext) => void;
+//#endregion
+//#region src/handlers/history.d.ts
+declare const registerHistoryHandlers: (context: PipelabContext) => void;
+//#endregion
+//#region src/handlers/engine.d.ts
+declare const registerEngineHandlers: (context: PipelabContext) => void;
+//#endregion
+//#region src/handlers/agents.d.ts
+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;
+  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;
+    userDataPath: string;
+    disk: {
+      total: number;
+      free: number;
+      pipelab: number;
+      folders: Array<{
+        name: SandboxFolder;
+        label: string;
+        size: number;
+      }>;
+    };
+  }>;
+  private getAllPipelineFiles;
+  private parsePipelineIdFromFilename;
+}
+//#endregion
+//#region src/handlers/index.d.ts
+declare const registerAllHandlers: (options: {
+  version: string;
+  context: PipelabContext;
+}) => Promise<void>;
+//#endregion
+//#region src/config.d.ts
+declare const setupSettingsConfigFile: (context: PipelabContext) => Promise<{
+  setConfig: (config: {
+    theme: "light" | "dark";
+    version: "7.0.0";
+    locale: "en-US" | "fr-FR" | "pt-BR" | "zh-CN" | "es-ES" | "de-DE";
+    tours: {
+      dashboard: {
+        step: number;
+        completed: boolean;
+      };
+      editor: {
+        step: number;
+        completed: boolean;
+      };
+    };
+    agents: {
+      id: string;
+      name: string;
+      url: string;
+    }[];
+    plugins: {
+      name: string;
+      enabled: boolean;
+      description: string;
+    }[];
+    autosave: boolean;
+    cacheFolder?: string | undefined;
+    tempFolder?: string | undefined;
+  }) => Promise<boolean>;
+  getConfig: () => Promise<{
+    theme: "light" | "dark";
+    version: "7.0.0";
+    locale: "en-US" | "fr-FR" | "pt-BR" | "zh-CN" | "es-ES" | "de-DE";
+    tours: {
+      dashboard: {
+        step: number;
+        completed: boolean;
+      };
+      editor: {
+        step: number;
+        completed: boolean;
+      };
+    };
+    agents: {
+      id: string;
+      name: string;
+      url: string;
+    }[];
+    plugins: {
+      name: string;
+      enabled: boolean;
+      description: string;
+    }[];
+    autosave: boolean;
+    cacheFolder?: string | undefined;
+    tempFolder?: string | undefined;
+  }>;
+}>;
+declare const setupConnectionsConfigFile: (context: PipelabContext) => Promise<{
+  setConfig: (config: {
+    version: "1.0.0";
+    connections: ({
+      id: string;
+      name: string;
+      pluginName: string;
+      createdAt: string;
+      isDefault: boolean;
+    } & {
+      [key: string]: unknown;
+    })[];
+  }) => Promise<boolean>;
+  getConfig: () => Promise<{
+    version: "1.0.0";
+    connections: ({
+      id: string;
+      name: string;
+      pluginName: string;
+      createdAt: string;
+      isDefault: boolean;
+    } & {
+      [key: string]: unknown;
+    })[];
+  }>;
+}>;
+declare const setupProjectsConfigFile: (context: PipelabContext) => Promise<{
+  setConfig: (config: {
+    version: "3.0.0";
+    projects: {
+      id: string;
+      name: string;
+      description: string;
+    }[];
+    pipelines?: ({
+      type: "external";
+      id: string;
+      summary: {
+        name: string;
+        plugins: string[];
+        description: string;
+      };
+      project: string;
+      path: string;
+      lastModified: string;
+    } | {
+      type: "internal";
+      id: string;
+      project: string;
+      lastModified: string;
+      configName: string;
+    } | {
+      type: "pipelab-cloud";
+      id: string;
+      project: string;
+    })[] | undefined;
+  }) => Promise<boolean>;
+  getConfig: () => Promise<{
+    version: "3.0.0";
+    projects: {
+      id: string;
+      name: string;
+      description: string;
+    }[];
+    pipelines?: ({
+      type: "external";
+      id: string;
+      summary: {
+        name: string;
+        plugins: string[];
+        description: string;
+      };
+      project: string;
+      path: string;
+      lastModified: string;
+    } | {
+      type: "internal";
+      id: string;
+      project: string;
+      lastModified: string;
+      configName: string;
+    } | {
+      type: "pipelab-cloud";
+      id: string;
+      project: string;
+    })[] | undefined;
+  }>;
+}>;
+declare const setupPipelineConfigFileByName: (name: string, context: PipelabContext) => Promise<{
+  setConfig: (config: {
+    version: "5.0.0";
+    name: string;
+    description: string;
+    variables: _pipelab_shared0.VariableBase[];
+    canvas: {
+      blocks: {
+        type: "action";
+        params: {
+          [x: string]: {
+            editor: "editor" | "simple";
+            value: unknown;
+          };
+        };
+        uid: string;
+        origin: {
+          pluginId: string;
+          nodeId: string;
+          version?: string | undefined;
+        };
+        name?: string | undefined;
+        disabled?: boolean | undefined;
+      }[];
+      triggers: {
+        type: "event";
+        params: {
+          [x: string]: any;
+        };
+        uid: string;
+        origin: {
+          pluginId: string;
+          nodeId: string;
+          version?: string | undefined;
+        };
+      }[];
+    };
+  }) => Promise<boolean>;
+  getConfig: () => Promise<{
+    version: "5.0.0";
+    name: string;
+    description: string;
+    variables: _pipelab_shared0.VariableBase[];
+    canvas: {
+      blocks: {
+        type: "action";
+        params: {
+          [x: string]: {
+            editor: "editor" | "simple";
+            value: unknown;
+          };
+        };
+        uid: string;
+        origin: {
+          pluginId: string;
+          nodeId: string;
+          version?: string | undefined;
+        };
+        name?: string | undefined;
+        disabled?: boolean | undefined;
+      }[];
+      triggers: {
+        type: "event";
+        params: {
+          [x: string]: any;
+        };
+        uid: string;
+        origin: {
+          pluginId: string;
+          nodeId: string;
+          version?: string | undefined;
+        };
+      }[];
+    };
+  }>;
+}>;
+declare const setupPipelineConfigFileByPath: (absolutePath: string, context: PipelabContext) => Promise<{
+  setConfig: (config: {
+    version: "5.0.0";
+    name: string;
+    description: string;
+    variables: _pipelab_shared0.VariableBase[];
+    canvas: {
+      blocks: {
+        type: "action";
+        params: {
+          [x: string]: {
+            editor: "editor" | "simple";
+            value: unknown;
+          };
+        };
+        uid: string;
+        origin: {
+          pluginId: string;
+          nodeId: string;
+          version?: string | undefined;
+        };
+        name?: string | undefined;
+        disabled?: boolean | undefined;
+      }[];
+      triggers: {
+        type: "event";
+        params: {
+          [x: string]: any;
+        };
+        uid: string;
+        origin: {
+          pluginId: string;
+          nodeId: string;
+          version?: string | undefined;
+        };
+      }[];
+    };
+  }) => Promise<boolean>;
+  getConfig: () => Promise<{
+    version: "5.0.0";
+    name: string;
+    description: string;
+    variables: _pipelab_shared0.VariableBase[];
+    canvas: {
+      blocks: {
+        type: "action";
+        params: {
+          [x: string]: {
+            editor: "editor" | "simple";
+            value: unknown;
+          };
+        };
+        uid: string;
+        origin: {
+          pluginId: string;
+          nodeId: string;
+          version?: string | undefined;
+        };
+        name?: string | undefined;
+        disabled?: boolean | undefined;
+      }[];
+      triggers: {
+        type: "event";
+        params: {
+          [x: string]: any;
+        };
+        uid: string;
+        origin: {
+          pluginId: string;
+          nodeId: string;
+          version?: string | undefined;
+        };
+      }[];
+    };
+  }>;
+}>;
+declare const deletePipelineConfigFileByName: (name: string, context: PipelabContext) => Promise<void>;
+declare const deletePipelineConfigFileByPath: (absolutePath: string, context: PipelabContext) => Promise<void>;
+//#endregion
+//#region src/api.d.ts
+type HandleListenerRenderer<KEY extends RendererChannels> = (event: Electron.IpcMainInvokeEvent, data: {
+  value: RendererData<KEY>;
+  send: HandleListenerRendererSendFn<KEY>;
+}) => Promise<void>;
+type ListenerMain<KEY extends RendererChannels> = (event: Electron.IpcMainEvent, data: RendererEvents<KEY>) => Promise<void>;
+declare const usePluginAPI: (browserWindow: any) => {
+  send: <KEY extends RendererChannels>(channel: KEY, args?: RendererData<KEY>) => void;
+  on: <KEY extends RendererChannels>(channel: KEY | string, listener: (event: any, data: RendererEvents<KEY>) => void) => () => void;
+  execute: <KEY extends RendererChannels>(channel: KEY, data?: RendererData<KEY>, listener?: ListenerMain<KEY>) => Promise<RendererEnd<KEY>>;
+};
+type UseMainAPI = ReturnType<typeof usePluginAPI>;
+//#endregion
+//#region src/handler-func.d.ts
+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: () => RendererPluginDefinition[];
+declare const executeGraphWithHistory: ({
+  graph,
+  variables,
+  projectName,
+  projectPath,
+  pipelineId,
+  onNodeEnter,
+  onNodeExit,
+  onLog,
+  abortSignal,
+  mainWindow,
+  cachePath,
+  context
+}: {
+  graph: any;
+  variables: Variable[];
+  projectName: string;
+  projectPath: string;
+  pipelineId: string;
+  onNodeEnter?: (node: any) => void;
+  onNodeExit?: (node: any) => void;
+  onLog?: (data: any, node?: any) => void;
+  abortSignal: AbortSignal;
+  mainWindow?: any;
+  cachePath: string;
+  context: PipelabContext;
+}) => Promise<{
+  result: {
+    graph: Array<_pipelab_shared0.Block>;
+    definitions: Array<RendererPluginDefinition>;
+    variables: Array<Variable>;
+    steps: _pipelab_shared0.Steps;
+    context: _pipelab_shared0.Context;
+    onExecuteItem: (node: _pipelab_shared0.Block, params: Record<string, string>, steps: _pipelab_shared0.Steps) => Promise<_pipelab_shared0.End<"action:execute">>;
+    onNodeEnter: (node: _pipelab_shared0.Block) => void;
+    onNodeExit: (node: _pipelab_shared0.Block) => void;
+    abortSignal?: AbortSignal;
+  };
+  buildId: string;
+}>;
+//#endregion
+//#region src/plugins-registry.d.ts
+declare const loadPipelabPlugin: (id: string, options: {
+  context: PipelabContext;
+}) => Promise<any>;
+declare const loadCustomPlugin: (packageName: string, version: string, options: {
+  context: PipelabContext;
+}) => Promise<any>;
+declare function findInstalledPlugins(packagesDir: string): Promise<Array<{
+  name: string;
+  version: string;
+  packageDir: string;
+  description: string;
+}>>;
+declare const builtInPlugins: (options: {
+  context: PipelabContext;
+}) => Promise<void>;
+//#endregion
+//#region src/utils/remote.d.ts
+declare function isOnline(): Promise<boolean>;
+type FetchOptions = {
+  installDeps?: boolean;
+  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, options: FetchOptions): Promise<{
+  packageDir: string;
+  resolvedVersion: string;
+  isLocal?: boolean;
+  entryPoint?: string;
+}>;
+/**
+ * Executes a pnpm install in a specific directory with a portable environment.
+ */
+declare function runPnpm(cwd: string, options: {
+  args?: string[];
+  extraEnv?: Record<string, string>;
+  signal?: AbortSignal;
+  context: PipelabContext;
+}): Promise<execa.Result<{
+  cwd: string;
+  all: true;
+  cancelSignal: AbortSignal | undefined;
+  env: {
+    NODE_ENV: string;
+    PATH: string | undefined;
+    PNPM_HOME: "PNPM/";
+    PNPM_ONLY_ALLOW_TRUSTED_DEPENDENCIES: string;
+  };
+}>>;
+/**
+ * Installs a specific version of Node.js if not already present.
+ */
+declare function ensureNodeJS(context: PipelabContext, version?: string): 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, 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(versionOrRange: string, options: FetchOptions): Promise<{
+  packageDir: string;
+  entryPoint: string;
+  isLocal: boolean;
+}>;
+//#endregion
+//#region src/utils/fs-extras.d.ts
+/**
+ * Ensures a directory exists and a file is created with default content if missing.
+ */
+declare const ensure: (filesPath: string, defaultContent?: string) => Promise<void>;
+/**
+ * Extracts a .tar.gz archive.
+ */
+declare function extractTarGz(archivePath: string, destinationDir: string): Promise<void>;
+/**
+ * Extracts a .zip archive.
+ */
+declare function extractZip(archivePath: string, destinationDir: string): Promise<void>;
+/**
+ * Zips a folder.
+ */
+declare const zipFolder: (from: string, to: string, log?: typeof console.log, abortSignal?: AbortSignal) => Promise<string>;
+/**
+ * Downloads a file with progress tracking.
+ */
+interface DownloadHooks {
+  onProgress?: (data: {
+    progress: number;
+    downloadedSize: number;
+  }) => void;
+}
+declare const downloadFile: (url: string, localPath: string, hooks?: DownloadHooks, abortSignal?: AbortSignal) => Promise<void>;
+declare const runWithLiveLogs: (command: string, args: string[], execaOptions: Options$1, log: typeof console.log, hooks?: {
+  onStdout?: (data: string, subprocess: Subprocess) => void;
+  onStderr?: (data: string, subprocess: Subprocess) => void;
+  onExit?: (code: number) => void;
+  onCreated?: (subprocess: Subprocess) => void;
+}, abortSignal?: AbortSignal) => Promise<void>;
+/**
+ * Calculates the total size of a directory recursively.
+ */
+declare function getFolderSize(dirPath: string): Promise<number>;
+//#endregion
+//#region ../../node_modules/electron/electron.d.ts
+declare module 'electron' {
+  export = Electron.CrossProcessExports;
+}
+declare module 'electron/main' {
+  export = Electron.Main;
+}
+declare module 'electron/common' {
+  export = Electron.Common;
+}
+declare module 'electron/renderer' {
+  export = Electron.Renderer;
+}
+declare module 'electron/utility' {
+  export = Electron.Utility;
+}
+declare module 'original-fs' {
+  import * as fs from 'fs';
+  export = fs;
+}
+declare module 'node:original-fs' {
+  import * as fs from 'fs';
+  export = fs;
+}
+//#endregion
+//#region src/types/runner.d.ts
+type RunnerCallbackFnArgument = {
+  done: () => void;
+  id: string;
+  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; /** @deprecated Use `context` instead to resolve sandboxed folders and binary paths. */
+  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> = (data: ActionRunnerData<ACTION>) => Promise<void>;
+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"];
+  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"];
+  cwd: string;
+  context: PipelabContext;
+}) => Promise<void>;
+type Runner = ActionRunner<any> | EventRunner<any>;
+//#endregion
+//#region src/runner.d.ts
+interface RunOptions {
+  userData?: string;
+  variables?: string;
+  output?: string;
+  cloud?: boolean;
+}
+declare function runPipelineCommand(file: string, options: RunOptions, version: string): Promise<{
+  graph: Array<_pipelab_shared0.Block>;
+  definitions: Array<_pipelab_shared0.RendererPluginDefinition>;
+  variables: Array<_pipelab_shared0.Variable>;
+  steps: _pipelab_shared0.Steps;
+  context: _pipelab_shared0.Context;
+  onExecuteItem: (node: _pipelab_shared0.Block, params: Record<string, string>, steps: _pipelab_shared0.Steps) => Promise<_pipelab_shared0.End<"action:execute">>;
+  onNodeEnter: (node: _pipelab_shared0.Block) => void;
+  onNodeExit: (node: _pipelab_shared0.Block) => void;
+  abortSignal?: AbortSignal;
+}>;
+//#endregion
+//#region src/server.d.ts
+interface ServeOptions {
+  port: string | number;
+  userData?: string;
+  nodePath?: string;
+  pnpmPath?: string;
+}
+declare const sendStartupProgress: (message: string) => void;
+declare const sendStartupReady: () => void;
+declare function serveCommand(options: ServeOptions, version: string, _dirname: string): Promise<http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>>;
+//#endregion
+//#region src/utils/github.d.ts
+interface GitHubRelease {
+  tag_name: string;
+  prerelease: boolean;
+  published_at: string;
+  html_url: string;
+  assets: Array<{
+    name: string;
+    browser_download_url: string;
+  }>;
+}
+interface FetchReleaseOptions {
+  repo?: string;
+  allowPrerelease?: boolean;
+}
+/**
+ * Fetches all releases for a specific package from GitHub.
+ * Tags are expected to follow the pattern "{packageName}@{version}"
+ */
+declare function fetchPackageReleases(packageName: string, options?: FetchReleaseOptions): Promise<GitHubRelease[]>;
+/**
+ * Fetches the latest release for a specific package.
+ * Supports PIPELAB_OVERRIDE_RELEASE environment variable.
+ */
+declare function fetchLatestPackageRelease(packageName: string, options?: FetchReleaseOptions): Promise<GitHubRelease | null>;
+/**
+ * Fetches all releases from GitHub and finds the latest one that matches the Pipelab Desktop app tag.
+ * This ensures we don't accidentally pick a package release (e.g. @pipelab/shared) as the "latest".
+ */
+declare function fetchLatestDesktopRelease(options?: FetchReleaseOptions): Promise<GitHubRelease | null>;
+//#endregion
+//#region src/fs-utils.d.ts
+/**
+ * Checks if a path matches a critical user or system directory.
+ */
+declare function isPathBlacklisted(pathToCheck: string): boolean;
+//#endregion
+export { type Action, ActionRunner, ActionRunnerData, BuildHistoryStorage, CacheFolder, CacheFolderType, ConnectedClient, DownloadHooks, type Event$1 as Event, EventRunner, type Expression, ExpressionRunner, type ExtractInputsFromAction, type ExtractInputsFromEvent, type ExtractInputsFromExpression, FetchOptions, FetchReleaseOptions, GitHubRelease, HandleListener, HandleListenerRenderer, type HandleListenerRendererSendFn, HandleListenerSendFn, ListenerMain, PipelabContext, PipelabContextOptions, PipelabEnv, type RendererChannels, type RendererData, type RendererEnd, type RendererEvents, type RendererMessage, type RequestId, RunOptions, Runner, RunnerCallbackFnArgument, ServeOptions, type SetOutputActionFn, type SetOutputExpressionFn, type UpdateStatus, UseMainAPI, WebSocketServer, WsEvent, builtInPlugins, deletePipelineConfigFileByName, deletePipelineConfigFileByPath, downloadFile, ensure, ensureNodeJS, ensurePNPM, executeGraphWithHistory, extractTarGz, extractZip, fetchLatestDesktopRelease, fetchLatestPackageRelease, fetchPackage, fetchPackageReleases, fetchPipelabAsset, fetchPipelabCli, fetchPipelabPlugin, findInstalledPlugins, getDefaultUserDataPath, getFinalPlugins, getFolderSize, handleActionExecute, isDev, isOnline, isPathBlacklisted, loadCustomPlugin, loadPipelabPlugin, projectRoot, registerAgentsHandlers, registerAllHandlers, registerConfigHandlers, registerEngineHandlers, registerFsHandlers, registerHistoryHandlers, registerShellHandlers, runPipelineCommand, runPnpm, runWithLiveLogs, sendStartupProgress, sendStartupReady, serveCommand, setupConnectionsConfigFile, setupPipelineConfigFileByName, setupPipelineConfigFileByPath, setupProjectsConfigFile, setupSettingsConfigFile, useAPI, usePluginAPI, webSocketServer, zipFolder };
+//# sourceMappingURL=index.d.cts.map