@pipelab/plugin-filesystem 1.0.0-beta.0

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@pipelab/plugin-filesystem",
+  "version": "1.0.0-beta.0",
+  "license": "FSL-1.1-MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CynToolkit/pipelab.git",
+    "directory": "plugins/plugin-filesystem"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@types/node": "^24.12.2",
+    "node-stream-zip": "1.15.0",
+    "@pipelab/plugin-core": "1.0.0-beta.0"
+  },
+  "devDependencies": {
+    "tsdown": "0.21.2",
+    "typescript": "5.9.3",
+    "vitest": "3.1.4",
+    "@pipelab/test-utils": "1.0.0-beta.0",
+    "@pipelab/tsconfig": "1.0.0-beta.0"
+  },
+  "test": {
+    "env": {
+      "NODE_ENV": "development"
+    }
+  },
+  "scripts": {
+    "format": "oxfmt .",
+    "lint": "oxlint .",
+    "build": "tsdown",
+    "test": "vitest run -c tests/e2e/vitest.config.mts"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
+    }
+  }
+}

package/src/copy.spec.ts

@@ -0,0 +1,100 @@
+import { describe, expect, test } from "vitest";
+import { copyRunner } from "./copy.js";
+import mock from "mock-fs";
+import { readFile } from "node:fs/promises";
+import { browserWindow } from "@pipelab/shared";
+
+describe("copy", () => {
+  test("copy file to file", async () => {
+    const outputs: Record<string, unknown> = {};
+
+    const sourcePath = "/source/source-file.txt";
+    const sourceContent = "text";
+
+    const destinationPath = "/destination/destination-file.txt";
+    const files = {
+      [sourcePath]: sourceContent,
+      "/destination": {},
+    };
+
+    // mock(files)
+
+    // await copyRunner({
+    //   cwd: '',
+    //   inputs: {
+    //     from: sourcePath,
+    //     to: destinationPath,
+    //     recursive: false
+    //   },
+    //   log: (...args) => {
+    //     console.log(...args)
+    //   },
+    //   setOutput: (key, value) => {
+    //     outputs[key] = value
+    //   },
+    //   meta: {
+    //     definition: ''
+    //   },
+    //   setMeta: () => {
+    //     console.log('set meta defined here')
+    //   },
+    //   paths: {
+    //     assets: '',
+    //     unpack: ''
+    //   },
+    //   api: undefined,
+    //   browserWindow
+    // })
+
+    // const data = await readFile(destinationPath, 'utf-8')
+
+    // expect(data).toBe(sourceContent)
+    expect(true).toBe(true);
+  });
+
+  test("copy file to file where parent folder doesn't exist", async () => {
+    const outputs: Record<string, unknown> = {};
+
+    const sourcePath = "/source/source-file.txt";
+    const sourceContent = "text";
+
+    const destinationPath = "/destination/destination-file.txt";
+    const files = {
+      [sourcePath]: sourceContent,
+    };
+
+    // mock(files)
+
+    // await copyRunner({
+    //   cwd: '',
+    //   inputs: {
+    //     from: sourcePath,
+    //     to: destinationPath,
+    //     recursive: false
+    //   },
+    //   log: (...args) => {
+    //     console.log(...args)
+    //   },
+    //   setOutput: (key, value) => {
+    //     outputs[key] = value
+    //   },
+    //   meta: {
+    //     definition: ''
+    //   },
+    //   setMeta: () => {
+    //     console.log('set meta defined here')
+    //   },
+    //   paths: {
+    //     assets: '',
+    //     unpack: ''
+    //   },
+    //   api: undefined,
+    //   browserWindow
+    // })
+
+    // const data = await readFile(destinationPath, 'utf-8')
+
+    // expect(data).toBe(sourceContent)
+    expect(true).toBe(true);
+  });
+});

package/src/copy.ts

@@ -0,0 +1,154 @@
+import { cp, mkdir, rm, stat } from "node:fs/promises";
+import { basename, join, dirname } from "node:path";
+import { createAction, createActionRunner, createPathParam } from "@pipelab/plugin-core";
+
+export const ID = "fs:copy";
+
+export const copy = createAction({
+  id: ID,
+  name: "Copy file/folder",
+  displayString:
+    '`Copy ${fmt.param(params.from, "primary", "Source")} to ${fmt.param(params.to, "primary", "Destination")}`',
+  params: {
+    from: createPathParam("", {
+      label: "From",
+      required: true,
+      control: {
+        type: "path",
+        options: {
+          properties: ["openFile", "openDirectory"],
+        },
+      },
+    }),
+    to: createPathParam("", {
+      label: "To",
+      required: true,
+      control: {
+        type: "path",
+        options: {
+          properties: ["openFile", "openDirectory", "createDirectory", "promptToCreate"],
+        },
+      },
+    }),
+    recursive: {
+      label: "Recursive",
+      required: true,
+      value: true,
+      control: {
+        type: "boolean",
+      },
+    },
+    overwrite: {
+      label: "Overwrite",
+      required: true,
+      value: true,
+      control: {
+        type: "boolean",
+      },
+    },
+    cleanup: {
+      label: "Cleanup",
+      required: true,
+      description: "Whether to delete the original file/folder",
+      value: true,
+      control: {
+        type: "boolean",
+      },
+    },
+  },
+
+  outputs: {
+    output: {
+      label: "Output",
+      value: "",
+      description: "The copied file/folder",
+    },
+    input: {
+      label: "Input",
+      value: "",
+      description: "The original file/folder",
+    },
+    parentDirectory: {
+      label: "Parent directory",
+      value: "",
+      description: "The parent directory of the copied file/folder",
+    },
+  },
+  description: "Copy a file or a folder from one location to another",
+  icon: "",
+  meta: {},
+});
+
+export const copyRunner = createActionRunner<typeof copy>(async ({ log, inputs, setOutput }) => {
+  log("");
+
+  const from = inputs.from;
+  let to = inputs.to;
+
+  let fromIsAFile = false;
+  try {
+    const stats = await stat(from);
+    if (stats.isFile()) {
+      fromIsAFile = true;
+    }
+  } catch (e) {
+    log("Error getting file stats", e);
+    throw e;
+  }
+  const fromFileName = fromIsAFile ? basename(from) : "";
+
+  if (!from) {
+    log("From", from);
+    throw new Error("Missing source");
+  }
+
+  if (!to) {
+    log("To", to);
+    throw new Error("Missing destination");
+  }
+
+  // if from is a file, we only add the file name to the destination if 'to' is an existing directory
+  if (fromIsAFile) {
+    try {
+      const toStats = await stat(to);
+      if (toStats.isDirectory()) {
+        to = join(to, fromFileName);
+      }
+    } catch (e) {
+      // If 'to' doesn't exist, we assume the user provided the full destination path (including filename)
+    }
+  }
+
+  log("Copying", from, "to", to, "recursive", inputs.recursive, "overwrite", inputs.overwrite);
+
+  if (inputs.cleanup) {
+    try {
+      log("Cleaning up", to);
+      process.noAsar = true;
+      await rm(to, { recursive: true, force: true, maxRetries: 3 });
+      if (!fromIsAFile) {
+        await mkdir(to, { recursive: true });
+      }
+      process.noAsar = false;
+    } catch (e) {
+      log("Error cleaning up file", e);
+      throw e;
+    }
+  }
+
+  try {
+    process.noAsar = true;
+    await cp(from, to, {
+      recursive: inputs.recursive && !fromIsAFile,
+      force: inputs.overwrite,
+    });
+    process.noAsar = false;
+    setOutput("output", to);
+    setOutput("input", from);
+    setOutput("parentDirectory", dirname(to));
+    log("Copied", from, "to", to);
+  } catch (e) {
+    log("Error copying file", e);
+    throw e;
+  }
+});

package/src/index.ts

@@ -0,0 +1,58 @@
+import { createNodeDefinition } from "@pipelab/plugin-core";
+import { ListFilesAction, ListFilesActionRun } from "./list-files";
+import { isFileCondition, isFileRunner } from "./is-file";
+import { zipRunner, zip } from "./zip";
+import { zipV2Runner, zipV2 } from "./zip-v2";
+import { unzipRunner, unzip } from "./unzip";
+import { copy, copyRunner } from "./copy";
+import { remove, removeRunner } from "./remove";
+import { run, runRunner } from "./run";
+import { openInExplorer, openInExplorerRunner } from "./open";
+
+export default createNodeDefinition({
+  description: "Filesystem",
+  id: "filesystem",
+  name: "Filesystem",
+  icon: {
+    type: "icon",
+    icon: "mdi-folder-zip-outline",
+  },
+  nodes: [
+    // {
+    //     node: ListFilesAction,
+    //     runner: ListFilesActionRun
+    // },
+    // {
+    //     node: isFileCondition,
+    //     runner: isFileRunner
+    // },
+    {
+      node: zip,
+      runner: zipRunner,
+    },
+    {
+      node: zipV2,
+      runner: zipV2Runner,
+    },
+    {
+      node: unzip,
+      runner: unzipRunner,
+    },
+    {
+      node: copy,
+      runner: copyRunner,
+    },
+    {
+      node: remove,
+      runner: removeRunner,
+    },
+    {
+      node: run,
+      runner: runRunner,
+    },
+    {
+      node: openInExplorer,
+      runner: openInExplorerRunner,
+    },
+  ],
+});

package/src/is-file.ts

@@ -0,0 +1,36 @@
+import fs from "node:fs/promises";
+import { createCondition, createConditionRunner } from "@pipelab/plugin-core";
+
+export const ID = "is-file";
+
+export const isFileCondition = createCondition({
+  id: ID,
+  icon: "",
+  name: "Is file",
+  description: "",
+  displayString: "`If ${params.path} is a file`",
+  params: {
+    path: {
+      value: "",
+      label: "Path",
+      control: {
+        type: "input",
+        options: {
+          kind: "text",
+        },
+      },
+    },
+  },
+});
+
+export const isFileRunner = createConditionRunner<typeof isFileCondition>(
+  async ({ log, inputs }) => {
+    const path = inputs.path;
+
+    log("path", path);
+
+    const stats = await fs.stat(path);
+
+    return stats.isFile();
+  },
+);

package/src/list-files.ts

@@ -0,0 +1,70 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createAction, createActionRunner } from "@pipelab/plugin-core";
+export const ID = "list-files-node";
+
+export const ListFilesAction = createAction({
+  id: ID,
+  name: "List files",
+  displayString:
+    "`List files \"${params.recursive ? 'recursively' : ''}\" from \"${params.folder}`",
+  params: {
+    folder: {
+      control: {
+        type: "path",
+        options: {
+          properties: ["openDirectory"],
+        },
+      },
+      value: "",
+      label: "Folder",
+    },
+    recursive: {
+      control: {
+        type: "boolean",
+      },
+      value: false,
+      label: "Recursive",
+    },
+  },
+
+  outputs: {
+    paths: {
+      value: [] as Array<string>,
+      label: "Paths",
+    },
+  },
+  description: "List files from a folder",
+  icon: "",
+  meta: {},
+});
+
+export const ListFilesActionRun = createActionRunner<typeof ListFilesAction>(
+  async ({ log, inputs, setOutput }) => {
+    const readdir = fs.readdir;
+
+    log("");
+
+    log("inputs", inputs);
+
+    const folder = inputs.folder;
+    const recursive = inputs.recursive;
+
+    log("folder", folder);
+
+    const response = await readdir(folder, {
+      withFileTypes: true,
+      recursive,
+    });
+
+    log("response", response);
+
+    const files = response;
+
+    log("-- setValue('paths')");
+    setOutput(
+      "paths",
+      files.map((x) => path.join(x.path, x.name)),
+    );
+  },
+);

package/src/open.ts

@@ -0,0 +1,67 @@
+import { exec } from "node:child_process";
+import { platform } from "node:os";
+import { createRequire } from "node:module";
+import { createAction, createActionRunner, createPathParam } from "@pipelab/plugin-core";
+
+const require = createRequire(import.meta.url);
+// import displayString from './displayStringRun.lua?raw'
+
+export const ID = "fs:open-in-explorer";
+
+export const openInExplorer = createAction({
+  id: ID,
+  name: "Open path in explorer",
+  displayString: "`Open ${fmt.param(params.path, 'primary', 'No path set')} in explorer`",
+  params: {
+    path: createPathParam("", {
+      required: true,
+      label: "Path",
+      control: {
+        type: "path",
+        options: {
+          properties: ["openDirectory", "openFile"],
+        },
+      },
+    }),
+  },
+
+  outputs: {
+    message: {
+      label: "Message",
+      value: "",
+    },
+  },
+  description: "Open a file or folder in your explorer",
+  icon: "",
+  meta: {},
+});
+
+export const openInExplorerRunner = createActionRunner<typeof openInExplorer>(
+  async ({ log, inputs, setOutput }) => {
+    log(`Opening ${inputs.path}`);
+
+    return new Promise((resolve, reject) => {
+      let command = "";
+      const p = platform();
+
+      if (p === "win32") {
+        command = `start "" "${inputs.path}"`;
+      } else if (p === "darwin") {
+        command = `open "${inputs.path}"`;
+      } else {
+        command = `xdg-open "${inputs.path}"`;
+      }
+
+      exec(command, (error) => {
+        if (error) {
+          log(`Error opening path: ${error.message}`);
+          setOutput("message", error.message);
+          resolve();
+        } else {
+          setOutput("message", "success");
+          resolve();
+        }
+      });
+    });
+  },
+);

package/src/remove.ts

@@ -0,0 +1,58 @@
+import { rm } from "node:fs/promises";
+import { createAction, createActionRunner, createPathParam } from "@pipelab/plugin-core";
+
+export const ID = "fs:remove";
+
+export const remove = createAction({
+  id: ID,
+  name: "Remove file/folder",
+  displayString: '`Remove ${fmt.param(params.from, "primary")}`',
+  params: {
+    from: createPathParam("", {
+      label: "Path",
+      required: true,
+      control: {
+        type: "path",
+        options: {
+          properties: ["openFile"],
+        },
+      },
+    }),
+    recursive: {
+      label: "Recursive",
+      required: true,
+      value: true,
+      control: {
+        type: "boolean",
+      },
+    },
+  },
+
+  outputs: {},
+  description: "Remove a file or a folder",
+  icon: "",
+  meta: {},
+});
+
+export const removeRunner = createActionRunner<typeof remove>(async ({ log, inputs }) => {
+  log("");
+
+  const from = inputs.from;
+
+  log("Removing", from, inputs.recursive);
+
+  if (!from) {
+    log("From", from);
+    throw new Error("Missing source");
+  }
+
+  try {
+    process.noAsar = true;
+    await rm(from, { recursive: true, force: true, maxRetries: 3 });
+    process.noAsar = false;
+    log("Removed", from);
+  } catch (e) {
+    log("Error removeing file", e);
+    throw e;
+  }
+});