@pipelab/asset-electron 1.0.0-beta.0

package/template/src/handlers/fs/exist.js

@@ -0,0 +1,37 @@
+// @ts-check
+
+import { access } from "node:fs/promises";
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageExistFile, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ */
+export default async (json, ws) => {
+  try {
+    await access(json.body.path);
+
+    /**
+     * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageExistFile, 'output'>}
+     */
+    const existResult = {
+      correlationId: json.correlationId,
+      url: json.url,
+      body: {
+        success: true,
+      },
+    };
+    ws.send(JSON.stringify(existResult));
+  } catch (e) {
+    /**
+     * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageExistFile, 'output'>}
+     */
+    const existResult = {
+      correlationId: json.correlationId,
+      url: json.url,
+      body: {
+        success: false,
+      },
+    };
+    ws.send(JSON.stringify(existResult));
+  }
+};

package/template/src/handlers/fs/file-size.js

@@ -0,0 +1,24 @@
+// @ts-check
+
+import { stat } from "node:fs/promises";
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageFileSize, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ */
+export default async (json, ws) => {
+  const stats = await stat(json.body.path);
+
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageFileSize, 'output'>}
+   */
+  const readFileResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+      size: stats.size,
+    },
+  };
+  ws.send(JSON.stringify(readFileResult));
+};

package/template/src/handlers/fs/folder-create.js

@@ -0,0 +1,25 @@
+// @ts-check
+
+import { mkdir } from "node:fs/promises";
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageCreateFolder, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ */
+export default async (json, ws) => {
+  await mkdir(json.body.path, {
+    recursive: json.body.recursive,
+  });
+
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageCreateFolder, 'output'>}
+   */
+  const folderCreateResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+    },
+  };
+  ws.send(JSON.stringify(folderCreateResult));
+};

package/template/src/handlers/fs/list.js

@@ -0,0 +1,61 @@
+// @ts-check
+
+import { readdir } from "node:fs/promises";
+import { join, dirname, relative } from "node:path";
+import slash from "slash";
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageListFiles, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ */
+export default async (json, ws) => {
+  // Custom recursive directory listing for Node 18 compatibility
+  async function listDirRecursive(dir, parentPath) {
+    let results = [];
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullpath = join(dir, entry.name);
+      const type = entry.isDirectory() ? "directory" : "file";
+      const relPath = slash(fullpath);
+      results.push({
+        type,
+        name: entry.name,
+        parent: slash(parentPath),
+        path: relPath,
+      });
+      if (entry.isDirectory()) {
+        const subResults = await listDirRecursive(fullpath, fullpath);
+        results = results.concat(subResults);
+      }
+    }
+    return results;
+  }
+
+  let fileList = [];
+  try {
+    fileList = await listDirRecursive(json.body.path, dirname(json.body.path));
+  } catch (err) {
+    console.error("Error listing files:", err);
+    ws.send(
+      JSON.stringify({
+        correlationId: json.correlationId,
+        url: json.url,
+        body: { success: false, error: err.message },
+      }),
+    );
+    return;
+  }
+
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageListFiles, 'output'>}
+   */
+  const readFileResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+      list: fileList,
+    },
+  };
+  ws.send(JSON.stringify(readFileResult));
+};

package/template/src/handlers/fs/move.js

@@ -0,0 +1,30 @@
+// @ts-check
+
+import { moveFile } from "move-file";
+import { mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageMove, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ */
+export default async (json, ws) => {
+  const destDirName = dirname(json.body.destination);
+  await mkdir(destDirName, { recursive: true });
+
+  await moveFile(json.body.source, json.body.destination, {
+    overwrite: json.body.overwrite,
+  });
+
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageMove, 'output'>}
+   */
+  const readFileResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+    },
+  };
+  ws.send(JSON.stringify(readFileResult));
+};

package/template/src/handlers/fs/read-binary.js

@@ -0,0 +1,24 @@
+// @ts-check
+
+import { readFile } from "node:fs/promises";
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageReadFileBinary, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ */
+export default async (json, ws) => {
+  const file = await readFile(json.body.path);
+
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageReadFileBinary, 'output'>}
+   */
+  const readFileResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+      content: [...file],
+    },
+  };
+  ws.send(JSON.stringify(readFileResult));
+};

package/template/src/handlers/fs/read.js

@@ -0,0 +1,42 @@
+// @ts-check
+
+import { readFile } from "node:fs/promises";
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageReadFile, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ */
+export default async (json, ws) => {
+  try {
+    const file = await readFile(json.body.path, {
+      encoding: json.body.encoding,
+    });
+
+    /**
+     * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageReadFile, 'output'>}
+     */
+    const readFileResult = {
+      correlationId: json.correlationId,
+      url: json.url,
+      body: {
+        success: true,
+        content: file,
+      },
+    };
+    ws.send(JSON.stringify(readFileResult));
+  } catch (e) {
+    console.error("e", e);
+    /**
+     * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageReadFile, 'output'>}
+     */
+    const readFileResult = {
+      correlationId: json.correlationId,
+      url: json.url,
+      body: {
+        success: false,
+        error: e.message,
+      },
+    };
+    ws.send(JSON.stringify(readFileResult));
+  }
+};

package/template/src/handlers/fs/write-base64.js

@@ -0,0 +1,32 @@
+// @ts-check
+
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+/**
+ * @param {{url: string, correlationId?: string, body: {path: string, base64Data: string, flag?: string}}} json
+ * @param {import('ws').WebSocket} ws
+ */
+export default async (json, ws) => {
+  const destDirName = dirname(json.body.path);
+  await mkdir(destDirName, { recursive: true });
+
+  // Decode base64 string to buffer
+  const buffer = Buffer.from(json.body.base64Data, "base64");
+
+  await writeFile(json.body.path, buffer, {
+    flag: json.body.flag,
+  });
+
+  /**
+   * @type {{url: string, correlationId?: string, body: {success: boolean}}}
+   */
+  const writeFileResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+    },
+  };
+  ws.send(JSON.stringify(writeFileResult));
+};

package/template/src/handlers/fs/write.js

@@ -0,0 +1,30 @@
+// @ts-check
+
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageWriteFile, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ */
+export default async (json, ws) => {
+  const destDirName = dirname(json.body.path);
+  await mkdir(destDirName, { recursive: true });
+
+  await writeFile(json.body.path, json.body.contents, {
+    encoding: json.body.encoding,
+    flag: json.body.flag,
+  });
+
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageWriteFile, 'output'>}
+   */
+  const writeFileResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+    },
+  };
+  ws.send(JSON.stringify(writeFileResult));
+};

package/template/src/handlers/general/engine.js

@@ -0,0 +1,17 @@
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageEngine, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ */
+export default async (json, ws) => {
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageEngine, 'output'>}
+   */
+  const engineResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      engine: "electron",
+    },
+  };
+  ws.send(JSON.stringify(engineResult));
+};

package/template/src/handlers/general/exit.js

@@ -0,0 +1,20 @@
+import { app } from "electron";
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageExit, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ */
+export default async (json, ws) => {
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageExit, 'output'>}
+   */
+  const engineResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+    },
+  };
+  ws.send(JSON.stringify(engineResult));
+
+  app.exit(json.body.code);
+};

package/template/src/handlers/general/infos.js

@@ -0,0 +1,23 @@
+import { arch, platform } from "os";
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageInfos, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ */
+export default async (json, ws) => {
+  const myArch = arch();
+  const myPlatform = platform();
+
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageInfos, 'output'>}
+   */
+  const engineResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      arch: myArch,
+      platform: myPlatform,
+      version: "0.0.0",
+    },
+  };
+  ws.send(JSON.stringify(engineResult));
+};

package/template/src/handlers/general/open-in-explorer.js

@@ -0,0 +1,21 @@
+import { shell } from "electron";
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageExplorerOpen, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ */
+export default async (json, ws) => {
+  await shell.showItemInFolder(json.body.path);
+
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageExplorerOpen, 'output'>}
+   */
+  const runResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+    },
+  };
+  ws.send(JSON.stringify(runResult));
+};

package/template/src/handlers/general/open.js

@@ -0,0 +1,21 @@
+import { shell } from "electron";
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageOpen, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ */
+export default async (json, ws) => {
+  await shell.openPath(json.body.path);
+
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageOpen, 'output'>}
+   */
+  const runResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+    },
+  };
+  ws.send(JSON.stringify(runResult));
+};

package/template/src/handlers/general/run.js

@@ -0,0 +1,27 @@
+import { execa } from "execa";
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageRun, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ */
+export default async (json, ws) => {
+  const exec = execa({
+    cwd: json.body.cwd,
+    env: json.body.env,
+  });
+  const { stderr, stdout } = await exec(json.body.command, json.body.args);
+
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageRun, 'output'>}
+   */
+  const execResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+      stdout,
+      stderr,
+    },
+  };
+  ws.send(JSON.stringify(execResult));
+};

package/template/src/handlers/steam/deleteItem.js

@@ -0,0 +1,26 @@
+import { handleSteamRequest } from "./utils.js";
+
+/**
+ * Core Steam workshop delete item logic
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @returns {Promise<any>} The delete result
+ */
+const deleteItemHandler = async (client, json) => {
+  const { itemId } = json.body;
+
+  const itemIdBigInt = BigInt(itemId);
+
+  const result = await client.workshop.deleteItem(itemIdBigInt);
+
+  return result;
+};
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ */
+export default async (json, ws, client) => {
+  await handleSteamRequest(client, json, ws, deleteItemHandler);
+};

package/template/src/handlers/steam/download.js

@@ -0,0 +1,26 @@
+import { handleSteamRequest } from "./utils.js";
+
+/**
+ * Core Steam workshop download logic
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @returns {Promise<any>} The download result
+ */
+const downloadHandler = async (client, json) => {
+  const { itemId, highPriority } = json.body;
+
+  const itemIdBigInt = BigInt(itemId);
+
+  const result = client.workshop.download(itemIdBigInt, highPriority);
+
+  return result;
+};
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ */
+export default async (json, ws, client) => {
+  await handleSteamRequest(client, json, ws, downloadHandler);
+};

package/template/src/handlers/steam/downloadInfo.js

@@ -0,0 +1,26 @@
+import { handleSteamRequest } from "./utils.js";
+
+/**
+ * Core Steam workshop download info logic
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @returns {Promise<any>} The download info result
+ */
+const downloadInfoHandler = async (client, json) => {
+  const { itemId } = json.body;
+
+  const itemIdBigInt = BigInt(itemId);
+
+  const result = client.workshop.downloadInfo(itemIdBigInt);
+
+  return result;
+};
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ */
+export default async (json, ws, client) => {
+  await handleSteamRequest(client, json, ws, downloadInfoHandler);
+};

package/template/src/handlers/steam/downloadScore.js

@@ -0,0 +1,28 @@
+import { handleSteamRequest } from "./utils.js";
+
+// * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {import('@pipelab/steamworks.js').Client} client
+ */
+export default async (json, ws, client) => {
+  await handleSteamRequest(client, json, ws, async (client, json) => {
+    const { body } = json;
+    const { name, type, start, end } = body;
+
+    const leaderboard = await client.leaderboards.findLeaderboard(name);
+    /** @type {Awaited<ReturnType<leaderboards['downloadScores']>>} */
+    const result = await client.leaderboards.downloadScores(leaderboard, type, start, end);
+
+    // Enhance each result with the Steam friend name
+    const enhancedResult = await Promise.all(
+      result.map(async (entry) => ({
+        ...entry,
+        name: await client.friends.getFriendName(entry.steamId),
+      })),
+    );
+
+    return enhancedResult;
+  });
+};

package/template/src/handlers/steam/getItem.js

@@ -0,0 +1,28 @@
+import { handleSteamRequest } from "./utils.js";
+
+/**
+ * Core Steam workshop get item logic
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @returns {Promise<any>} The item result
+ */
+const getItemHandler = async (client, json) => {
+  const { itemId } = json.body;
+
+  // Convert itemId from string to BigInt
+  const itemIdBigInt = BigInt(itemId);
+
+  // TODO: Handle queryConfig parameter when needed
+  const result = await client.workshop.getItem(itemIdBigInt);
+
+  return result;
+};
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ */
+export default async (json, ws, client) => {
+  await handleSteamRequest(client, json, ws, getItemHandler);
+};

package/template/src/handlers/steam/getItems.js

@@ -0,0 +1,28 @@
+import { handleSteamRequest } from "./utils.js";
+
+/**
+ * Core Steam workshop get items logic
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @returns {Promise<any>} The items result
+ */
+const getItemsHandler = async (client, json) => {
+  const { itemIds } = json.body;
+
+  // Convert array of string itemIds to array of BigInts
+  const itemIdsBigInt = itemIds.map((id) => BigInt(id));
+
+  // TODO: Handle queryConfig parameter when needed
+  const result = await client.workshop.getItems(itemIdsBigInt);
+
+  return result;
+};
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ */
+export default async (json, ws, client) => {
+  await handleSteamRequest(client, json, ws, getItemsHandler);
+};

package/template/src/handlers/steam/installInfo.js

@@ -0,0 +1,26 @@
+import { handleSteamRequest } from "./utils.js";
+
+/**
+ * Core Steam workshop install info logic
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @returns {Promise<any>} The install info result
+ */
+const installInfoHandler = async (client, json) => {
+  const { itemId } = json.body;
+
+  const itemIdBigInt = BigInt(itemId);
+
+  const result = client.workshop.installInfo(itemIdBigInt);
+
+  return result;
+};
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ */
+export default async (json, ws, client) => {
+  await handleSteamRequest(client, json, ws, installInfoHandler);
+};