@caido-utils/backend 0.2.0 → 0.4.0

package/dist/index.d.ts

@@ -1,3 +1,6 @@
 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 { getProjectId } from "./project";
+export { fileExists, readFile, storeFile } from "./storage";

package/dist/index.js

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

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/project.d.ts

@@ -0,0 +1,2 @@
+import type { SDK } from "caido:plugin";
+export declare function getProjectId(sdk: SDK): Promise<string>;

package/dist/project.js

@@ -0,0 +1,8 @@
+export async function getProjectId(sdk) {
+  const project = await sdk.projects.getCurrent();
+  const projectId = project?.getId().toString();
+  if (projectId === void 0) {
+    throw new Error("Project not found");
+  }
+  return projectId;
+}

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.2.0",
+  "version": "0.4.0",
   "type": "module",
   "files": [
     "dist"