@pipelab/core-node 1.0.0-beta.0

package/src/handlers/auth.ts

@@ -0,0 +1,95 @@
+import { supabase, useLogger, isSupabaseAvailable } from "@pipelab/shared";
+import { useAPI } from "../ipc-core";
+import { JsonFileStorage } from "../utils/storage";
+import { PipelabContext } from "../context";
+import { webSocketServer } from "../websocket-server";
+
+/**
+ * Registers authentication handlers for the CLI/system backend.
+ */
+export const registerAuthHandlers = (context: PipelabContext) => {
+  const { handle } = useAPI();
+  const { logger } = useLogger();
+
+  const supabaseAvailable = isSupabaseAvailable();
+  if (!supabaseAvailable) {
+    logger().warn("[Auth] Supabase is not available. Auth handlers will not be functional.");
+    return;
+  }
+
+  // Initialize the singleton Supabase client for the backend with the custom FileStorage
+  const client = supabase({
+    auth: {
+      storage: new JsonFileStorage("auth-session.json", context),
+      persistSession: true,
+      autoRefreshToken: true,
+      detectSessionInUrl: false,
+    },
+  });
+
+  handle("auth:getUser", async (_, { send }) => {
+    try {
+      const { data, error } = await client.auth.getUser();
+      if (error) {
+        return send({ type: "end", data: { type: "success", result: { user: null } } });
+      }
+      return send({ type: "end", data: { type: "success", result: { user: data.user } } });
+    } catch (e) {
+      return send({ type: "end", data: { type: "success", result: { user: null } } });
+    }
+  });
+
+  handle("auth:signInWithPassword", async (_, { value, send }) => {
+    const { email, password } = value;
+    logger().info("[Auth] signInWithPassword:", email);
+    const result = await client.auth.signInWithPassword({ email, password });
+    return send({ type: "end", data: { type: "success", result: result as any } });
+  });
+
+  handle("auth:signUp", async (_, { value, send }) => {
+    const { email, password } = value;
+    logger().info("[Auth] signUp:", email);
+    const result = await client.auth.signUp({ email, password });
+    return send({ type: "end", data: { type: "success", result: result as any } });
+  });
+
+  handle("auth:signOut", async (_, { send }) => {
+    logger().info("[Auth] signOut");
+    await client.auth.signOut();
+    return send({ type: "end", data: { type: "success", result: undefined } });
+  });
+
+  handle("auth:resetPasswordForEmail", async (_, { value, send }) => {
+    const { email } = value;
+    logger().info("[Auth] resetPasswordForEmail:", email);
+    const { error } = await client.auth.resetPasswordForEmail(email);
+    return send({ type: "end", data: { type: "success", result: { error } } });
+  });
+
+  handle("auth:invoke", async (_, { value, send }) => {
+    const { name, options } = value;
+    logger().info("[Auth] invoke function:", name);
+    try {
+      const result = await client.functions.invoke(name, options);
+      return send({ type: "end", data: { type: "success", result } });
+    } catch (e) {
+      return send({
+        type: "end",
+        data: {
+          type: "error",
+          ipcError: e instanceof Error ? e.message : "Edge Function invocation failed",
+        },
+      });
+    }
+  });
+
+  // Maintain logs for the backend state change and broadcast to all clients
+  client.auth.onAuthStateChange(async (event, session) => {
+    logger().info(
+      "[Auth] State changed, broadcasting:",
+      event,
+      session?.user?.email || "anonymous",
+    );
+    webSocketServer.broadcast("auth:getUser" as any, { user: session?.user || null } as any);
+  });
+};

package/src/handlers/build-history.ts

@@ -0,0 +1,381 @@
+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 { useLogger, BuildHistoryEntry, IBuildHistoryStorage, AppConfig } from "@pipelab/shared";
+import { setupConfigFile } from "../config";
+import checkDiskSpace from "check-disk-space";
+import { getFolderSize } from "../utils/fs-extras";
+
+// Simplified storage - one file per pipeline containing array of build entries
+
+export class BuildHistoryStorage implements IBuildHistoryStorage {
+  private logger = useLogger();
+
+  constructor(private context: PipelabContext) {
+    // Simple initialization - no complex setup needed
+  }
+
+  private getStoragePath() {
+    return join(this.context.userDataPath, "build-history");
+  }
+
+  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`);
+  }
+
+  private async ensureStoragePath(): Promise<void> {
+    try {
+      await mkdir(this.getStoragePath(), { recursive: true });
+    } catch (error) {
+      this.logger.logger().error("Failed to create storage path:", error);
+      throw new Error(`Failed to create storage directory: ${error}`);
+    }
+  }
+
+  private async loadPipelineHistory(pipelineId: string): Promise<BuildHistoryEntry[]> {
+    try {
+      const pipelinePath = this.getPipelinePath(pipelineId);
+      const data = await readFile(pipelinePath, "utf-8");
+      return JSON.parse(data);
+    } catch (error) {
+      // File doesn't exist or is corrupted, return empty array
+      return [];
+    }
+  }
+
+  private async savePipelineHistory(
+    pipelineId: string,
+    entries: BuildHistoryEntry[],
+  ): Promise<void> {
+    try {
+      await this.ensureStoragePath();
+      const pipelinePath = this.getPipelinePath(pipelineId);
+      await writeFile(pipelinePath, JSON.stringify(entries, null, 2), "utf-8");
+    } catch (error) {
+      this.logger.logger().error("Failed to save pipeline history:", error);
+      throw new Error(`Failed to save pipeline history: ${error}`);
+    }
+  }
+
+  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);
+      const existingIndex = entries.findIndex((e) => e.id === entry.id);
+
+      if (existingIndex >= 0) {
+        entries[existingIndex] = entry;
+      } else {
+        entries.push(entry);
+      }
+
+      await this.savePipelineHistory(entry.pipelineId, entries);
+      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}`);
+    }
+  }
+
+  async get(id: string, pipelineId?: string): Promise<BuildHistoryEntry | undefined> {
+    try {
+      if (pipelineId) {
+        const entries = await this.loadPipelineHistory(pipelineId);
+        return entries.find((e) => e.id === id);
+      }
+
+      const files = await this.getAllPipelineFiles();
+      for (const file of files) {
+        const pId = file.replace("pipeline-", "").replace(".json", "");
+        const entries = await this.loadPipelineHistory(pId);
+        const entry = entries.find((e) => e.id === id);
+        if (entry) return entry;
+      }
+      return undefined;
+    } catch (error) {
+      this.logger.logger().error(`Failed to get build history entry ${id}:`, error);
+      return undefined;
+    }
+  }
+
+  async getAll(): Promise<BuildHistoryEntry[]> {
+    try {
+      const files = await this.getAllPipelineFiles();
+      const allEntries: BuildHistoryEntry[] = [];
+      for (const file of files) {
+        const pipelineId = file.replace("pipeline-", "").replace(".json", "");
+        const entries = await this.loadPipelineHistory(pipelineId);
+        allEntries.push(...entries);
+      }
+      return allEntries.sort((a, b) => b.createdAt - a.createdAt);
+    } catch (error) {
+      this.logger.logger().error("Failed to get all build history entries:", error);
+      throw new Error(`Failed to get all build history entries: ${error}`);
+    }
+  }
+
+  async getByPipeline(pipelineId: string): Promise<BuildHistoryEntry[]> {
+    try {
+      const entries = await this.loadPipelineHistory(pipelineId);
+      return entries.sort((a, b) => b.createdAt - a.createdAt);
+    } catch (error) {
+      this.logger.logger().error(`Failed to get build history for pipeline ${pipelineId}:`, error);
+      throw new Error(`Failed to get build history for pipeline: ${error}`);
+    }
+  }
+
+  async update(
+    id: string,
+    updates: Partial<BuildHistoryEntry>,
+    pipelineId?: string,
+  ): Promise<void> {
+    try {
+      if (pipelineId) {
+        const entries = await this.loadPipelineHistory(pipelineId);
+        const entryIndex = entries.findIndex((e) => e.id === id);
+        if (entryIndex >= 0) {
+          entries[entryIndex] = { ...entries[entryIndex], ...updates, updatedAt: Date.now() };
+          await this.savePipelineHistory(pipelineId, entries);
+          return;
+        }
+      } else {
+        const files = await this.getAllPipelineFiles();
+        for (const file of files) {
+          const pId = file.replace("pipeline-", "").replace(".json", "");
+          const entries = await this.loadPipelineHistory(pId);
+          const entryIndex = entries.findIndex((e) => e.id === id);
+          if (entryIndex >= 0) {
+            entries[entryIndex] = { ...entries[entryIndex], ...updates, updatedAt: Date.now() };
+            await this.savePipelineHistory(pId, entries);
+            return;
+          }
+        }
+      }
+      throw new Error(`Build history entry ${id} not found`);
+    } catch (error) {
+      this.logger.logger().error(`Failed to update build history entry ${id}:`, error);
+      throw new Error(`Failed to update build history entry: ${error}`);
+    }
+  }
+
+  async delete(id: string, pipelineId?: string): Promise<void> {
+    try {
+      if (pipelineId) {
+        const entries = await this.loadPipelineHistory(pipelineId);
+        const entryIndex = entries.findIndex((e) => e.id === id);
+        if (entryIndex >= 0) {
+          entries.splice(entryIndex, 1);
+          await this.savePipelineHistory(pipelineId, entries);
+          this.logger.logger().info(`Deleted build history entry: ${id}`);
+          return;
+        }
+      } else {
+        const files = await this.getAllPipelineFiles();
+        for (const file of files) {
+          const pId = file.replace("pipeline-", "").replace(".json", "");
+          const entries = await this.loadPipelineHistory(pId);
+          const entryIndex = entries.findIndex((e) => e.id === id);
+          if (entryIndex >= 0) {
+            entries.splice(entryIndex, 1);
+            await this.savePipelineHistory(pId, entries);
+            this.logger.logger().info(`Deleted build history entry: ${id}`);
+            return;
+          }
+        }
+      }
+      this.logger.logger().info(`Build history entry ${id} not found for deletion`);
+    } catch (error) {
+      this.logger.logger().error(`Failed to delete build history entry ${id}:`, error);
+      throw new Error(`Failed to delete build history entry: ${error}`);
+    }
+  }
+
+  async clear(): Promise<void> {
+    try {
+      await this.ensureStoragePath();
+      const files = await this.getAllPipelineFiles();
+      await Promise.all(files.map((file) => unlink(join(this.getStoragePath(), file))));
+      this.logger.logger().info("Cleared all build history");
+    } catch (error) {
+      this.logger.logger().error("Failed to clear build history:", error);
+      throw new Error(`Failed to clear build history: ${error}`);
+    }
+  }
+
+  async clearByPipeline(pipelineId: string): Promise<void> {
+    try {
+      const pipelinePath = this.getPipelinePath(pipelineId);
+      await unlink(pipelinePath);
+      this.logger.logger().info(`Cleared history for pipeline "${pipelineId}"`);
+    } catch (error: any) {
+      if (error.code === 'ENOENT') {
+        this.logger.logger().warn(`No history file found for pipeline "${pipelineId}". Nothing to clear.`);
+        return;
+      }
+      this.logger.logger().error(`Failed to clear history for pipeline "${pipelineId}":`, error);
+      throw new Error(`Failed to clear history for pipeline: ${error}`);
+    }
+  }
+
+  async 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;
+    };
+  }> {
+    try {
+      const allEntries = await this.getAll();
+      const files = await this.getAllPipelineFiles();
+
+      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,
+      };
+
+      if (allEntries.length === 0) {
+        return {
+          totalEntries: 0,
+          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,
+          },
+        };
+      }
+
+      let totalSize = 0;
+      try {
+        for (const file of files) {
+          const filePath = join(this.getStoragePath(), file);
+          const stats = await stat(filePath);
+          totalSize += stats.size;
+        }
+      } catch (error) {
+        totalSize = allEntries.length * 1024; // Rough estimate
+      }
+
+      const sortedEntries = allEntries.sort((a, b) => a.createdAt - b.createdAt);
+
+      return {
+        totalEntries: allEntries.length,
+        totalSize,
+        oldestEntry: sortedEntries[0]?.createdAt,
+        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,
+        },
+      };
+    } catch (error) {
+      this.logger.logger().error("Failed to get storage info:", error);
+      throw new Error(`Failed to get storage info: ${error}`);
+    }
+  }
+
+  private async getAllPipelineFiles(): Promise<string[]> {
+    try {
+      await this.ensureStoragePath();
+      const files = await readdir(this.getStoragePath());
+      return files.filter((file) => file.startsWith("pipeline-") && file.endsWith(".json"));
+    } catch (error) {
+      return [];
+    }
+  }
+}

package/src/handlers/config.ts

@@ -0,0 +1,109 @@
+import { useAPI } from "../ipc-core";
+import { useLogger, configRegistry } from "@pipelab/shared";
+import { setupConfigFile, getMigrator } from "../config";
+import { PipelabContext } from "../context";
+
+export const registerConfigHandlers = (context: PipelabContext) => {
+  const { handle } = useAPI();
+  const { logger } = useLogger();
+
+  handle("config:load", async (_, { send, value }) => {
+    const { config: name } = value;
+    logger().info("config:load", name);
+
+    try {
+      const manager = await setupConfigFile(name, { context });
+      const json = await manager.getConfig();
+
+      send({
+        type: "end",
+        data: {
+          type: "success",
+          result: {
+            result: json,
+          },
+        },
+      });
+    } catch (e) {
+      logger().error(`config:load error for ${name}:`, e);
+      send({
+        type: "end",
+        data: {
+          type: "error",
+          ipcError: e instanceof Error ? e.message : `Unable to load config ${name}`,
+        },
+      });
+    }
+  });
+
+  handle("config:save", async (_, { send, value }) => {
+    const { data, config: name } = value;
+
+    try {
+      const manager = await setupConfigFile(name, { context });
+      const json = typeof data === "string" ? JSON.parse(data) : data;
+      await manager.setConfig(json);
+
+      send({
+        type: "end",
+        data: {
+          type: "success",
+          result: {
+            result: "ok",
+          },
+        },
+      });
+    } catch (e) {
+      logger().error(`config:save error for ${name}:`, e);
+      send({
+        type: "end",
+        data: {
+          type: "error",
+          ipcError: e instanceof Error ? e.message : `Unable to save config ${name}`,
+        },
+      });
+    }
+  });
+
+  handle("config:reset", async (event, { value, send }) => {
+    const { config: name, key } = value;
+    logger().info("config:reset", name, key);
+
+    try {
+      const manager = await setupConfigFile(name, { context });
+      const currentConfig = await manager.getConfig();
+
+      const migrator = getMigrator(name);
+
+      if (!migrator) {
+        throw new Error(`No migrator found for configuration: ${name}`);
+      }
+
+      const defaultValue = (migrator.defaultValue as any)[key];
+
+      await manager.setConfig({
+        ...(currentConfig ? (currentConfig as any) : {}),
+        [key]: defaultValue,
+      } as any);
+
+      send({
+        type: "end",
+        data: {
+          type: "success",
+          result: {
+            result: "ok",
+          },
+        },
+      });
+    } catch (e) {
+      logger().error(`config:reset error for ${name}:`, e);
+      send({
+        type: "end",
+        data: {
+          type: "error",
+          ipcError: e instanceof Error ? e.message : `Unable to reset config ${name}`,
+        },
+      });
+    }
+  });
+};