@pipelab/shared 0.0.1

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@pipelab/shared",
+  "version": "0.0.1",
+  "private": false,
+  "description": "Shared logic and types for the Pipelab ecosystem",
+  "license": "FSL-1.1-MIT",
+  "author": "CynToolkit",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CynToolkit/pipelab.git",
+    "directory": "packages/shared"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@jitl/quickjs-singlefile-mjs-release-sync": "0.31.0",
+    "@jitl/quickjs-wasmfile-release-sync": "0.31.0",
+    "@supabase/supabase-js": "2.99.3",
+    "@types/node": "^24.12.2",
+    "klona": "2.0.6",
+    "nanoid": "5.0.7",
+    "quickjs-emscripten": "0.31.0",
+    "quickjs-emscripten-sync": "1.6.0",
+    "tslog": "4.9.3",
+    "type-fest": "4.26.1",
+    "valibot": "0.42.1",
+    "@pipelab/migration": "0.0.1"
+  },
+  "devDependencies": {
+    "esbuild-plugin-wasm": "1.1.0",
+    "tsdown": "0.21.2",
+    "typescript": "5.9.3",
+    "@pipelab/tsconfig": "0.0.1"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "format": "oxfmt .",
+    "lint": "oxlint ."
+  }
+}

package/src/apis.ts

@@ -0,0 +1,193 @@
+import { RendererPluginDefinition } from "./plugins/definitions";
+import { User, UserResponse } from "@supabase/supabase-js";
+import type { Tagged } from "type-fest";
+import { PresetResult, Steps } from "./model";
+import { AppConfig } from "./config.schema";
+import { Agent } from "./websocket.types";
+import {
+  BuildHistoryEntry,
+  BuildHistoryQuery,
+  BuildHistoryResponse,
+  BuildHistoryConfig,
+  RetentionPolicy,
+} from "./build-history";
+
+type Event<TYPE extends string, DATA> =
+  | { type: TYPE; data: DATA }
+  | { type: "log"; data: { decorator: string; message: unknown[]; time: number } };
+type EndEvent<DATA> = {
+  type: "end";
+  data:
+    | {
+        type: "success";
+        result: DATA;
+      }
+    | {
+        type: "error";
+        ipcError: string;
+        code?: string;
+      };
+};
+
+export type Presets = Record<string, PresetResult>;
+
+export type IpcDefinition = {
+  "fs:read": [
+    // input
+    { path: string },
+    EndEvent<{ content: string }>,
+  ];
+  "fs:remove": [
+    // input
+    { path: string },
+    EndEvent<boolean>,
+  ];
+  "fs:write": [
+    // input
+    {
+      path: string;
+      content: string;
+    },
+    EndEvent<{ ok: boolean }>,
+  ];
+  "fs:rm": [
+    // input
+    {
+      path: string;
+      recursive: boolean;
+      force: boolean;
+    },
+    EndEvent<{ ok: boolean }>,
+  ];
+  "fs:listDirectory": [
+    // input
+    { path: string },
+    EndEvent<{
+      files: {
+        name: string;
+        isDirectory: boolean;
+        isSymbolicLink: boolean;
+        size: number;
+        mtime: number;
+      }[];
+    }>,
+  ];
+  "fs:getHomeDirectory": [void, EndEvent<{ path: string }>];
+  "dialog:showOpenDialog": [
+    // input
+    Electron.OpenDialogOptions,
+    EndEvent<{ canceled: boolean; filePaths: string[] }>,
+  ];
+  "dialog:showSaveDialog": [
+    // input
+    Electron.SaveDialogOptions,
+    EndEvent<{ canceled: boolean; filePath: string | undefined }>,
+  ];
+  "nodes:get": [void, EndEvent<{ nodes: RendererPluginDefinition[] }>];
+  "presets:get": [void, EndEvent<Presets>];
+  "action:execute": [
+    {
+      pluginId: string;
+      nodeId: string;
+      params: any;
+      steps: Steps;
+    },
+    (
+      | Event<"progress", unknown>
+      | Event<"progress", unknown>
+      | EndEvent<{ outputs: Record<string, unknown>; tmp: string }>
+    ),
+  ];
+  "condition:execute": [
+    {
+      pluginId: string;
+      nodeId: string;
+      params: any;
+      steps: Steps;
+    },
+    (
+      | Event<"progress", unknown>
+      | Event<"progress", unknown>
+      | EndEvent<{ outputs: Record<string, unknown>; value: boolean }>
+    ),
+  ];
+  "constants:get": [void, EndEvent<{ result: { userData: string } }>];
+
+  "config:load": [{ config: string }, EndEvent<{ result: any }>];
+  "config:save": [{ data: any; config: string }, EndEvent<{ result: "ok" }>];
+  "config:reset": [{ config: string; key: string }, EndEvent<{ result: "ok" }>];
+  "action:cancel": [void, EndEvent<{ result: "ok" | "ko" }>];
+
+  // Build History APIs
+  "build-history:save": [{ entry: BuildHistoryEntry }, EndEvent<{ result: "ok" | "ko" }>];
+  "build-history:get": [
+    { id: string; pipelineId?: string },
+    EndEvent<{ entry?: BuildHistoryEntry }>,
+  ];
+  "build-history:get-all": [{ query?: BuildHistoryQuery }, EndEvent<BuildHistoryResponse>];
+  "build-history:update": [
+    { id: string; updates: Partial<BuildHistoryEntry>; pipelineId?: string },
+    EndEvent<{ result: "ok" | "ko" }>,
+  ];
+  "build-history:delete": [{ id: string; pipelineId?: string }, EndEvent<{ result: "ok" | "ko" }>];
+  "build-history:clear": [void, EndEvent<{ result: "ok" | "ko" }>];
+  "build-history:clear-by-pipeline": [{ pipelineId: string }, EndEvent<{ result: "ok" | "ko" }>];
+  "build-history:get-storage-info": [
+    void,
+    EndEvent<{
+      totalEntries: number;
+      totalSize: number;
+      oldestEntry?: number;
+      newestEntry?: number;
+    }>,
+  ];
+  "build-history:configure": [
+    { config: Partial<BuildHistoryConfig> },
+    EndEvent<{ result: "ok" | "ko" }>,
+  ];
+  "agents:get": [void, EndEvent<{ agents: Agent[] }>];
+  "graph:execute": [
+    {
+      graph: any[];
+      variables: any[];
+      pipelineId?: string;
+      projectId?: string;
+      projectName?: string;
+      projectPath?: string;
+    },
+    (
+      | { type: "node-enter"; data: { nodeUid: string; nodeName: string } }
+      | { type: "node-exit"; data: { nodeUid: string; nodeName: string } }
+      | { type: "node-log"; data: { nodeUid: string; logData: any } }
+      | EndEvent<{ result: any; buildId: string }>
+    ),
+  ];
+  "auth:getUser": [void, EndEvent<{ user: User | null }>];
+  "auth:signInWithPassword": [{ email: string; password: string }, EndEvent<UserResponse>];
+  "auth:signUp": [{ email: string; password: string }, EndEvent<UserResponse>];
+  "auth:signOut": [void, EndEvent<void>];
+  "auth:resetPasswordForEmail": [{ email: string }, EndEvent<{ error: any | null }>];
+  "auth:invoke": [
+    { name: string; options?: any },
+    EndEvent<{ data: any | null; error: any | null }>,
+  ];
+  "agent:version:get": [void, EndEvent<{ version: string }>];
+  "startup:progress": [void, { type: "progress"; data: { message: string } } | { type: "ready" }];
+};
+
+export type Channels = keyof IpcDefinition;
+
+export const ShellChannels: Channels[] = ["dialog:showOpenDialog", "dialog:showSaveDialog"];
+
+export type Data<KEY extends Channels> = IpcDefinition[KEY][0];
+export type Events<KEY extends Channels> = IpcDefinition[KEY][1];
+export type End<KEY extends Channels> = Extract<IpcDefinition[KEY][1], { type: "end" }>["data"];
+
+export type IpcMessage = {
+  // the channel to communicate
+  requestId: RequestId;
+  data: any;
+};
+export type RequestId = Tagged<string, "request-id">;
+
+// type Output = End<'fs:openFolder'>

package/src/build-history.ts

@@ -0,0 +1,131 @@
+// Build History Storage Types and Interfaces
+
+export interface ExecutionStep {
+  id: string;
+  name: string;
+  status: "pending" | "running" | "completed" | "failed" | "cancelled";
+  startTime: number;
+  endTime?: number;
+  duration?: number;
+  logs: LogEntry[];
+  error?: ExecutionError;
+  output?: Record<string, unknown>;
+}
+
+export interface ExecutionError {
+  message: string;
+  stack?: string;
+  code?: string;
+  timestamp: number;
+}
+
+export interface LogEntry {
+  id: string;
+  timestamp: number;
+  level: "debug" | "info" | "warn" | "error";
+  message: string;
+  source?: string;
+  data?: Record<string, unknown>;
+}
+
+export interface BuildHistoryEntry {
+  id: string;
+  pipelineId: string;
+  projectName: string;
+  projectPath: string;
+  status: "running" | "completed" | "failed" | "cancelled";
+  startTime: number;
+  endTime?: number;
+  duration?: number;
+  steps: ExecutionStep[];
+  totalSteps: number;
+  completedSteps: number;
+  failedSteps: number;
+  cancelledSteps: number;
+  logs: LogEntry[];
+  error?: ExecutionError;
+  output?: Record<string, unknown>;
+  metadata?: Record<string, unknown>;
+  userId?: string;
+  createdAt: number;
+  updatedAt: number;
+}
+
+// Query interface supporting both pipeline and scenario filtering
+export interface BuildHistoryQuery {
+  pipelineId?: string;
+}
+
+export interface BuildHistoryResponse {
+  entries: BuildHistoryEntry[];
+  total: number;
+}
+
+// Storage interfaces - Simplified for pipeline-specific storage
+export interface IBuildHistoryStorage {
+  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>;
+  getStorageInfo(): Promise<{
+    totalEntries: number;
+    totalSize: number;
+    oldestEntry?: number;
+    newestEntry?: number;
+    numberOfPipelines: number;
+    userDataPath: string;
+    retentionPolicy: {
+      enabled: boolean;
+      maxEntries: number;
+      maxAge: number;
+    };
+    disk: {
+      total: number;
+      free: number;
+      pipelab: number;
+    };
+  }>;
+}
+
+// Retention policy configuration
+export interface RetentionPolicy {
+  enabled: boolean;
+  maxEntries: number;
+  maxAge: number; // in milliseconds
+  maxSize: number; // in bytes
+  keepFailedBuilds: boolean;
+  keepSuccessfulBuilds: boolean;
+}
+
+// Storage configuration
+export interface BuildHistoryConfig {
+  storagePath: string;
+  indexFileName: string;
+  entryFilePrefix: string;
+  retentionPolicy: RetentionPolicy;
+}
+
+// Authorization and subscription types
+export interface SubscriptionBenefit {
+  id: string;
+  name: string;
+  description?: string;
+}
+
+export interface SubscriptionError extends Error {
+  code: "SUBSCRIPTION_REQUIRED" | "SUBSCRIPTION_EXPIRED" | "BENEFIT_NOT_FOUND" | "UNAUTHORIZED";
+  benefit?: string;
+  userMessage: string;
+}
+
+export interface AuthorizationContext {
+  userId?: string;
+  hasBenefit: (benefitId: string) => boolean;
+  isPaidUser: boolean;
+}
+
+// Authorization check function type
+export type AuthorizationCheck = (context: AuthorizationContext) => void;

package/src/config/migrators.ts

@@ -0,0 +1,291 @@
+import {
+  createMigration as createMigrationBase,
+  createMigrator,
+  finalVersion,
+  OmitVersion,
+  SemVer,
+  Awaitable,
+  MigrationSchema,
+} from "@pipelab/migration";
+import {
+  AppConfig,
+  AppConfigV1,
+  AppConfigV2,
+  AppConfigV3,
+  AppConfigV4,
+  AppConfigV5,
+  AppConfigV6,
+  AppConfigV7,
+} from "../config.schema";
+import { FileRepoV1, FileRepoV2, FileRepo } from "./projects-types";
+import { SavedFileV1, SavedFileV2, SavedFileV3, SavedFileV4, SavedFile } from "../model";
+
+// --- Types ---
+
+export type Additive<T, P> = OmitVersion<T> & OmitVersion<P>;
+
+const createMigration = <From extends MigrationSchema, To extends MigrationSchema>(config: {
+  version: SemVer;
+  up: (state: OmitVersion<From>, targetVersion: string) => Awaitable<Additive<To, From>>;
+}) => createMigrationBase<From, To>(config);
+
+export interface Migrator<T> {
+  migrate: (data: any, options?: any) => Promise<T>;
+  defaultValue: T;
+}
+
+// --- Settings Migrator ---
+
+const settingsMigratorInternal = createMigrator<AppConfigV1, AppConfig>();
+
+export const defaultAppSettings = settingsMigratorInternal.createDefault({
+  locale: "en-US",
+  theme: "light",
+  version: "7.0.0",
+  autosave: true,
+  agents: [],
+  tours: {
+    dashboard: {
+      step: 0,
+      completed: false,
+    },
+    editor: {
+      step: 0,
+      completed: false,
+    },
+  },
+  buildHistory: {
+    retentionPolicy: {
+      enabled: false,
+      maxEntries: 50,
+      maxAge: 30,
+    },
+  },
+});
+
+export const appSettingsMigrator = settingsMigratorInternal.createMigrations({
+  defaultValue: defaultAppSettings,
+  migrations: [
+    createMigration<AppConfigV1, AppConfigV2>({
+      version: "1.0.0" as SemVer,
+      up: (state) => state,
+    }),
+    createMigration<AppConfigV2, AppConfigV3>({
+      version: "2.0.0" as SemVer,
+      up: (state) => {
+        return {
+          ...state,
+          clearTemporaryFoldersOnPipelineEnd: false,
+        };
+      },
+    }),
+    createMigration<AppConfigV3, AppConfigV4>({
+      version: "3.0.0" as SemVer,
+      up: (state) => ({
+        ...state,
+        locale: "en-US" as const,
+      }),
+    }),
+    createMigration<AppConfigV4, AppConfigV5>({
+      version: "4.0.0" as SemVer,
+      up: (state) => ({
+        ...state,
+        tours: {
+          dashboard: {
+            step: 0,
+            completed: false,
+          },
+          editor: {
+            step: 0,
+            completed: false,
+          },
+        },
+      }),
+    }),
+    createMigration<AppConfigV5, AppConfigV6>({
+      version: "5.0.0" as SemVer,
+      up: (state) => ({
+        ...state,
+        autosave: true,
+      }),
+    }),
+    createMigration<AppConfigV6, AppConfigV7>({
+      version: "6.0.0" as SemVer,
+      up: (state) => {
+        // Upgrades V6 to V7: Add agents, add buildHistory.
+        // (Additive only - keeping cacheFolder and clearTemporaryFoldersOnPipelineEnd)
+        return {
+          ...state,
+          agents: [],
+          buildHistory: {
+            retentionPolicy: {
+              enabled: false,
+              maxEntries: 50,
+              maxAge: 30,
+            },
+          },
+        };
+      },
+    }),
+    createMigration<AppConfigV7, never>({
+      version: "7.0.0" as SemVer,
+      up: finalVersion,
+    }),
+  ],
+});
+
+// --- Projects Migrator ---
+
+const fileRepoMigratorInternal = createMigrator<FileRepoV1, FileRepo>();
+
+export const defaultFileRepo = fileRepoMigratorInternal.createDefault({
+  version: "2.0.0",
+  projects: [
+    {
+      id: "main",
+      name: "Default project",
+      description: "The initial default project",
+    },
+  ],
+  pipelines: [],
+});
+
+export const fileRepoMigrations = fileRepoMigratorInternal.createMigrations({
+  defaultValue: defaultFileRepo,
+  migrations: [
+    createMigration<FileRepoV1, FileRepoV2>({
+      version: "1.0.0",
+      up: (state) => {
+        const pipelines: FileRepoV2["pipelines"] = Object.entries(state.data || {}).map(
+          ([id, file]) => {
+            return {
+              ...file,
+              id,
+              project: "main",
+            };
+          },
+        );
+        return {
+          ...state,
+          projects: [
+            {
+              id: "main",
+              name: "Default project",
+              description: "The initial default project",
+            },
+          ],
+          pipelines: pipelines,
+        };
+      },
+    }),
+    createMigration<FileRepoV2, never>({
+      version: "2.0.0",
+      up: finalVersion,
+    }),
+  ],
+});
+
+// --- Saved File Migrator ---
+
+const savedFileMigratorInternal = createMigrator<SavedFileV1, SavedFile>();
+const savedFileDefaultValue = savedFileMigratorInternal.createDefault({
+  canvas: {
+    triggers: [],
+    blocks: [],
+  },
+  description: "",
+  name: "",
+  variables: [],
+  type: "default",
+  version: "4.0.0",
+});
+
+export const savedFileMigrator = savedFileMigratorInternal.createMigrations({
+  defaultValue: savedFileDefaultValue,
+  migrations: [
+    createMigration<SavedFileV1, SavedFileV2>({
+      version: "1.0.0" as SemVer,
+      up: (state) => {
+        const blocks = state.canvas.blocks;
+
+        const triggers: SavedFileV2["canvas"]["triggers"] = [];
+        const newBlocks: SavedFileV2["canvas"]["blocks"] = [];
+
+        for (const block of blocks) {
+          if (block.type === "event") {
+            triggers.push(block);
+          } else {
+            newBlocks.push(block);
+          }
+        }
+
+        return {
+          ...state,
+          canvas: {
+            ...state.canvas,
+            blocks: newBlocks,
+            triggers: triggers,
+          },
+        };
+      },
+    }),
+    createMigration<SavedFileV2, SavedFileV3>({
+      version: "2.0.0" as SemVer,
+      up: (state) => {
+        const { canvas } = state;
+        const { blocks, triggers } = canvas;
+
+        const newBlocks: SavedFileV3["canvas"]["blocks"] = [];
+
+        for (const block of blocks) {
+          const newParams: SavedFileV3["canvas"]["blocks"][number]["params"] = {};
+
+          for (const data of Object.entries(block.params)) {
+            if (data === undefined) {
+              throw new Error("Can't migrate block with undefined params");
+            } else {
+              const [key, value] = data;
+              newParams[key] = {
+                editor: "editor",
+                value,
+              };
+            }
+          }
+
+          newBlocks.push({
+            ...block,
+            params: newParams,
+          });
+        }
+
+        return {
+          ...state,
+          canvas: {
+            ...canvas,
+            triggers,
+            blocks: newBlocks,
+          },
+        };
+      },
+    }),
+    createMigration<SavedFileV3, SavedFileV4>({
+      version: "3.0.0" as SemVer,
+      up: (state) => ({
+        ...state,
+        type: "default",
+      }),
+    }),
+    createMigration<SavedFileV4, never>({
+      version: "4.0.0" as SemVer,
+      up: finalVersion,
+    }),
+  ],
+});
+
+// --- Registry ---
+
+export const configRegistry: Record<string, Migrator<any>> = {
+  settings: appSettingsMigrator,
+  projects: fileRepoMigrations,
+  pipeline: savedFileMigrator,
+};

package/src/config/projects-definition.ts

@@ -0,0 +1,25 @@
+import { SaveLocationValidator } from "../save-location";
+import { object, string, optional, record, InferInput, literal, array } from "valibot";
+
+export const FileRepoValidatorV1 = object({
+  version: literal("1.0.0"),
+  data: optional(record(string(), SaveLocationValidator), {}),
+});
+
+export const FileRepoProjectValidatorV2 = object({
+  id: string(),
+  name: string(),
+  description: string(),
+});
+
+export const FileRepoValidatorV2 = object({
+  version: literal("2.0.0"),
+  projects: array(FileRepoProjectValidatorV2),
+  pipelines: optional(array(SaveLocationValidator), []),
+});
+
+export type FileRepoV1 = InferInput<typeof FileRepoValidatorV1>;
+export type FileRepoV2 = InferInput<typeof FileRepoValidatorV2>;
+
+export const FileRepoValidator = FileRepoValidatorV2;
+export type FileRepo = InferInput<typeof FileRepoValidator>;