@caido-utils/backend 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -1 +1,5 @@
 export { Fetch, type FetchOptions } from "./fetcher";
+export { createSignal, pausePool, resumePool, runPool, stopPool } from "./pool";
+export type { PoolCallbacks, PoolConfig, PoolSignal } from "./pool";
+export { spawnCommand } from "./process";
+export { fileExists, readFile, storeFile } from "./storage";

package/dist/index.js

@@ -1 +1,4 @@
 export { Fetch } from "./fetcher.js";
+export { createSignal, pausePool, resumePool, runPool, stopPool } from "./pool.js";
+export { spawnCommand } from "./process.js";
+export { fileExists, readFile, storeFile } from "./storage.js";

package/dist/pool.d.ts

@@ -0,0 +1,28 @@
+export type PoolSignal = {
+    stopped: boolean;
+    paused: boolean;
+};
+export type PoolConfig = {
+    concurrency: number;
+    delayMs?: number;
+};
+export type PoolCallbacks<TItem> = {
+    onProgress?: (progress: {
+        completed: number;
+        total: number;
+    }) => void;
+    onError?: (item: TItem, error: string) => void;
+};
+export declare function createSignal(): PoolSignal;
+export declare function stopPool(signal: PoolSignal): void;
+export declare function pausePool(signal: PoolSignal): void;
+export declare function resumePool(signal: PoolSignal): void;
+export declare function runPool<TItem>(opts: {
+    items: TItem[] | AsyncIterable<TItem>;
+    config: PoolConfig;
+    signal: PoolSignal;
+    run: (item: TItem) => Promise<void>;
+    callbacks?: PoolCallbacks<TItem>;
+}): Promise<{
+    completed: number;
+}>;

package/dist/pool.js

@@ -0,0 +1,85 @@
+export function createSignal() {
+  return { stopped: false, paused: false };
+}
+export function stopPool(signal) {
+  signal.stopped = true;
+}
+export function pausePool(signal) {
+  signal.paused = true;
+}
+export function resumePool(signal) {
+  signal.paused = false;
+}
+const PAUSE_POLL_MS = 200;
+const YIELD_EVERY = 10;
+function yieldTick() {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+function delay(ms) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function waitForUnpause(signal) {
+  if (!signal.paused || signal.stopped) return Promise.resolve();
+  return new Promise((resolve) => {
+    const poll = () => {
+      if (!signal.paused || signal.stopped) {
+        resolve();
+        return;
+      }
+      setTimeout(poll, PAUSE_POLL_MS);
+    };
+    setTimeout(poll, PAUSE_POLL_MS);
+  });
+}
+async function materializeItems(source) {
+  if (Array.isArray(source)) return source;
+  const items = [];
+  for await (const item of source) {
+    items.push(item);
+  }
+  return items;
+}
+export async function runPool(opts) {
+  const { config, signal, run, callbacks } = opts;
+  const items = await materializeItems(opts.items);
+  const total = items.length;
+  const delayMs = config.delayMs ?? 0;
+  let nextIndex = 0;
+  let completed = 0;
+  async function worker() {
+    let localCount = 0;
+    while (nextIndex < items.length) {
+      if (signal.stopped) return;
+      await waitForUnpause(signal);
+      if (signal.stopped) return;
+      const idx = nextIndex++;
+      const item = items[idx];
+      if (item === void 0) return;
+      try {
+        await run(item);
+        completed++;
+      } catch (error) {
+        completed++;
+        if (callbacks?.onError) {
+          const message = error instanceof Error ? error.message : "Unknown error";
+          callbacks.onError(item, message);
+        }
+      }
+      if (callbacks?.onProgress) {
+        callbacks.onProgress({ completed, total });
+      }
+      localCount++;
+      if (localCount % YIELD_EVERY === 0) {
+        await yieldTick();
+      }
+      if (delayMs > 0) {
+        await delay(delayMs);
+      }
+    }
+  }
+  const workerCount = Math.min(config.concurrency, items.length);
+  const workers = Array.from({ length: workerCount }, () => worker());
+  await Promise.all(workers);
+  return { completed };
+}

package/dist/process.d.ts

@@ -0,0 +1,2 @@
+import type { SDK } from "caido:plugin";
+export declare function spawnCommand(sdk: SDK, binary: string, args: string[], stdin?: string): Promise<string>;

package/dist/process.js

@@ -0,0 +1,58 @@
+import {
+  spawn as nodeSpawn
+} from "child_process";
+import { access, constants } from "fs/promises";
+import * as path from "path";
+async function ensureBinaryExecutable(binaryPath, sdk) {
+  try {
+    await access(binaryPath, constants.F_OK | constants.X_OK);
+  } catch {
+    try {
+      await makeExecutable(binaryPath);
+    } catch (chmodError) {
+      sdk.console.error(
+        `Failed to make ${binaryPath} executable: ${chmodError}`
+      );
+      throw new Error(`Cannot make binary executable: ${chmodError}`);
+    }
+  }
+}
+async function makeExecutable(binaryPath) {
+  const child = nodeSpawn("chmod", ["+x", binaryPath], {
+    shell: true
+  });
+  await driveChild(child);
+}
+export async function spawnCommand(sdk, binary, args, stdin) {
+  try {
+    const binaryPath = path.join(sdk.meta.assetsPath(), binary);
+    await ensureBinaryExecutable(binaryPath, sdk);
+    const child = nodeSpawn(binaryPath, args);
+    if (stdin !== void 0) {
+      child.stdin.write(stdin);
+      child.stdin.end();
+    }
+    const output = await driveChild(child);
+    return output;
+  } catch (error) {
+    sdk.console.error(`Spawn command error (${binary}): ${error}`);
+    throw error;
+  }
+}
+async function driveChild(child, allowExitCode1 = false) {
+  let output = "";
+  child.stdout.on("data", (data) => {
+    output += data.toString();
+  });
+  let error = "";
+  child.stderr.on("data", (data) => {
+    error += data.toString();
+  });
+  const exitCode = await new Promise((resolve) => {
+    child.on("close", resolve);
+  });
+  if (exitCode !== void 0 && exitCode !== 0 && !(allowExitCode1 && exitCode === 1)) {
+    throw new Error(`subprocess error exit ${exitCode}, ${error}`);
+  }
+  return output;
+}

package/dist/storage.d.ts

@@ -0,0 +1,9 @@
+import type { SDK } from "caido:plugin";
+type StoreFileOptions = {
+    data: string;
+    contentType?: string;
+};
+export declare function storeFile(sdk: SDK, options: StoreFileOptions): Promise<string>;
+export declare function readFile(fsPath: string): Promise<string>;
+export declare function fileExists(fsPath: string): Promise<boolean>;
+export {};

package/dist/storage.js

@@ -0,0 +1,45 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+const extensionMap = {
+  "application/javascript": ".js",
+  "application/x-javascript": ".js",
+  "text/javascript": ".js",
+  "text/html": ".html",
+  "application/json": ".json",
+  "application/xml": ".xml",
+  "text/xml": ".xml",
+  "text/css": ".css",
+  "text/plain": ".txt",
+  "application/typescript": ".ts"
+};
+function getExtensionFromContentType(contentType) {
+  if (contentType === void 0) return "";
+  return extensionMap[contentType.toLowerCase()] ?? "";
+}
+function generateFileName(contentType) {
+  const randomName = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+  const extension = getExtensionFromContentType(contentType);
+  return randomName + extension;
+}
+export async function storeFile(sdk, options) {
+  const { data, contentType } = options;
+  const dataDir = sdk.meta.path();
+  const filesDir = path.join(dataDir, "files");
+  await fs.mkdir(filesDir, { recursive: true });
+  const fileName = generateFileName(contentType);
+  const filePath = path.join(filesDir, fileName);
+  await fs.writeFile(filePath, data);
+  return filePath;
+}
+export async function readFile(fsPath) {
+  const content = await fs.readFile(fsPath);
+  return content.toString();
+}
+export async function fileExists(fsPath) {
+  try {
+    await fs.access(fsPath);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caido-utils/backend",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "type": "module",
   "files": [
     "dist"
@@ -11,6 +11,9 @@
       "import": "./dist/index.js"
     }
   },
+  "scripts": {
+    "build": "unbuild"
+  },
   "peerDependencies": {
     "@caido/sdk-backend": ">=0.46.0"
   },
@@ -18,8 +21,5 @@
     "@caido/sdk-backend": "^0.46.0",
     "typescript": "^5.5.4",
     "unbuild": "^3.6.1"
-  },
-  "scripts": {
-    "build": "unbuild"
   }
-}
+}