@pipelab/plugin-core 1.0.1-beta.9 → 1.0.1-latest.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipelab/plugin-core",
-  "version": "1.0.1-beta.9",
+  "version": "1.0.1-latest.30",
   "description": "Core library for building Pipelab plugins",
   "license": "FSL-1.1-MIT",
   "author": "CynToolkit",
@@ -34,7 +34,8 @@
     "tar": "6.2.1",
     "type-fest": "4.26.1",
     "yauzl": "2.10.0",
-    "zod": "4.3.6"
+    "zod": "4.3.6",
+    "@pipelab/core-node": "1.0.1-latest.34"
   },
   "devDependencies": {
     "@types/archiver": "7.0.0",
@@ -43,9 +44,9 @@
     "@types/yauzl": "2.10.3",
     "tsdown": "0.21.2",
     "typescript": "5.9.3",
-    "@pipelab/constants": "1.0.1-beta.10",
-    "@pipelab/shared": "2.0.1-beta.11",
-    "@pipelab/tsconfig": "1.0.1-beta.10"
+    "@pipelab/constants": "1.0.1-latest.30",
+    "@pipelab/shared": "2.0.1-latest.31",
+    "@pipelab/tsconfig": "1.0.1-latest.30"
   },
   "scripts": {
     "build": "tsdown",

package/src/pipelab.ts

@@ -16,87 +16,79 @@ import type {
 } from "@pipelab/shared";
 
 export * from "@pipelab/shared";
+import {
+  type RunnerCallbackFnArgument,
+  type ActionRunnerData,
+  type ActionRunner,
+  type ConditionRunner,
+  type LoopRunner,
+  type ExpressionRunner,
+  type EventRunner,
+  type Runner,
+  PipelabContext,
+} from "@pipelab/core-node";
 
-export type RunnerCallbackFnArgument = {
-  done: () => void;
-  id: string;
-  log: (...args: Parameters<(typeof console)["log"]>) => void;
+export {
+  type RunnerCallbackFnArgument,
+  type ActionRunnerData,
+  type ActionRunner,
+  type ConditionRunner,
+  type LoopRunner,
+  type ExpressionRunner,
+  type EventRunner,
+  type Runner,
+  PipelabContext,
 };
 
-export 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: {
-    assets: string;
-    cache: string;
-    pnpm: string;
-    node: string;
-    userData: string;
-    modules: string;
-    thirdparty: string;
-  };
-  api: {
-    fetchAsset: (packageName: string, version?: string) => Promise<string>;
-    [key: string]: any;
-  };
-  browserWindow: BrowserWindow;
-  abortSignal: AbortSignal;
-};
-
-export type ActionRunner<ACTION extends Action> = (data: ActionRunnerData<ACTION>) => Promise<void>;
-export const createActionRunner = <ACTION extends Action>(runner: ActionRunner<ACTION>) => runner;
-
-// ---
+export const createActionRunner = <ACTION extends Action>(
+  runner: (data: ActionRunnerData<ACTION>) => Promise<void>,
+) => runner;
 
-export type ConditionRunner<CONDITION extends Condition> = (data: {
-  log: typeof console.log;
-  inputs: ExtractInputsFromCondition<CONDITION>;
-  setMeta: (callback: (data: CONDITION["meta"]) => CONDITION["meta"]) => void;
-  meta: CONDITION["meta"];
-  cwd: string;
-}) => Promise<boolean>;
 export const createConditionRunner = <CONDITION extends Condition>(
-  runner: ConditionRunner<CONDITION>,
+  runner: (data: {
+    log: typeof console.log;
+    inputs: ExtractInputsFromCondition<CONDITION>;
+    setMeta: (callback: (data: CONDITION["meta"]) => CONDITION["meta"]) => void;
+    meta: CONDITION["meta"];
+    cwd: string;
+    context: PipelabContext;
+  }) => Promise<boolean>,
 ) => runner;
 
-// ---
-
-export 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"];
-  cwd: string;
-}) => Promise<"step" | "exit">;
-export const createLoopRunner = <LOOP extends Loop>(runner: LoopRunner<LOOP>) => runner;
+export const createLoopRunner = <LOOP extends Loop>(
+  runner: (data: {
+    log: typeof console.log;
+    setOutput: SetOutputLoopFn<LOOP>;
+    inputs: ExtractInputsFromLoop<LOOP>;
+    setMeta: (callback: (data: LOOP["meta"]) => LOOP["meta"]) => void;
+    meta: LOOP["meta"];
+    cwd: string;
+    context: PipelabContext;
+  }) => Promise<"step" | "exit">,
+) => runner;
 
-export 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;
-}) => Promise<string>;
 export const createExpressionRunner = <EXPRESSION extends Expression>(
-  runner: ExpressionRunner<EXPRESSION>,
+  runner: (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>,
 ) => runner;
 
-export type EventRunner<EVENT extends Event> = (data: {
-  log: typeof console.log;
-  inputs: ExtractInputsFromEvent<EVENT>;
-  setMeta: (callback: (data: EVENT["meta"]) => EVENT["meta"]) => void;
-  meta: EVENT["meta"];
-  cwd: string;
-}) => Promise<void>;
-export const createEventRunner = <EVENT extends Event>(runner: EventRunner<EVENT>) => runner;
-
-export type Runner = ActionRunner<any> | LoopRunner<any> | EventRunner<any> | ConditionRunner<any>;
+export const createEventRunner = <EVENT extends Event>(
+  runner: (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>,
+) => runner;
 
 export const sleep = (duration: number) => {
   return new Promise((resolve) => setTimeout(resolve, duration));

package/src/utils.ts

@@ -1,176 +1,26 @@
-import { execa, Options, Subprocess } from "execa";
-import { ExternalCommandError } from "./custom-errors.js";
-import { join } from "node:path";
-import { access, mkdir, writeFile, rm } from "node:fs/promises";
-import { createWriteStream } from "node:fs";
-import { pipeline } from "node:stream/promises";
-import pacote from "pacote";
+import { Options, Subprocess } from "execa";
+export {
+  fetchPackage,
+  fetchPipelabAsset,
+  fetchPipelabPlugin,
+  fetchPipelabCli,
+  runPnpm,
+  downloadFile,
+  runWithLiveLogs,
+} from "@pipelab/core-node";
 
+/**
+ * Re-exporting hooks type for backward compatibility
+ */
+export type { DownloadHooks as Hooks } from "@pipelab/core-node";
+
+// Keep runtime-only utilities that don't depend on complex engine state
 export const fileExists = async (path: string): Promise<boolean> => {
   try {
+    const { access } = await import("node:fs/promises");
     await access(path);
     return true;
   } catch {
     return false;
   }
 };
-
-export const runWithLiveLogs = async (
-  command: string,
-  args: string[],
-  execaOptions: Options,
-  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> => {
-  console.log("command: ", command, args.join(" "));
-
-  const subprocess = execa(command, args, {
-    ...execaOptions,
-    stdout: "pipe",
-    stderr: "pipe",
-    stdin: "pipe",
-    env: {
-      ...process.env,
-      ...execaOptions.env,
-      TERM: "xterm-256color",
-      FORCE_STDERR_LOGGING: "1",
-    },
-    cancelSignal: abortSignal,
-  });
-
-  hooks?.onCreated?.(subprocess);
-
-  subprocess.stdout?.on("data", (data: Buffer) => {
-    hooks?.onStdout?.(data.toString(), subprocess);
-  });
-
-  subprocess.stderr?.on("data", (data: Buffer) => {
-    hooks?.onStderr?.(data.toString(), subprocess);
-  });
-
-  try {
-    const { exitCode } = await subprocess;
-    hooks?.onExit?.(exitCode ?? 0);
-  } catch (error: any) {
-    const code = error.exitCode ?? 1;
-    hooks?.onExit?.(code);
-    throw new ExternalCommandError(error.message, code);
-  }
-};
-
-export interface Hooks {
-  onProgress?: (data: { progress: number; downloadedSize: number }) => void;
-}
-
-/**
- * Downloads a file from a given URL to a specified local path with progress tracking.
- *
- * @param url - The URL of the file to download.
- * @param localPath - The local file path to save the downloaded file.
- * @returns A promise that resolves when the file is downloaded.
- */
-export const downloadFile = async (
-  url: string,
-  localPath: string,
-  hooks?: Hooks,
-  abortSignal?: AbortSignal,
-): Promise<void> => {
-  // Fetch the resource
-  const response = await fetch(url, {
-    signal: abortSignal,
-  });
-
-  // Check if the fetch was successful
-  if (!response.ok) {
-    throw new Error(`Failed to fetch file: ${response.statusText}`);
-  }
-
-  // Get the total size of the file
-  const contentLength = response.headers.get("content-length");
-  if (!contentLength) {
-    throw new Error("Content-Length header is missing");
-  }
-  const totalSize = parseInt(contentLength, 10);
-
-  // Track progress
-  let downloadedSize = 0;
-  const fileStream = createWriteStream(localPath);
-
-  // Create a readable stream to monitor progress
-  const progressStream = new TransformStream({
-    transform(chunk, controller) {
-      downloadedSize += chunk.length;
-      const progress = (downloadedSize / totalSize) * 100;
-      if (hooks?.onProgress) {
-        hooks.onProgress({
-          progress,
-          downloadedSize,
-        });
-      }
-      controller.enqueue(chunk);
-    },
-  });
-
-  // Pipe the response through the progress tracker and into the file
-  const readable = response.body?.pipeThrough(progressStream);
-  if (!readable) {
-    throw new Error("Failed to create a readable stream");
-  }
-
-  await pipeline(readable, fileStream);
-};
-
-/**
- * Installs an NPM package from the npm registry as a tarball if not already present.
- * @param thirdpartyDir The directory where third-party tools are stored.
- * @param name The name of the package (e.g., 'pnpm' or '@poki/cli').
- * @param version The version of the package.
- * @param options (Optional) configuration for dependency installation.
- * @returns A Promise that resolves to the path of the extracted package (the 'package' subfolder).
- */
-export const ensureNPMPackage = async (
-  thirdpartyDir: string,
-  name: string,
-  version: string,
-  options?: {
-    nodePath?: string;
-    pnpmPath?: string;
-    installDeps?: boolean;
-  },
-) => {
-  const packageDir = join(thirdpartyDir, name, version);
-  const finalPath = join(packageDir, "package");
-
-  // 1. Check if already installed
-  if (await fileExists(finalPath)) {
-    return finalPath;
-  }
-  console.log(`NPM package ${name}@${version} not found at ${finalPath}, installing...`);
-
-  // 2. Extract using pacote
-  console.log(`Extracting ${name}@${version} to ${finalPath}...`);
-  await mkdir(packageDir, { recursive: true });
-  await pacote.extract(`${name}@${version}`, finalPath);
-
-  // 3. Install dependencies if requested
-  if (options?.installDeps && options.pnpmPath) {
-    console.log(
-      `Installing dependencies for ${name}@${version} using pnpm at ${options.pnpmPath}...`,
-    );
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    // We use the pnpm .cjs bundle directly with node
-    const node = options.nodePath || process.execPath;
-    await execa(node, [options.pnpmPath, "install", "--prod"], {
-      cwd: finalPath,
-      stdio: "inherit",
-    });
-  }
-
-  return finalPath;
-};