@pipelab/plugin-construct 1.0.0-beta.0

package/src/export-shared.ts

@@ -0,0 +1,286 @@
+import {
+  Action,
+  ActionRunnerData,
+  createNumberParam,
+  createPasswordParam,
+  createPathParam,
+  createStringParam,
+  InputsDefinition,
+  ParamsToInput,
+  runWithLiveLogs,
+  fetchPackage,
+} from "@pipelab/plugin-core";
+import { script } from "./assets/script.js";
+import * as v from "valibot";
+import { BrowserContext } from "playwright";
+import { dirname, join, delimiter } from "node:path";
+import { cp, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { createRequire } from "node:module";
+
+const platform = process.platform;
+const { LOCALAPPDATA, XDG_CONFIG_HOME } = process.env;
+
+const isCI = process.env.CI === "true";
+
+let baseProfile;
+if (platform === "win32") {
+  baseProfile = join(LOCALAPPDATA ?? "", "Google", "Chrome", "User Data");
+} else if (platform === "linux") {
+  baseProfile = join(XDG_CONFIG_HOME ?? "", "google-chrome");
+} else if (platform === "darwin") {
+  baseProfile = join(homedir(), "Library", "Application Support", "Google", "Chrome");
+}
+
+export const sharedParams = {
+  username: createStringParam("", {
+    label: "Username",
+    required: false,
+    description: "Your Construct username",
+  }),
+  password: createPasswordParam("", {
+    description:
+      "Your Construct password. Will only be used locally to automate the export on Construct website via a local browser. Will not be sent to any server.",
+    required: false,
+    label: "Password",
+  }),
+  version: createStringParam("", {
+    description: "The Construct version you want to use",
+    label: "Version",
+    required: false,
+  }),
+  headless: {
+    description: "Whether to show the browser while export",
+    required: false,
+    control: {
+      type: "boolean",
+    },
+    value: false,
+    label: "Start headless",
+  },
+  timeout: createNumberParam(120, {
+    description: "The timeout (in seconds) to close the browser if it's stuck",
+    required: false,
+    label: "Timeout",
+  }),
+  // customBrowser: {
+  //   description: 'Start your own browser rather than the predefined one',
+  //   control: {
+  //     type: 'path',
+  //     options: {
+  //       properties: ['openFile']
+  //     }
+  //   },
+  //   label: 'Custom browser',
+  //   value: ''
+  // },
+  customProfile: createPathParam(undefined, {
+    required: false,
+    description:
+      "Use your own profile (X:\\Users\\XXX\\AppData\\Local\\Google\\Chrome\\User Data). Usefull if you want to reuse plugins installed in your current browser",
+    control: {
+      type: "path",
+      options: {
+        properties: ["openDirectory"],
+        defaultPath: baseProfile,
+      },
+    },
+    label: "Custom profile",
+  }),
+  // addonsFolder: {
+  //   description: 'Folder containing addons to import in the editor',
+  //   required: false,
+  //   control: {
+  //     type: 'path',
+  //     options: {
+  //       buttonLabel: 'Addons folder',
+  //       properties: ['openDirectory']
+  //     }
+  //   },
+  //   value: '',
+  //   label: 'Addons folder'
+  // }
+} satisfies InputsDefinition;
+
+type Inputs = ParamsToInput<typeof sharedParams>;
+
+export const exportc3p = async <ACTION extends Action>(
+  file: string,
+  { cwd, log, inputs, setOutput, paths, abortSignal, context: ctx }: ActionRunnerData<ACTION>,
+) => {
+  let browserContext: BrowserContext | undefined = undefined;
+  let browser: any | undefined = undefined;
+
+  abortSignal.addEventListener("abort", () => {
+    console.error("aborted");
+
+    browserContext?.close();
+  });
+  const newInputs = inputs as Inputs;
+
+  // const { addonsFolder } = newInputs
+
+  const { thirdparty, node, pnpm } = paths;
+
+  const browserName: "chromium" | "firefox" | "webkit" = "chromium";
+
+  const { packageDir: playwrightPkgPath } = await fetchPackage("playwright-core", "1.48.2", {
+    installDeps: true,
+    context: ctx,
+  });
+  const playwrightCli = join(playwrightPkgPath, "cli.js");
+  const browsersPath = join(thirdparty, "playwright-browsers");
+
+  process.env.PLAYWRIGHT_BROWSERS_PATH = browsersPath;
+
+  log("Downloading browser to", browsersPath);
+  await runWithLiveLogs(
+    node,
+    [playwrightCli, "install", browserName],
+    {
+      env: {
+        ...process.env,
+        PLAYWRIGHT_BROWSERS_PATH: browsersPath,
+        PATH: `${dirname(node)}${delimiter}${process.env.PATH}`,
+      },
+      cancelSignal: abortSignal,
+    },
+    log,
+    {
+      onStdout(data) {
+        log(data);
+      },
+      onStderr(data) {
+        log(data);
+      },
+    },
+  );
+
+  const require = createRequire(import.meta.url);
+  const playwrightModule = require(join(playwrightPkgPath, "index.js"));
+  const playwright = playwrightModule.default || playwrightModule;
+
+  const downloadDir = join(cwd, "playwright");
+
+  log("Browser downloaded to", downloadDir);
+
+  log("Exporting construct project");
+
+  console.log("newInputs", newInputs);
+
+  const browserInstance = playwright[browserName];
+
+  let version = newInputs.version;
+  // if version is full digit, prepend "r", otherwise, use as is
+  if (version && /^\d+$/.test(version as string)) {
+    version = `r${version}`;
+  }
+  const headless = newInputs.headless;
+
+  // if (newInputs.customBrowser && !newInputs.customProfile) {
+  //   throw new Error('You must specify a custom profile when using a custom browser')
+  // }
+
+  // if (!newInputs.customBrowser && newInputs.customProfile) {
+  //   throw new Error('You must specify a custom browser when using a custom profile')
+  // }
+
+  // if (newInputs.customBrowser && newInputs.customProfile) {
+  if (newInputs.customProfile) {
+    const customProfile = join(cwd, "playwright-profile");
+
+    await mkdir(customProfile, {
+      recursive: true,
+    });
+
+    const indexedDbPathSource = join(newInputs.customProfile as string, "Default", "IndexedDB");
+    const indexedDbPathDestination = join(customProfile, "Default", "IndexedDB");
+    const pathsToCopy = [
+      "https_editor.construct.net_0.indexeddb.blob",
+      "https_editor.construct.net_0.indexeddb.leveldb",
+    ];
+
+    for (const p of pathsToCopy) {
+      const from = join(indexedDbPathSource, p);
+      const to = join(indexedDbPathDestination, p);
+      await cp(from, to, { recursive: true });
+    }
+
+    browserContext = await browserInstance.launchPersistentContext(customProfile, {
+      headless: headless as boolean,
+      locale: "en-US",
+      recordVideo: isCI
+        ? {
+            dir: join(process.cwd(), "playwright"),
+          }
+        : undefined,
+    });
+  } else {
+    browser = await browserInstance.launch({
+      headless: headless as boolean,
+    });
+
+    browserContext = await browser.newContext({
+      locale: "en-US",
+      recordVideo: isCI
+        ? {
+            dir: join(process.cwd(), "playwright"),
+          }
+        : undefined,
+    });
+    await browserContext?.clearPermissions();
+  }
+
+  if (!browserContext) {
+    throw new Error("Failed to initialize browser context");
+  }
+
+  const page = await browserContext.newPage();
+
+  page.setDefaultTimeout((newInputs.timeout as number) * 1000);
+
+  // this exact sequn=ence make it work
+  await page.addInitScript(() => {
+    // @ts-expect-error dds
+    delete self.showOpenFilePicker;
+  });
+  page.on("filechooser", (worker) => {
+    console.log("filechooser created: " + worker.page.name);
+  });
+  // ---------------------------------
+
+  try {
+    const result = await script(
+      page,
+      log,
+      file,
+      newInputs.username as string,
+      newInputs.password as string,
+      version as string,
+      downloadDir,
+      // addonsFolder,
+    );
+
+    log("Setting output result to ", result);
+
+    setOutput("folder", result); // deprecated
+
+    setOutput("parentFolder", dirname(result));
+    setOutput("zipFile", result);
+  } catch (e: any) {
+    log("error, no result, crashed", e);
+    throw new Error("ConstructExport failed: " + e.message);
+  } finally {
+    if (browserContext) {
+      await browserContext.close();
+    }
+    if (browser) {
+      await browser.close();
+    }
+  }
+};
+
+export const constructVersionValidator = (options: any) => {
+  void options;
+  return v.pipe(v.string(), v.regex(/^\d+(-\d+)?$/, "Invalid version"));
+};

package/src/export.test.ts

@@ -0,0 +1,37 @@
+import { expect, test } from "vitest";
+import { ExportActionRunner } from "./export-c3p.js";
+import { browserWindow } from "@pipelab/shared";
+
+test("adds 1 + 2 to equal 3", async () => {
+  const outputs: Record<string, unknown> = {};
+  // await ExportActionRunner({
+  //   inputs: {
+  //     password: '123',
+  //     headless: false,
+  //     username: 'abc',
+  //     version: '350',
+  //     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/index.ts

@@ -0,0 +1,34 @@
+import { createNodeDefinition } from "@pipelab/plugin-core";
+import { exportAction, ExportActionRunner } from "./export-c3p";
+import { exportProjectAction, ExportProjectActionRunner } from "./export-project";
+const icon = new URL("./assets/construct.webp", import.meta.url).href;
+import { constructVersionValidator } from "./export-shared";
+
+export default createNodeDefinition({
+  description: "Construct",
+  name: "Construct",
+  id: "construct",
+  icon: {
+    type: "image",
+    image: icon,
+  },
+  nodes: [
+    {
+      node: exportAction,
+      runner: ExportActionRunner,
+    },
+    {
+      node: exportProjectAction,
+      runner: ExportProjectActionRunner,
+    },
+  ],
+  validators: [
+    // {
+    //   id: 'construct-version',
+    //   description: 'Version must be a valid semver',
+    //   validator: constructVersionValidator
+    // }
+  ],
+});
+
+export type { Params as ExportParams } from "./export-c3p";

package/tests/e2e/construct.spec.ts

@@ -0,0 +1,60 @@
+import { expect, test, describe, afterEach } from "vitest";
+import { readFile, access } from "node:fs/promises";
+import { join, resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createSandbox, runAction } from "@pipelab/test-utils";
+import { ExportActionRunner } from "../../src/export-c3p";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const fixturesPath = join(__dirname, "fixtures");
+
+describe("End-to-End: Construct 3 Export Pipeline", () => {
+  let sandbox: Awaited<ReturnType<typeof createSandbox>>;
+
+  afterEach(async () => {
+    if (sandbox) {
+      await sandbox.remove();
+    }
+  });
+
+  test(
+    "should run the full C3 export action",
+    async () => {
+      sandbox = await createSandbox("c3-pipeline-e2e");
+      const fixtures = fixturesPath;
+      const jsonProject = JSON.parse(await readFile(join(fixtures, "c3-export.json"), "utf-8"));
+
+      // 1. Prepare inputs
+      const testC3pPath = resolve(fixtures, "c3-export/test.c3p");
+      const blockParams = jsonProject.canvas?.blocks?.[0]?.params;
+
+      const inputs = {
+        file: testC3pPath,
+        version: JSON.parse(blockParams?.version?.value || '"stable"'),
+        type: JSON.parse(blockParams?.type?.value || '"web"'),
+        // Add other required inputs from sharedParams if needed
+      };
+
+      // 2. Run the action directly
+      const result = await runAction(ExportActionRunner, {
+        inputs,
+        sandboxPath: sandbox.path,
+      });
+
+      // 3. Verification
+      const outputs = result.outputs;
+      expect(outputs).toBeDefined();
+
+      expect(outputs.folder).toEqual(expect.any(String));
+      expect(outputs.parentFolder).toEqual(expect.any(String));
+      expect(outputs.zipFile).toEqual(expect.any(String));
+
+      // Verify that the output files/folders actually exist
+      await expect(access(outputs.folder as string)).resolves.not.toThrow();
+      await expect(access(outputs.parentFolder as string)).resolves.not.toThrow();
+      await expect(access(outputs.zipFile as string)).resolves.not.toThrow();
+    },
+    10 * 60 * 1000,
+  );
+});

package/tests/e2e/fixtures/c3-export.json

@@ -0,0 +1,51 @@
+{
+  "description": "Export from Construct, package with Electron, then upload to Steam",
+  "name": "From Construct to Steam",
+  "variables": [],
+  "canvas": {
+    "triggers": [
+      {
+        "type": "event",
+        "origin": {
+          "pluginId": "system",
+          "nodeId": "manual"
+        },
+        "uid": "manual-start",
+        "params": {}
+      }
+    ],
+    "blocks": [
+      {
+        "uid": "export-construct-project",
+        "type": "action",
+        "origin": {
+          "nodeId": "export-construct-project",
+          "pluginId": "construct"
+        },
+        "params": {
+          "file": {
+            "editor": "editor",
+            "value": "\"./tests/e2e/fixtures/c3-export/test.c3p\""
+          },
+          "username": {
+            "editor": "editor",
+            "value": ""
+          },
+          "password": {
+            "editor": "editor",
+            "value": ""
+          },
+          "version": {
+            "editor": "editor",
+            "value": ""
+          },
+          "headless": {
+            "editor": "editor",
+            "value": true
+          }
+        }
+      }
+    ]
+  },
+  "version": "3.0.0"
+}

package/tests/e2e/fixtures/html-export/index.html

@@ -0,0 +1,29 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Test</title>
+  </head>
+  <body>
+    OK
+    <script>
+      // window.electronAPI.exit(0)
+
+      const ws = new WebSocket("ws://localhost:31753");
+
+      ws.onopen = () => {
+        console.log("WebSocket opened");
+
+        /** @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageExit, 'input'>} */
+        const orderPath = {
+          url: "/exit",
+          body: {
+            code: 0,
+          },
+        };
+        ws.send(JSON.stringify(orderPath));
+      };
+    </script>
+  </body>
+</html>

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,10 @@
+{
+  "extends": "@pipelab/tsconfig/vue.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "types": ["node"],
+    "skipLibCheck": true
+  },
+  "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",
+  },
+});