@pipelab/plugin-filesystem 1.0.0-beta.0

package/src/run.ts

@@ -0,0 +1,138 @@
+import {
+  createAction,
+  createActionRunner,
+  createPathParam,
+  createStringParam,
+  runWithLiveLogs,
+} from "@pipelab/plugin-core";
+
+export const ID = "fs:run";
+
+export const run = createAction({
+  id: ID,
+  name: "Invoke file",
+  displayString:
+    "`Invoke ${fmt.param(params.command, 'primary')} ${(params.parameters ?? []).map(x => fmt.param(x)).join(' ')}`",
+  // displayString: displayString,
+  params: {
+    command: createStringParam("", {
+      required: true,
+      description: "The command to run",
+      label: "Command",
+    }),
+    parameters: {
+      required: true,
+      description: "The command's parameters",
+      label: "Arguments",
+      value: [],
+      control: {
+        type: "array",
+        options: {
+          kind: "text",
+        },
+      },
+    },
+    workingDirectory: createPathParam("", {
+      required: false,
+      description: "The directory to run the command in. Default to current task directory",
+      label: "Working directory",
+      control: {
+        type: "path",
+        options: {
+          properties: ["createDirectory", "openDirectory"],
+        },
+      },
+    }),
+    stopOnError: {
+      required: false,
+      description: "Stop the task if the command fails",
+      label: "Stop on error",
+      value: false,
+      control: {
+        type: "boolean",
+      },
+    },
+  },
+
+  outputs: {
+    stdout: {
+      label: "Standard output",
+      description: "Standard output of the command",
+      value: "",
+    },
+    stderr: {
+      label: "Error output",
+      value: "",
+    },
+    exitCode: {
+      label: "Exit code",
+      value: 0,
+    },
+    duration: {
+      label: "Duration",
+      value: 0,
+    },
+  },
+  description: "Invoke an arbitrary executable",
+  icon: "",
+  meta: {},
+});
+
+export const runRunner = createActionRunner<typeof run>(
+  async ({ log, inputs, setOutput, abortSignal }) => {
+    const str = `${inputs.command} ${inputs.parameters.join(" ")}`;
+
+    log(`Running ${str}`);
+
+    let stdout: string = "";
+    let stderr: string = "";
+    let exitCode: number = 0;
+    const durationMs: number = 0;
+
+    const wd = inputs.workingDirectory ?? process.cwd();
+    log(`Working directory: ${wd}`);
+
+    try {
+      await runWithLiveLogs(
+        inputs.command,
+        inputs.parameters,
+        {
+          cwd: wd,
+          cancelSignal: abortSignal,
+        },
+        log,
+        {
+          onStdout: (data) => {
+            stdout += data.toString();
+            log(data.toString());
+          },
+          onStderr: (data) => {
+            stderr += data.toString();
+            log(data.toString());
+          },
+          onExit(code) {
+            exitCode = code;
+          },
+        },
+      );
+
+      setOutput("exitCode", exitCode === undefined ? -1 : exitCode);
+      setOutput("stdout", stdout);
+      setOutput("stderr", stderr);
+      setOutput("duration", durationMs);
+      if ((exitCode > 0 || exitCode === undefined) && inputs.stopOnError === true) {
+        throw new Error(`Command failed with exit code ${exitCode}`);
+      }
+    } catch (error) {
+      console.log("error", error);
+      if (inputs.stopOnError === true) {
+        throw error;
+      } else if (error /*  instanceof ExecaError */) {
+        setOutput("exitCode", error.exitCode === undefined ? -1 : error.exitCode);
+        setOutput("stdout", error.stdout ?? "");
+        setOutput("stderr", error.stderr ?? "");
+        setOutput("duration", error.durationMs ?? 0);
+      }
+    }
+  },
+);

package/src/temporary-folder.ts

@@ -0,0 +1,50 @@
+// import { ComputeOutput, Context, CynNode, IODef, createDefinition, path, schema } from '@pipelab/plugin-core';
+// import { nanoid } from 'nanoid'
+
+// export const ID = 'temporary-folder'
+
+// export type Data = {
+// }
+
+// export const definition = createDefinition({
+//     inputs: {
+
+//     },
+//     outputs: {
+//         value: {
+//             type: 'data',
+//             schema: schema.string()
+//         }
+//     }
+// } satisfies IODef)
+
+// export class TemporaryFolderNode extends CynNode<Data, typeof ID, typeof definition> {
+//     width = 180;
+//     height = 250;
+
+//     path: string | undefined
+
+//     constructor(context: Context) {
+//         super(ID, "Temporary folder", context);
+
+//         const value = new ClassicPreset.Output(path(), "Valeur")
+//         this.addOutput('value', value);
+//     }
+//     run() { }
+//     compute(): ComputeOutput<typeof definition> {
+//         if (!this.path) {
+//             this.path = nanoid()
+//         }
+//         return {
+//             value: this.path
+//         };
+//     }
+
+//     load(data: Data) {
+//     }
+
+//     save() {
+//         return {
+//         }
+//     }
+// }

package/src/unzip.spec.ts

@@ -0,0 +1,33 @@
+import { expect, test } from "vitest";
+import { unzipRunner } from "./unzip.js";
+import { browserWindow } from "@pipelab/shared";
+
+test("adds 1 + 2 to equal 3", async () => {
+  const outputs: Record<string, unknown> = {};
+  // await unzipRunner({
+  //   inputs: {
+  //     file: ''
+  //   },
+  //   log: (...args) => {
+  //     console.log(...args)
+  //   },
+  //   setOutput: (key, value) => {
+  //     outputs[key] = value
+  //   },
+  //   meta: {
+  //     definition: ''
+  //   },
+  //   setMeta: () => {
+  //     console.log('set meta defined here')
+  //   },
+  //   cwd: '',
+  //   paths: {
+  //     assets: '',
+  //     unpack: ''
+  //   },
+  //   api: undefined,
+  //   browserWindow,
+  // })
+  console.log("outputs", outputs);
+  expect(true).toBe(true);
+}, 120_000);

package/src/unzip.ts

@@ -0,0 +1,58 @@
+import StreamZip from "node-stream-zip";
+import { join } from "node:path";
+import { createAction, createActionRunner, createPathParam } from "@pipelab/plugin-core";
+
+export const ID = "unzip-file-node";
+
+export const unzip = createAction({
+  id: ID,
+  name: "Unzip file",
+  displayString: '`Unzip ${fmt.param(params.file, "primary", "No file specified")}`',
+  params: {
+    file: createPathParam("", {
+      required: true,
+      control: {
+        type: "path",
+        options: {
+          properties: ["openFile"],
+        },
+      },
+      label: "File",
+    }),
+  },
+
+  outputs: {
+    output: {
+      value: "",
+      label: "Output",
+    },
+  },
+  description: "Unzip a file to a specified folder",
+  icon: "",
+  meta: {},
+});
+
+export const unzipRunner = createActionRunner<typeof unzip>(
+  async ({ log, inputs, setOutput, cwd }) => {
+    console.log("inputs", inputs);
+
+    console.log("inputs.file", inputs.file);
+    const file = inputs.file;
+    console.log("file", file);
+    const output = join(cwd);
+
+    console.log("file", file);
+    console.log("output", output);
+
+    log("Unzip file", inputs.file, "to", output);
+
+    const zip = new StreamZip.async({ file });
+
+    const bytes = await zip.extract(null, output);
+    await zip.close();
+
+    console.log("bytes", bytes);
+
+    setOutput("output", output);
+  },
+);

package/src/zip-v2.ts

@@ -0,0 +1,120 @@
+import { createWriteStream } from "node:fs";
+import { join } from "node:path";
+import archiver from "archiver";
+import { createAction, createActionRunner, createPathParam } from "@pipelab/plugin-core";
+
+export const ID = "zip-v2-node";
+
+export type MaybeArray<T> = T | T[];
+
+export const getValue = <T>(array: MaybeArray<T>): T => {
+  if (Array.isArray(array)) {
+    return array[0];
+  } else {
+    return array;
+  }
+};
+
+export const zipV2 = createAction({
+  id: ID,
+  name: "Zip",
+  displayString: '`Zip ${fmt.param(params.folder, "primary", "No folder specified")}`',
+  params: {
+    folder: createPathParam("", {
+      required: true,
+      control: {
+        type: "path",
+        options: {
+          properties: ["openDirectory"],
+        },
+      },
+      label: "Folder",
+    }),
+  },
+
+  outputs: {
+    path: {
+      value: "",
+      label: "Path",
+    },
+  },
+  description: "Zip a folder into a .zip file",
+  icon: "",
+  meta: {},
+});
+
+export const zipV2Runner = createActionRunner<typeof zipV2>(
+  async ({ log, inputs, setOutput, abortSignal, paths }) => {
+    abortSignal.addEventListener("abort", () => {
+      throw new Error("Aborted");
+    });
+
+    const outputDir = paths.cache;
+    const outputFile = join(outputDir, "output.zip");
+
+    console.log("outputFile", outputFile);
+
+    const output = createWriteStream(outputFile);
+
+    const archive = archiver("zip", {
+      zlib: { level: 9 }, // Sets the compression level.
+    });
+
+    return new Promise((resolve, reject) => {
+      output.on("close", function () {
+        console.log(archive.pointer() + " total bytes");
+        console.log("archiver has been finalized and the output file descriptor has closed.");
+
+        setOutput("path", outputFile);
+        resolve();
+      });
+
+      output.on("end", function () {
+        console.log("Data has been drained");
+      });
+
+      archive.on("warning", function (err) {
+        if (err.code === "ENOENT") {
+          console.log("Archiver warning: ENOENT");
+        } else {
+          reject(err);
+        }
+      });
+
+      archive.on("error", function (err) {
+        reject(err);
+      });
+
+      // archive.on('data', function (data) {
+      //   log('data', data)
+      // })
+      // archive.on('progress', function (data) {
+      //   /* {
+      //     entries:
+      //      {
+      //        total: 5012,
+      //        processed: 5012
+      //      },
+      //     fs:
+      //      {
+      //        totalBytes: 318794388,
+      //        processedBytes: 318794388
+      //      }
+      //   } */
+      //   // log('progress', data.entries.processed + '/' + data.entries.total)
+      // })
+      archive.on("entry", function (data) {
+        log("Adding", data.name);
+      });
+      archive.on("finish", function () {
+        log("finish");
+      });
+
+      archive.pipe(output);
+
+      archive.directory(inputs.folder, false);
+
+      archive.finalize();
+    });
+  },
+);

package/src/zip.ts

@@ -0,0 +1,133 @@
+import { createWriteStream } from "node:fs";
+import archiver from "archiver";
+import { createAction, createActionRunner, createPathParam } from "@pipelab/plugin-core";
+
+export const ID = "zip-node";
+
+export type MaybeArray<T> = T | T[];
+
+export const getValue = <T>(array: MaybeArray<T>): T => {
+  if (Array.isArray(array)) {
+    return array[0];
+  } else {
+    return array;
+  }
+};
+
+export const zip = createAction({
+  id: ID,
+  name: "Zip",
+  updateAvailable: true,
+  displayString:
+    '`Zip ${fmt.param(params.folder, "primary", "No folder specified")} to ${fmt.param(params.output, "secondary", "No output specified")}`',
+  params: {
+    folder: createPathParam("", {
+      required: true,
+      control: {
+        type: "path",
+        options: {
+          properties: ["openDirectory"],
+        },
+      },
+      label: "Folder",
+    }),
+    output: createPathParam("", {
+      required: true,
+      control: {
+        type: "path",
+        options: {
+          properties: ["openFile", "promptToCreate"],
+          // must be zip file
+          filters: [
+            {
+              extensions: ["zip"],
+              name: "Zip file",
+            },
+          ],
+        },
+      },
+      label: "Folder",
+    }),
+  },
+
+  outputs: {
+    path: {
+      value: "",
+      label: "Path",
+    },
+  },
+  description: "Zip a folder into a .zip file",
+  icon: "",
+  meta: {},
+});
+
+export const zipRunner = createActionRunner<typeof zip>(
+  async ({ log, inputs, setOutput, abortSignal }) => {
+    abortSignal.addEventListener("abort", () => {
+      throw new Error("Aborted");
+    });
+
+    const output = createWriteStream(inputs.output);
+
+    const archive = archiver("zip", {
+      zlib: { level: 9 }, // Sets the compression level.
+    });
+
+    return new Promise((resolve, reject) => {
+      output.on("close", function () {
+        console.log(archive.pointer() + " total bytes");
+        console.log("archiver has been finalized and the output file descriptor has closed.");
+
+        setOutput("path", inputs.output);
+        resolve();
+      });
+
+      output.on("end", function () {
+        console.log("Data has been drained");
+      });
+
+      archive.on("warning", function (err) {
+        if (err.code === "ENOENT") {
+          console.log("Archiver warning: ENOENT");
+        } else {
+          reject(err);
+        }
+      });
+
+      archive.on("error", function (err) {
+        reject(err);
+      });
+
+      // archive.on('data', function (data) {
+      //   log('data', data)
+      // })
+      // archive.on('progress', function (data) {
+      //   /* {
+      //     entries:
+      //      {
+      //        total: 5012,
+      //        processed: 5012
+      //      },
+      //     fs:
+      //      {
+      //        totalBytes: 318794388,
+      //        processedBytes: 318794388
+      //      }
+      //   } */
+      //   // log('progress', data.entries.processed + '/' + data.entries.total)
+      // })
+      archive.on("entry", function (data) {
+        log("Adding", data.name);
+      });
+      archive.on("finish", function () {
+        log("finish");
+      });
+
+      archive.pipe(output);
+
+      archive.directory(inputs.folder, false);
+
+      archive.finalize();
+    });
+  },
+);

package/tests/e2e/filesystem.spec.ts

@@ -0,0 +1,103 @@
+import { expect, test, describe, beforeAll, afterAll, afterEach } from "vitest";
+import { mkdir, writeFile, readFile, access } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createSandbox, runAction } from "@pipelab/test-utils";
+import { copyRunner } from "../../src/copy";
+import { removeRunner } from "../../src/remove";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+describe("End-to-End: Filesystem Plugin", () => {
+  let sandbox: Awaited<ReturnType<typeof createSandbox>>;
+
+  afterEach(async () => {
+    if (sandbox) {
+      await sandbox.remove();
+    }
+  });
+
+  test("should copy a file using 'copy' action", { timeout: 60000 }, async () => {
+    sandbox = await createSandbox("fs-copy-e2e");
+    const testPath = sandbox.path;
+    const sourcePath = join(testPath, "source");
+    const destPath = join(testPath, "destination");
+    await mkdir(sourcePath, { recursive: true });
+    await mkdir(destPath, { recursive: true });
+
+    const sourceFile = join(sourcePath, "file.txt");
+    const destFile = join(destPath, "file.txt");
+    await writeFile(sourceFile, "Hello World");
+
+    await runAction(copyRunner, {
+      inputs: {
+        from: sourceFile,
+        to: destFile,
+        recursive: false,
+        overwrite: false,
+        cleanup: false,
+      },
+      sandboxPath: testPath,
+    });
+
+    await expect(access(destFile)).resolves.not.toThrow();
+    const content = await readFile(destFile, "utf-8");
+    expect(content).toBe("Hello World");
+  });
+
+  test("should move a file using 'copy' then 'remove' actions", { timeout: 60000 }, async () => {
+    sandbox = await createSandbox("fs-move-e2e");
+    const testPath = sandbox.path;
+    const sourcePath = join(testPath, "source");
+    const destPath = join(testPath, "destination");
+    await mkdir(sourcePath, { recursive: true });
+    await mkdir(destPath, { recursive: true });
+
+    const sourceFile = join(sourcePath, "file.txt");
+    const destFile = join(destPath, "file.txt");
+    await writeFile(sourceFile, "File to move");
+
+    // Copy
+    await runAction(copyRunner, {
+      inputs: {
+        from: sourceFile,
+        to: destFile,
+        recursive: false,
+        overwrite: false,
+        cleanup: false,
+      },
+      sandboxPath: testPath,
+    });
+
+    // Remove
+    await runAction(removeRunner, {
+      inputs: {
+        from: sourceFile,
+        recursive: true,
+      },
+      sandboxPath: testPath,
+    });
+
+    await expect(access(destFile)).resolves.not.toThrow();
+    await expect(access(sourceFile)).rejects.toThrow();
+  });
+
+  test("should delete a file using 'remove' action", { timeout: 60000 }, async () => {
+    sandbox = await createSandbox("fs-remove-e2e");
+    const testPath = sandbox.path;
+    await mkdir(testPath, { recursive: true });
+    const fileToDelete = join(testPath, "file_to_delete.txt");
+    await writeFile(fileToDelete, "Delete me");
+
+    await runAction(removeRunner, {
+      inputs: {
+        from: fileToDelete,
+        recursive: true,
+      },
+      sandboxPath: testPath,
+    });
+
+    await expect(access(fileToDelete)).rejects.toThrow();
+  });
+});

package/tests/e2e/vitest.config.mts

@@ -0,0 +1,20 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    fileParallelism: false,
+    testTimeout: 60000,
+    hookTimeout: 60000,
+    maxWorkers: 1,
+    minWorkers: 1,
+    poolOptions: {
+      forks: {
+        singleFork: true,
+      },
+    },
+    include: ["**/*.spec.ts"],
+    root: "tests/e2e",
+    environment: "node",
+    env: { NODE_ENV: "development", PIPELAB_DISABLE_HISTORY: "true" },
+  },
+});

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "@pipelab/tsconfig/vue.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}

package/tsdown.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["esm", "cjs"],
+  dts: true,
+  clean: true,
+  loader: {
+    ".webp": "dataurl",
+    ".png": "dataurl",
+    ".jpg": "dataurl",
+    ".jpeg": "dataurl",
+    ".svg": "dataurl",
+  },
+});