@pipelab/core-node 1.0.0-beta.2 → 1.0.0-beta.21

package/src/context.ts

@@ -1,18 +1,25 @@
 import { join, dirname, resolve } from "node:path";
 import { homedir, platform } from "node:os";
 import { fileURLToPath } from "node:url";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, realpath, mkdtemp } from "node:fs/promises";
+import { SandboxFolder, DEFAULT_NODE_VERSION, DEFAULT_PNPM_VERSION } from "@pipelab/constants";
+
+// @ts-ignore import.meta is only allowed in ES Modules
+const metaUrl = typeof import.meta !== "undefined" ? import.meta.url : undefined;
 
 const _dirname =
   typeof __dirname !== "undefined"
     ? __dirname
-    : typeof import.meta !== "undefined" && import.meta.url
-      ? dirname(fileURLToPath(import.meta.url))
+    : metaUrl
+      ? dirname(fileURLToPath(metaUrl))
       : process.cwd();
 
 export const isDev = process.env.NODE_ENV === "development";
 
-export const getDefaultUserDataPath = () => {
+export type PipelabEnv = "dev" | "beta" | "prod";
+
+export const getDefaultUserDataPath = (env?: PipelabEnv) => {
   const base = (() => {
     switch (platform()) {
       case "win32":
@@ -24,7 +31,10 @@ export const getDefaultUserDataPath = () => {
     }
   })();
 
-  return join(base, "@pipelab", isDev ? "app-dev" : "app");
+  const mode = env ?? (isDev ? "dev" : "prod");
+  const folder = mode === "dev" ? "app-dev" : mode === "beta" ? "app-beta" : "app";
+
+  return join(base, "@pipelab", folder);
 };
 
 /**
@@ -43,15 +53,26 @@ function findProjectRoot(startDir: string): string | null {
 
 export const projectRoot = findProjectRoot(_dirname);
 
+export const CacheFolder = {
+  Actions: "actions",
+  Pipelines: "pipelines",
+  Pacote: "pacote",
+} as const;
+
+export type CacheFolderType = (typeof CacheFolder)[keyof typeof CacheFolder];
+
 export interface PipelabContextOptions {
   userDataPath: string;
+  releaseTag?: string;
 }
 
 export class PipelabContext {
   public readonly userDataPath: string;
+  public readonly releaseTag: string;
 
   constructor(options: PipelabContextOptions) {
     this.userDataPath = options.userDataPath;
+    this.releaseTag = options.releaseTag || "latest";
   }
 
   getPackagesPath(...subpaths: string[]) {
@@ -65,4 +86,95 @@ export class PipelabContext {
   getConfigPath(...subpaths: string[]) {
     return join(this.userDataPath, "config", ...subpaths);
   }
+
+  getSettingsPath() {
+    return this.getConfigPath("settings.json");
+  }
+
+  getConnectionsPath() {
+    return this.getConfigPath("connections.json");
+  }
+
+  getProjectsPath() {
+    return this.getConfigPath("projects.json");
+  }
+
+  private _cachedSettings: any = null;
+  private _cachedSettingsTime: number = 0;
+
+  private getSettings() {
+    const settingsPath = this.getSettingsPath();
+    if (!existsSync(settingsPath)) {
+      return null;
+    }
+    const now = Date.now();
+    if (this._cachedSettings && now - this._cachedSettingsTime < 2000) {
+      return this._cachedSettings;
+    }
+    try {
+      const content = readFileSync(settingsPath, "utf8");
+      this._cachedSettings = JSON.parse(content);
+      this._cachedSettingsTime = now;
+      return this._cachedSettings;
+    } catch (e) {
+      return this._cachedSettings;
+    }
+  }
+
+  getTempPath(...subpaths: string[]) {
+    const settings = this.getSettings();
+    const base = settings?.tempFolder || join(this.userDataPath, "temp");
+    return join(base, ...subpaths);
+  }
+
+  async createTempFolder(prefix = "pipelab-") {
+    const baseDir = this.getTempPath();
+    await mkdir(baseDir, { recursive: true });
+    const realBaseDir = await realpath(baseDir);
+    return await mkdtemp(join(realBaseDir, prefix));
+  }
+
+  getCachePath(): string;
+  getCachePath(folder: CacheFolderType, ...subpaths: string[]): string;
+  getCachePath(folder?: CacheFolderType, ...subpaths: string[]) {
+    const settings = this.getSettings();
+    const base = settings?.cacheFolder || join(this.userDataPath, "cache");
+    if (!folder) {
+      return base;
+    }
+    return join(base, folder, ...subpaths);
+  }
+
+  getPnpmPath(...subpaths: string[]) {
+    return join(this.userDataPath, "pnpm", ...subpaths);
+  }
+
+  getBuildHistoryPath(...subpaths: string[]) {
+    return join(this.userDataPath, "build-history", ...subpaths);
+  }
+
+  getNodePath(version = DEFAULT_NODE_VERSION) {
+    const isWindows = process.platform === "win32";
+    return this.getThirdPartyPath("node", version, isWindows ? "node.exe" : "bin/node");
+  }
+
+  getPnpmBinPath(version = DEFAULT_PNPM_VERSION) {
+    return this.getPackagesPath("pnpm", version, "bin", "pnpm.cjs");
+  }
+
+  getSandboxFolders(): Array<{ name: SandboxFolder; label: string; path: string }> {
+    const foldersRecord: Record<SandboxFolder, { label: string; path: string }> = {
+      [SandboxFolder.Packages]: { label: "Packages", path: this.getPackagesPath() },
+      [SandboxFolder.ThirdParty]: { label: "Third-Party Tools", path: this.getThirdPartyPath() },
+      [SandboxFolder.Config]: { label: "Configuration", path: this.getConfigPath() },
+      [SandboxFolder.Temp]: { label: "Temporary Files", path: this.getTempPath() },
+      [SandboxFolder.Cache]: { label: "Cache", path: this.getCachePath() },
+      [SandboxFolder.Pnpm]: { label: "PNPM Home", path: this.getPnpmPath() },
+    };
+
+    return (Object.keys(foldersRecord) as SandboxFolder[]).map((key) => ({
+      name: key,
+      ...foldersRecord[key],
+    }));
+  }
 }

package/src/handler-func.ts

@@ -1,13 +1,13 @@
 import { End } from "@pipelab/shared";
 import { ensureNodeJS, ensurePNPM } from "./utils/remote";
-import { Action, ActionRunner, Condition, ConditionRunner } from "./types/runner";
+import { Action, ActionRunner } from "./types/runner";
 import { InputsDefinition } from "@pipelab/shared";
 import { usePlugins } from "@pipelab/shared";
 import { isRequired } from "@pipelab/shared";
 import { mkdir, stat } from "node:fs/promises";
 import { PipelabContext } from "./context";
 import { useLogger } from "@pipelab/shared";
-import { BlockCondition } from "@pipelab/shared";
+
 import { HandleListenerSendFn } from "./handlers";
 import path from "node:path";
 const { join } = path;
@@ -38,81 +38,6 @@ const checkParams = (definitionParams: InputsDefinition, elementParams: Record<s
   }
 };
 
-export const handleConditionExecute = async (
-  nodeId: string,
-  pluginId: string,
-  params: BlockCondition["params"],
-  cwd: string,
-  context: PipelabContext,
-): Promise<End<"condition:execute">> => {
-  const ctx = context;
-  const { plugins } = usePlugins();
-  const { logger } = useLogger();
-
-  const node = plugins.value
-    .find((plugin) => plugin.id === pluginId)
-    ?.nodes.find((node: any) => node.node.id === nodeId) as
-    | {
-        node: Condition;
-        runner: ConditionRunner<any>;
-      }
-    | undefined;
-
-  if (!node) {
-    return {
-      type: "error",
-      ipcError: "Node not found",
-    };
-  }
-
-  try {
-    const s = await stat(cwd);
-    if (!s.isDirectory()) {
-      throw new Error(`Execution directory "${cwd}" exists but is not a directory.`);
-    }
-  } catch (e: any) {
-    if (e.code === "ENOENT") {
-      await mkdir(cwd, { recursive: true });
-    } else {
-      throw e;
-    }
-  }
-
-  try {
-    checkParams(node.node.params, params);
-    const resolvedInputs = params; // await resolveConditionInputs(params, node.node, steps)
-
-    const result = await node.runner({
-      inputs: resolvedInputs,
-      log: (...args) => {
-        logger().info(`[${node.node.name}]`, ...args);
-      },
-      meta: {
-        definition: "",
-      },
-      setMeta: () => {
-        logger().info("set meta defined here");
-      },
-      cwd,
-      context: ctx,
-    });
-
-    return {
-      type: "success",
-      result: {
-        outputs: {},
-        value: result,
-      },
-    };
-  } catch (e) {
-    logger().error("Error in condition execution:", e);
-    return {
-      type: "error",
-      ipcError: String(e),
-    };
-  }
-};
-
 export const handleActionExecute = async (
   nodeId: string,
   pluginId: string,

package/src/handlers/build-history.ts

@@ -1,11 +1,10 @@
 import { PipelabContext } from "../context";
 import { join } from "node:path";
-import { writeFile, readFile, unlink, mkdir, stat, readdir } from "node:fs/promises";
-import { tmpdir } from "node:os";
+import { writeFile, readFile, unlink, mkdir, stat, readdir, rm } from "node:fs/promises";
 import { useLogger, BuildHistoryEntry, IBuildHistoryStorage, AppConfig } from "@pipelab/shared";
-import { setupConfigFile } from "../config";
 import checkDiskSpace from "check-disk-space";
 import { getFolderSize } from "../utils/fs-extras";
+import { SandboxFolder } from "@pipelab/constants";
 
 // Simplified storage - one file per pipeline containing array of build entries
 
@@ -17,18 +16,11 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
   }
 
   private getStoragePath() {
-    return join(this.context.userDataPath, "build-history");
+    return this.context.getConfigPath("pipelines");
   }
 
   private getPipelinePath(pipelineId: string): string {
-    // Sanitize the pipelineId to create a valid filename
-    // Replace invalid filename characters with underscores
-    const sanitizedId = pipelineId
-      .replace(/[/\:*?"<>|]/g, "_")
-      .replace(/__/g, "_") // Replace multiple underscores with single
-      .replace(/^_+|_+$/g, ""); // Remove leading/trailing underscores
-
-    return join(this.getStoragePath(), `pipeline-${sanitizedId}.json`);
+    return join(this.getStoragePath(), `${pipelineId}.history.json`);
   }
 
   private async ensureStoragePath(): Promise<void> {
@@ -65,51 +57,6 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
     }
   }
 
-  async applyRetentionPolicy(): Promise<void> {
-    try {
-      this.logger.logger().info("Applying build history retention policy...");
-      const settings = await setupConfigFile<AppConfig>("settings", { context: this.context });
-      const config = await settings.getConfig();
-      const policy = config?.buildHistory?.retentionPolicy;
-
-      if (!policy || !policy.enabled) {
-        this.logger.logger().info("Retention policy is disabled. Skipping.");
-        return;
-      }
-
-      const { maxAge, maxEntries } = policy;
-      const pipelineFiles = await this.getAllPipelineFiles();
-
-      for (const file of pipelineFiles) {
-        const pipelineId = file.replace("pipeline-", "").replace(".json", "");
-        let entries = await this.loadPipelineHistory(pipelineId);
-        const originalCount = entries.length;
-
-        // 1. Filter by maxAge
-        if (maxAge > 0) {
-          const minDate = Date.now() - maxAge * 24 * 60 * 60 * 1000;
-          entries = entries.filter((entry) => entry.createdAt >= minDate);
-        }
-
-        // 2. Filter by maxEntries (sort by date first to keep the newest)
-        if (maxEntries > 0 && entries.length > maxEntries) {
-          entries = entries.sort((a, b) => b.createdAt - a.createdAt).slice(0, maxEntries);
-        }
-
-        if (entries.length < originalCount) {
-          this.logger
-            .logger()
-            .info(`[${pipelineId}] Pruned ${originalCount - entries.length} history entries.`);
-          await this.savePipelineHistory(pipelineId, entries);
-        }
-      }
-      this.logger.logger().info("Retention policy applied successfully.");
-    } catch (error) {
-      this.logger.logger().error("Failed to apply retention policy:", error);
-      // We don't re-throw here as this is a background task and shouldn't crash the app
-    }
-  }
-
   async save(entry: BuildHistoryEntry): Promise<void> {
     try {
       const entries = await this.loadPipelineHistory(entry.pipelineId);
@@ -125,11 +72,6 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
       this.logger
         .logger()
         .info(`Saved build history entry: ${entry.id} for pipeline: ${entry.pipelineId}`);
-
-      // Apply retention policy after each save
-      this.applyRetentionPolicy().catch((err) => {
-        this.logger.logger().error("Failed to apply retention policy after save:", err);
-      });
     } catch (error) {
       this.logger.logger().error("Failed to save build history entry:", error);
       throw new Error(`Failed to save build history entry: ${error}`);
@@ -145,7 +87,8 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
 
       const files = await this.getAllPipelineFiles();
       for (const file of files) {
-        const pId = file.replace("pipeline-", "").replace(".json", "");
+        const pId = this.parsePipelineIdFromFilename(file);
+        if (!pId) continue;
         const entries = await this.loadPipelineHistory(pId);
         const entry = entries.find((e) => e.id === id);
         if (entry) return entry;
@@ -162,7 +105,8 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
       const files = await this.getAllPipelineFiles();
       const allEntries: BuildHistoryEntry[] = [];
       for (const file of files) {
-        const pipelineId = file.replace("pipeline-", "").replace(".json", "");
+        const pipelineId = this.parsePipelineIdFromFilename(file);
+        if (!pipelineId) continue;
         const entries = await this.loadPipelineHistory(pipelineId);
         allEntries.push(...entries);
       }
@@ -200,7 +144,8 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
       } else {
         const files = await this.getAllPipelineFiles();
         for (const file of files) {
-          const pId = file.replace("pipeline-", "").replace(".json", "");
+          const pId = this.parsePipelineIdFromFilename(file);
+          if (!pId) continue;
           const entries = await this.loadPipelineHistory(pId);
           const entryIndex = entries.findIndex((e) => e.id === id);
           if (entryIndex >= 0) {
@@ -231,7 +176,8 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
       } else {
         const files = await this.getAllPipelineFiles();
         for (const file of files) {
-          const pId = file.replace("pipeline-", "").replace(".json", "");
+          const pId = this.parsePipelineIdFromFilename(file);
+          if (!pId) continue;
           const entries = await this.loadPipelineHistory(pId);
           const entryIndex = entries.findIndex((e) => e.id === id);
           if (entryIndex >= 0) {
@@ -253,8 +199,26 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
     try {
       await this.ensureStoragePath();
       const files = await this.getAllPipelineFiles();
-      await Promise.all(files.map((file) => unlink(join(this.getStoragePath(), file))));
+      const cachePathsToDelete = new Set<string>();
+
+      for (const file of files) {
+        const pipelineId = this.parsePipelineIdFromFilename(file);
+        if (pipelineId) {
+          const entries = await this.loadPipelineHistory(pipelineId);
+          for (const entry of entries) {
+            if (entry.cachePath) {
+              cachePathsToDelete.add(entry.cachePath);
+            }
+          }
+        }
+        await unlink(join(this.getStoragePath(), file));
+      }
+
       this.logger.logger().info("Cleared all build history");
+
+      for (const cachePath of cachePathsToDelete) {
+        await rm(cachePath, { recursive: true, force: true }).catch(() => {});
+      }
     } catch (error) {
       this.logger.logger().error("Failed to clear build history:", error);
       throw new Error(`Failed to clear build history: ${error}`);
@@ -264,8 +228,19 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
   async clearByPipeline(pipelineId: string): Promise<void> {
     try {
       const pipelinePath = this.getPipelinePath(pipelineId);
+      const entries = await this.loadPipelineHistory(pipelineId);
       await unlink(pipelinePath);
       this.logger.logger().info(`Cleared history for pipeline "${pipelineId}"`);
+
+      const cachePathsToDelete = new Set<string>();
+      for (const entry of entries) {
+        if (entry.cachePath) {
+          cachePathsToDelete.add(entry.cachePath);
+        }
+      }
+      for (const cachePath of cachePathsToDelete) {
+        await rm(cachePath, { recursive: true, force: true }).catch(() => {});
+      }
     } catch (error: any) {
       if (error.code === "ENOENT") {
         this.logger
@@ -285,15 +260,11 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
     newestEntry?: number;
     numberOfPipelines: number;
     userDataPath: string;
-    retentionPolicy: {
-      enabled: boolean;
-      maxEntries: number;
-      maxAge: number;
-    };
     disk: {
       total: number;
       free: number;
       pipelab: number;
+      folders: Array<{ name: SandboxFolder; label: string; size: number }>;
     };
   }> {
     try {
@@ -303,13 +274,15 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
       const diskSpace = await checkDiskSpace(this.context.userDataPath);
       const pipelabSize = await getFolderSize(this.context.userDataPath);
 
-      const settings = await setupConfigFile<AppConfig>("settings", { context: this.context });
-      const config = await settings.getConfig();
-      const policy = config?.buildHistory?.retentionPolicy || {
-        enabled: false,
-        maxEntries: 50,
-        maxAge: 30,
-      };
+      const folders = [];
+      for (const folder of this.context.getSandboxFolders()) {
+        const size = await getFolderSize(folder.path);
+        folders.push({
+          name: folder.name,
+          label: folder.label,
+          size,
+        });
+      }
 
       if (allEntries.length === 0) {
         return {
@@ -317,15 +290,11 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
           totalSize: 0,
           numberOfPipelines: files.length,
           userDataPath: this.context.userDataPath,
-          retentionPolicy: {
-            enabled: policy.enabled,
-            maxEntries: policy.maxEntries,
-            maxAge: policy.maxAge,
-          },
           disk: {
             total: diskSpace.size,
             free: diskSpace.free,
             pipelab: pipelabSize,
+            folders,
           },
         };
       }
@@ -350,15 +319,11 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
         newestEntry: sortedEntries[sortedEntries.length - 1]?.createdAt,
         numberOfPipelines: files.length,
         userDataPath: this.context.userDataPath,
-        retentionPolicy: {
-          enabled: policy.enabled,
-          maxEntries: policy.maxEntries,
-          maxAge: policy.maxAge,
-        },
         disk: {
           total: diskSpace.size,
           free: diskSpace.free,
           pipelab: pipelabSize,
+          folders,
         },
       };
     } catch (error) {
@@ -371,9 +336,14 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
     try {
       await this.ensureStoragePath();
       const files = await readdir(this.getStoragePath());
-      return files.filter((file) => file.startsWith("pipeline-") && file.endsWith(".json"));
+      return files.filter((file) => file.endsWith(".history.json"));
     } catch (error) {
       return [];
     }
   }
+
+  private parsePipelineIdFromFilename(filename: string): string | null {
+    const match = filename.match(/^(.+)\.history\.json$/);
+    return match ? match[1] : null;
+  }
 }