@pipelab/test-utils 1.0.0-beta.28 → 1.0.0-beta.32

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # @pipelab/test-utils
 
+## 1.0.0-beta.32
+
+### Patch Changes
+
+- sd
+- Updated dependencies
+  - @pipelab/plugin-core@1.0.0-beta.32
+
+## 1.0.0-beta.31
+
+### Patch Changes
+
+- sdsd
+- Updated dependencies
+  - @pipelab/plugin-core@1.0.0-beta.31
+
+## 1.0.0-beta.30
+
+### Patch Changes
+
+- sd
+- Updated dependencies
+  - @pipelab/plugin-core@1.0.0-beta.30
+
+## 1.0.0-beta.29
+
+### Patch Changes
+
+- sd
+- Updated dependencies
+  - @pipelab/plugin-core@1.0.0-beta.29
+
 ## 1.0.0-beta.28
 
 ### Patch Changes

package/dist/index.cjs

@@ -0,0 +1,150 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let node_path = require("node:path");
+let node_url = require("node:url");
+let node_fs_promises = require("node:fs/promises");
+let node_fs = require("node:fs");
+let node_os = require("node:os");
+let _pipelab_plugin_core = require("@pipelab/plugin-core");
+let execa = require("execa");
+//#region src/index.ts
+const __dirname$1 = (0, node_path.dirname)((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+/**
+* Finds the monorepo root by looking for pnpm-workspace.yaml.
+*/
+function findProjectRoot(startDir) {
+	let curr = startDir;
+	while (curr !== (0, node_path.dirname)(curr)) {
+		if ((0, node_fs.existsSync)((0, node_path.join)(curr, "pnpm-workspace.yaml"))) return curr;
+		curr = (0, node_path.dirname)(curr);
+	}
+	throw new Error("Could not find project root (pnpm-workspace.yaml)");
+}
+const isWindows = process.platform === "win32";
+const isMac = process.platform === "darwin";
+const isLinux = process.platform === "linux";
+/**
+* Creates a unique sandbox directory and returns a bundle containing its path
+* and a pre-filled remove utility.
+*/
+const createSandbox = async (prefix) => {
+	const sandboxPath = (0, node_path.join)((0, node_os.tmpdir)(), `${prefix}-${Math.random().toString(36).substring(7)}`);
+	const paths = {
+		input: (0, node_path.join)(sandboxPath, "input"),
+		output: (0, node_path.join)(sandboxPath, "output"),
+		userData: (0, node_path.join)(sandboxPath, "user-data"),
+		project: (0, node_path.join)(sandboxPath, "project"),
+		thirdparty: (0, node_path.join)(sandboxPath, "thirdparty")
+	};
+	await (0, node_fs_promises.mkdir)(sandboxPath, { recursive: true });
+	await Promise.all([
+		(0, node_fs_promises.mkdir)(paths.input, { recursive: true }),
+		(0, node_fs_promises.mkdir)(paths.output, { recursive: true }),
+		(0, node_fs_promises.mkdir)(paths.userData, { recursive: true })
+	]);
+	return {
+		path: sandboxPath,
+		paths,
+		mockBinary: async (relativePath, content, options = {}) => {
+			const fullPath = (0, node_path.join)(sandboxPath, relativePath);
+			let platformPath = fullPath;
+			if (options.extension === false) {} else if (options.extension) platformPath = `${fullPath}.${options.extension}`;
+			else platformPath = /\.[a-z0-9]+$/i.test(relativePath) ? fullPath : isWindows ? `${fullPath}.cmd` : `${fullPath}.sh`;
+			const defaultContent = isWindows ? `@echo off\necho Mock Binary Execution: %*\nexit /b 0` : `#!/bin/bash\necho "Mock Binary Execution: $@"\nexit 0`;
+			await (0, node_fs_promises.mkdir)((0, node_path.dirname)(platformPath), { recursive: true });
+			await (0, node_fs_promises.writeFile)(platformPath, content || defaultContent);
+			if (!isWindows) await (0, node_fs_promises.chmod)(platformPath, 493);
+			return platformPath;
+		},
+		remove: async () => {
+			await (0, node_fs_promises.rm)(sandboxPath, {
+				recursive: true,
+				force: true,
+				maxRetries: 20,
+				retryDelay: 500
+			});
+		}
+	};
+};
+/**
+* Runs the Pipelab CLI out-of-process.
+*/
+const runCLI = async (args, options = {}) => {
+	const projectRoot = findProjectRoot(__dirname$1);
+	return (0, execa.execa)("tsx", [(0, node_path.resolve)(projectRoot, "apps/cli/src/index.ts"), ...args], {
+		cwd: options.cwd || projectRoot,
+		env: {
+			...process.env,
+			PIPELAB_DISABLE_HISTORY: "true",
+			...options.env
+		}
+	});
+};
+/**
+* Runs a Pipelab action runner directly in-process for focused testing.
+*/
+const runAction = async (runner, options) => {
+	const outputs = {};
+	const pnpmShimPath = (0, node_path.join)(options.sandboxPath, "pnpm-shim.cjs");
+	await (0, node_fs_promises.writeFile)(pnpmShimPath, `const { spawnSync } = require('child_process');
+const result = spawnSync('pnpm', process.argv.slice(2), { stdio: 'inherit', shell: true });
+process.exit(result.status ?? 0);`);
+	const context = {
+		inputs: options.inputs,
+		log: (...args) => {
+			console.log("[Runner Log]", ...args);
+		},
+		setOutput: (key, value) => {
+			console.log(`[Runner Output] ${key} = ${value}`);
+			outputs[key] = value;
+		},
+		cwd: options.sandboxPath,
+		paths: {
+			cache: (0, node_path.join)(options.sandboxPath, "cache"),
+			pnpm: pnpmShimPath,
+			node: process.execPath,
+			userData: (0, node_path.join)(options.sandboxPath, "user-data"),
+			modules: (0, node_path.join)(options.sandboxPath, "modules"),
+			thirdparty: (0, node_path.join)(options.sandboxPath, "thirdparty")
+		},
+		api: { fetchAsset: async (packageName) => {
+			const sandboxAssetPath = (0, node_path.join)(options.sandboxPath, "assets", packageName);
+			if ((0, node_fs.existsSync)(sandboxAssetPath)) return sandboxAssetPath;
+			const folderName = packageName.startsWith("@pipelab/") ? packageName.replace("@pipelab/", "") : packageName;
+			return (0, node_path.join)(findProjectRoot(__dirname$1), "assets", folderName);
+		} },
+		browserWindow: void 0,
+		abortSignal: new AbortController().signal,
+		context: new _pipelab_plugin_core.PipelabContext({ userDataPath: (0, node_path.join)(options.sandboxPath, "user-data") }),
+		setMeta: () => {},
+		meta: {}
+	};
+	const originalEnv = { ...process.env };
+	if (options.extraEnv) Object.assign(process.env, options.extraEnv);
+	try {
+		await runner(context);
+	} finally {
+		if (options.extraEnv) {
+			for (const key in options.extraEnv) if (!(key in originalEnv)) delete process.env[key];
+			Object.assign(process.env, originalEnv);
+		}
+	}
+	return { outputs };
+};
+/**
+* Runs the packaged electron app (smoke test)
+*/
+const runElectronApp = async (app_path, options = {}) => {
+	return (0, execa.execa)(app_path, [], {
+		cleanup: true,
+		timeout: options.timeoutMs || 12e4
+	});
+};
+//#endregion
+exports.createSandbox = createSandbox;
+exports.findProjectRoot = findProjectRoot;
+exports.isLinux = isLinux;
+exports.isMac = isMac;
+exports.isWindows = isWindows;
+exports.runAction = runAction;
+exports.runCLI = runCLI;
+exports.runElectronApp = runElectronApp;

package/dist/index.d.cts

@@ -0,0 +1,66 @@
+import * as execa from "execa";
+import { Action, ActionRunner, ActionRunnerData } from "@pipelab/plugin-core";
+
+//#region src/index.d.ts
+/**
+ * Finds the monorepo root by looking for pnpm-workspace.yaml.
+ */
+declare function findProjectRoot(startDir: string): string;
+declare const isWindows: boolean;
+declare const isMac: boolean;
+declare const isLinux: boolean;
+/**
+ * Creates a unique sandbox directory and returns a bundle containing its path
+ * and a pre-filled remove utility.
+ */
+declare const createSandbox: (prefix: string) => Promise<{
+  path: string;
+  paths: {
+    input: string;
+    output: string;
+    userData: string;
+    project: string;
+    thirdparty: string;
+  };
+  /**
+   * Creates a mock binary/script in the sandbox.
+   */
+  mockBinary: (relativePath: string, content?: string, options?: {
+    extension?: string | false;
+  }) => Promise<string>;
+  remove: () => Promise<void>;
+}>;
+/**
+ * Runs the Pipelab CLI out-of-process.
+ */
+declare const runCLI: (args: string[], options?: {
+  cwd?: string;
+  env?: Record<string, string>;
+}) => Promise<execa.Result<{
+  cwd: string;
+  env: {
+    PIPELAB_DISABLE_HISTORY: string;
+  };
+}>>;
+/**
+ * Runs a Pipelab action runner directly in-process for focused testing.
+ */
+declare const runAction: <A extends Action>(runner: ActionRunner<A>, options: {
+  inputs: ActionRunnerData<A>["inputs"];
+  sandboxPath: string;
+  extraEnv?: Record<string, string>;
+}) => Promise<{
+  outputs: Record<string, unknown>;
+}>;
+/**
+ * Runs the packaged electron app (smoke test)
+ */
+declare const runElectronApp: (app_path: string, options?: {
+  timeoutMs?: number;
+}) => Promise<execa.Result<{
+  cleanup: true;
+  timeout: number;
+}>>;
+//#endregion
+export { createSandbox, findProjectRoot, isLinux, isMac, isWindows, runAction, runCLI, runElectronApp };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;iBAmBgB,eAAA,CAAgB,QAAA;AAAA,cAWnB,SAAA;AAAA,cACA,KAAA;AAAA,cACA,OAAA;;AAFb;;;cAQa,aAAA,GAAuB,MAAA,aAAc,OAAA;;;;;;;;;;;;qCAyBxB,OAAA,WACJ,OAAA;IACL,SAAA;EAAA,MAA4B,OAAA;;;;;;cAyChC,MAAA,GACX,IAAA,YACA,OAAA;EACE,GAAA;EACA,GAAA,GAAM,MAAA;AAAA,MACF,OAAA,CADQ,KAAA,CACR,MAAA;;;;;;;;;cAkBK,SAAA,aAA6B,MAAA,EACxC,MAAA,EAAQ,YAAA,CAAa,CAAA,GACrB,OAAA;EACE,MAAA,EAAQ,gBAAA,CAAiB,CAAA;EACzB,WAAA;EACA,QAAA,GAAW,MAAA;AAAA,MAEZ,OAAA;EAAU,OAAA,EAAS,MAAA;AAAA;AA9BtB;;;AAAA,cAmHa,cAAA,GAAwB,QAAA,UAAkB,OAAA;EAAW,SAAA;AAAA,MAAyB,OAAA,CAM1F,KAAA,CAN0F,MAAA"}

package/dist/index.d.mts

@@ -62,4 +62,5 @@ declare const runElectronApp: (app_path: string, options?: {
   timeout: number;
 }>>;
 //#endregion
-export { createSandbox, findProjectRoot, isLinux, isMac, isWindows, runAction, runCLI, runElectronApp };
+export { createSandbox, findProjectRoot, isLinux, isMac, isWindows, runAction, runCLI, runElectronApp };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;iBAmBgB,eAAA,CAAgB,QAAA;AAAA,cAWnB,SAAA;AAAA,cACA,KAAA;AAAA,cACA,OAAA;;AAFb;;;cAQa,aAAA,GAAuB,MAAA,aAAc,OAAA;;;;;;;;;;;;qCAyBxB,OAAA,WACJ,OAAA;IACL,SAAA;EAAA,MAA4B,OAAA;;;;;;cAyChC,MAAA,GACX,IAAA,YACA,OAAA;EACE,GAAA;EACA,GAAA,GAAM,MAAA;AAAA,MACF,OAAA,CADQ,OAAA,CACR,MAAA;;;;;;;;;cAkBK,SAAA,aAA6B,MAAA,EACxC,MAAA,EAAQ,YAAA,CAAa,CAAA,GACrB,OAAA;EACE,MAAA,EAAQ,gBAAA,CAAiB,CAAA;EACzB,WAAA;EACA,QAAA,GAAW,MAAA;AAAA,MAEZ,OAAA;EAAU,OAAA,EAAS,MAAA;AAAA;AA9BtB;;;AAAA,cAmHa,cAAA,GAAwB,QAAA,UAAkB,OAAA;EAAW,SAAA;AAAA,MAAyB,OAAA,CAM1F,OAAA,CAN0F,MAAA"}

package/dist/index.mjs

@@ -98,7 +98,6 @@ process.exit(result.status ?? 0);`);
 		},
 		cwd: options.sandboxPath,
 		paths: {
-			assets: join(options.sandboxPath, "assets"),
 			cache: join(options.sandboxPath, "cache"),
 			pnpm: pnpmShimPath,
 			node: process.execPath,
@@ -141,3 +140,5 @@ const runElectronApp = async (app_path, options = {}) => {
 };
 //#endregion
 export { createSandbox, findProjectRoot, isLinux, isMac, isWindows, runAction, runCLI, runElectronApp };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["existsSyncSync"],"sources":["../src/index.ts"],"sourcesContent":["import { resolve, dirname, join } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { mkdir, writeFile, chmod, rm } from \"node:fs/promises\";\nimport { existsSync as existsSyncSync } from \"node:fs\";\nimport { tmpdir } from \"node:os\";\nimport {\n  type ActionRunner,\n  type ActionRunnerData,\n  type Action,\n  PipelabContext,\n} from \"@pipelab/plugin-core\";\nimport { execa } from \"execa\";\n\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = dirname(__filename);\n\n/**\n * Finds the monorepo root by looking for pnpm-workspace.yaml.\n */\nexport function findProjectRoot(startDir: string): string {\n  let curr = startDir;\n  while (curr !== dirname(curr)) {\n    if (existsSyncSync(join(curr, \"pnpm-workspace.yaml\"))) {\n      return curr;\n    }\n    curr = dirname(curr);\n  }\n  throw new Error(\"Could not find project root (pnpm-workspace.yaml)\");\n}\n\nexport const isWindows = process.platform === \"win32\";\nexport const isMac = process.platform === \"darwin\";\nexport const isLinux = process.platform === \"linux\";\n\n/**\n * Creates a unique sandbox directory and returns a bundle containing its path\n * and a pre-filled remove utility.\n */\nexport const createSandbox = async (prefix: string) => {\n  const sandboxPath = join(tmpdir(), `${prefix}-${Math.random().toString(36).substring(7)}`);\n\n  const paths = {\n    input: join(sandboxPath, \"input\"),\n    output: join(sandboxPath, \"output\"),\n    userData: join(sandboxPath, \"user-data\"),\n    project: join(sandboxPath, \"project\"),\n    thirdparty: join(sandboxPath, \"thirdparty\"),\n  };\n\n  await mkdir(sandboxPath, { recursive: true });\n  await Promise.all([\n    mkdir(paths.input, { recursive: true }),\n    mkdir(paths.output, { recursive: true }),\n    mkdir(paths.userData, { recursive: true }),\n  ]);\n\n  return {\n    path: sandboxPath,\n    paths,\n    /**\n     * Creates a mock binary/script in the sandbox.\n     */\n    mockBinary: async (\n      relativePath: string,\n      content?: string,\n      options: { extension?: string | false } = {},\n    ) => {\n      const fullPath = join(sandboxPath, relativePath);\n      let platformPath = fullPath;\n\n      if (options.extension === false) {\n        // Use exactly the path provided\n      } else if (options.extension) {\n        platformPath = `${fullPath}.${options.extension}`;\n      } else {\n        const hasExtension = /\\.[a-z0-9]+$/i.test(relativePath);\n        platformPath = hasExtension ? fullPath : isWindows ? `${fullPath}.cmd` : `${fullPath}.sh`;\n      }\n\n      const defaultContent = isWindows\n        ? `@echo off\\necho Mock Binary Execution: %*\\nexit /b 0`\n        : `#!/bin/bash\\necho \"Mock Binary Execution: $@\"\\nexit 0`;\n\n      await mkdir(dirname(platformPath), { recursive: true });\n      await writeFile(platformPath, content || defaultContent);\n\n      if (!isWindows) {\n        await chmod(platformPath, 0o755);\n      }\n\n      return platformPath;\n    },\n    remove: async () => {\n      await rm(sandboxPath, {\n        recursive: true,\n        force: true,\n        maxRetries: 20,\n        retryDelay: 500,\n      });\n    },\n  };\n};\n\n/**\n * Runs the Pipelab CLI out-of-process.\n */\nexport const runCLI = async (\n  args: string[],\n  options: {\n    cwd?: string;\n    env?: Record<string, string>;\n  } = {},\n) => {\n  const projectRoot = findProjectRoot(__dirname);\n  const cliPath = resolve(projectRoot, \"apps/cli/src/index.ts\");\n\n  return execa(\"tsx\", [cliPath, ...args], {\n    cwd: options.cwd || projectRoot,\n    env: {\n      ...process.env,\n      PIPELAB_DISABLE_HISTORY: \"true\",\n      ...options.env,\n    },\n  });\n};\n\n/**\n * Runs a Pipelab action runner directly in-process for focused testing.\n */\nexport const runAction = async <A extends Action>(\n  runner: ActionRunner<A>,\n  options: {\n    inputs: ActionRunnerData<A>[\"inputs\"];\n    sandboxPath: string;\n    extraEnv?: Record<string, string>;\n  },\n): Promise<{ outputs: Record<string, unknown> }> => {\n  const outputs: Record<string, unknown> = {};\n\n  // Create a pnpm shim because ensureNPMPackage expects a JS file runnable by node\n  const pnpmShimPath = join(options.sandboxPath, \"pnpm-shim.cjs\");\n  await writeFile(\n    pnpmShimPath,\n    `const { spawnSync } = require('child_process');\nconst result = spawnSync('pnpm', process.argv.slice(2), { stdio: 'inherit', shell: true });\nprocess.exit(result.status ?? 0);`,\n  );\n\n  const context: ActionRunnerData<A> = {\n    inputs: options.inputs,\n    log: (...args: any[]) => {\n      console.log(\"[Runner Log]\", ...args);\n    },\n    setOutput: (key: any, value: any) => {\n      console.log(`[Runner Output] ${key} = ${value}`);\n      outputs[key] = value;\n    },\n    cwd: options.sandboxPath,\n    paths: {\n      cache: join(options.sandboxPath, \"cache\"),\n      pnpm: pnpmShimPath,\n      node: process.execPath,\n      userData: join(options.sandboxPath, \"user-data\"),\n      modules: join(options.sandboxPath, \"modules\"),\n      thirdparty: join(options.sandboxPath, \"thirdparty\"),\n    },\n    api: {\n      fetchAsset: async (packageName: string) => {\n        const sandboxAssetPath = join(options.sandboxPath, \"assets\", packageName);\n        if (existsSyncSync(sandboxAssetPath)) {\n          return sandboxAssetPath;\n        }\n        // Fallback to real monorepo assets\n        // Normalize: remove @pipelab/ prefix if present\n        const folderName = packageName.startsWith(\"@pipelab/\")\n          ? packageName.replace(\"@pipelab/\", \"\")\n          : packageName;\n\n        const projectRoot = findProjectRoot(__dirname);\n        return join(projectRoot, \"assets\", folderName);\n      },\n    },\n    // @ts-ignore - Mocking BrowserWindow\n    browserWindow: undefined,\n    abortSignal: new AbortController().signal,\n    context: new PipelabContext({\n      userDataPath: join(options.sandboxPath, \"user-data\"),\n    }),\n    // @ts-ignore - Mocking setMeta\n    setMeta: () => {},\n    meta: {} as any,\n  };\n\n  // Set environment variables for the test if provided\n  const originalEnv = { ...process.env };\n  if (options.extraEnv) {\n    Object.assign(process.env, options.extraEnv);\n  }\n\n  try {\n    await runner(context);\n  } finally {\n    // Restore original environment\n    if (options.extraEnv) {\n      // Remove keys that were added\n      for (const key in options.extraEnv) {\n        if (!(key in originalEnv)) {\n          delete process.env[key];\n        }\n      }\n      // Restore original values\n      Object.assign(process.env, originalEnv);\n    }\n  }\n\n  return { outputs };\n};\n\n/**\n * Runs the packaged electron app (smoke test)\n */\nexport const runElectronApp = async (app_path: string, options: { timeoutMs?: number } = {}) => {\n  const child = execa(app_path, [], {\n    cleanup: true,\n    timeout: options.timeoutMs || 120000,\n  });\n  return child;\n};\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipelab/test-utils",
-  "version": "1.0.0-beta.28",
+  "version": "1.0.0-beta.32",
   "private": false,
   "description": "Testing utilities for Pipelab plugins and monorepo",
   "license": "FSL-1.1-MIT",
@@ -27,17 +27,18 @@
   },
   "dependencies": {
     "execa": "9.5.1",
-    "@pipelab/plugin-core": "1.0.0-beta.28"
+    "@pipelab/plugin-core": "1.0.0-beta.32"
   },
   "devDependencies": {
     "@types/node": "24.12.2",
     "tsdown": "0.21.2",
     "typescript": "^5.0.0",
-    "@pipelab/tsconfig": "1.0.0-beta.21"
+    "@pipelab/tsconfig": "1.0.0-beta.25"
   },
   "scripts": {
     "build": "tsdown",
     "format": "oxfmt .",
+    "typecheck": "tsc -b",
     "lint": "oxlint ."
   }
 }

package/src/index.ts

@@ -157,7 +157,6 @@ process.exit(result.status ?? 0);`,
     },
     cwd: options.sandboxPath,
     paths: {
-      assets: join(options.sandboxPath, "assets"),
       cache: join(options.sandboxPath, "cache"),
       pnpm: pnpmShimPath,
       node: process.execPath,

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../tsconfig/node.json",
+  "compilerOptions": {
+    "moduleResolution": "bundler",
+    "outDir": "dist",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "baseUrl": "."
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"],
+  "references": [{ "path": "../../plugins/plugin-core" }]
+}

package/tsdown.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["esm", "cjs"],
+  dts: {
+    tsconfigRaw: {
+      references: [],
+    },
+  },
+  clean: true,
+});