@zbruceli/openclaw-dchat 0.1.11 → 0.3.0

package/src/ipfs.test.ts

@@ -0,0 +1,301 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import http from "http";
+import { EventEmitter } from "events";
+import { IpfsService, IPFS_FILE_TYPE, mimeToIpfsFileType, buildFileMetadata } from "./ipfs.js";
+import { decryptAesGcm, encryptAesGcm, keyToByteArray, byteArrayToKey } from "./crypto.js";
+
+describe("mimeToIpfsFileType", () => {
+  it("maps image/* to IMAGE (1)", () => {
+    expect(mimeToIpfsFileType("image/png")).toBe(IPFS_FILE_TYPE.IMAGE);
+    expect(mimeToIpfsFileType("image/jpeg")).toBe(IPFS_FILE_TYPE.IMAGE);
+    expect(mimeToIpfsFileType("image/gif")).toBe(IPFS_FILE_TYPE.IMAGE);
+    expect(mimeToIpfsFileType("Image/WebP")).toBe(IPFS_FILE_TYPE.IMAGE);
+  });
+
+  it("maps audio/* to AUDIO (2)", () => {
+    expect(mimeToIpfsFileType("audio/mpeg")).toBe(IPFS_FILE_TYPE.AUDIO);
+    expect(mimeToIpfsFileType("audio/ogg")).toBe(IPFS_FILE_TYPE.AUDIO);
+    expect(mimeToIpfsFileType("Audio/WAV")).toBe(IPFS_FILE_TYPE.AUDIO);
+  });
+
+  it("maps video/* to VIDEO (3)", () => {
+    expect(mimeToIpfsFileType("video/mp4")).toBe(IPFS_FILE_TYPE.VIDEO);
+    expect(mimeToIpfsFileType("Video/WebM")).toBe(IPFS_FILE_TYPE.VIDEO);
+  });
+
+  it("maps unknown types to FILE (0)", () => {
+    expect(mimeToIpfsFileType("application/pdf")).toBe(IPFS_FILE_TYPE.FILE);
+    expect(mimeToIpfsFileType("text/plain")).toBe(IPFS_FILE_TYPE.FILE);
+  });
+
+  it("defaults to IMAGE when undefined", () => {
+    expect(mimeToIpfsFileType(undefined)).toBe(IPFS_FILE_TYPE.IMAGE);
+  });
+});
+
+describe("IPFS_FILE_TYPE constants", () => {
+  it("has correct values", () => {
+    expect(IPFS_FILE_TYPE.FILE).toBe(0);
+    expect(IPFS_FILE_TYPE.IMAGE).toBe(1);
+    expect(IPFS_FILE_TYPE.AUDIO).toBe(2);
+    expect(IPFS_FILE_TYPE.VIDEO).toBe(3);
+  });
+});
+
+describe("IpfsService.buildMessageOptions", () => {
+  const service = new IpfsService("10.0.0.1:5001");
+
+  const fakeResult = {
+    hash: "QmTestHash123",
+    key: Buffer.alloc(16, 0xab),
+    nonce: Buffer.alloc(12, 0xcd),
+    nonceSize: 12,
+  };
+
+  it("produces correct wire format for IMAGE", () => {
+    const opts = service.buildMessageOptions(fakeResult, IPFS_FILE_TYPE.IMAGE);
+
+    expect(opts.ipfsHash).toBe("QmTestHash123");
+    expect(opts.ipfsIp).toBe("10.0.0.1:5001");
+    expect(opts.ipfsEncrypt).toBe(1);
+    expect(opts.ipfsEncryptAlgorithm).toBe("AES/GCM/NoPadding");
+    expect(opts.ipfsEncryptKeyBytes).toEqual(keyToByteArray(fakeResult.key));
+    expect(opts.ipfsEncryptNonceSize).toBe(12);
+    expect(opts.fileType).toBe(IPFS_FILE_TYPE.IMAGE);
+  });
+
+  it("produces correct wire format for AUDIO with duration", () => {
+    const opts = service.buildMessageOptions(fakeResult, IPFS_FILE_TYPE.AUDIO, {
+      mediaDuration: 5.3,
+      fileMimeType: "audio/ogg",
+    });
+
+    expect(opts.fileType).toBe(IPFS_FILE_TYPE.AUDIO);
+    expect(opts.mediaDuration).toBe(5.3);
+    expect(opts.fileMimeType).toBe("audio/ogg");
+  });
+
+  it("produces correct wire format for FILE with name/ext", () => {
+    const opts = service.buildMessageOptions(fakeResult, IPFS_FILE_TYPE.FILE, {
+      fileName: "doc.pdf",
+      fileExt: ".pdf",
+      fileMimeType: "application/pdf",
+      fileSize: 12345,
+    });
+
+    expect(opts.fileType).toBe(IPFS_FILE_TYPE.FILE);
+    expect(opts.fileName).toBe("doc.pdf");
+    expect(opts.fileExt).toBe(".pdf");
+    expect(opts.fileMimeType).toBe("application/pdf");
+    expect(opts.fileSize).toBe(12345);
+  });
+
+  it("omits optional extra fields when not provided", () => {
+    const opts = service.buildMessageOptions(fakeResult, IPFS_FILE_TYPE.IMAGE);
+
+    expect(opts.fileMimeType).toBeUndefined();
+    expect(opts.fileName).toBeUndefined();
+    expect(opts.fileExt).toBeUndefined();
+    expect(opts.fileSize).toBeUndefined();
+    expect(opts.mediaWidth).toBeUndefined();
+    expect(opts.mediaHeight).toBeUndefined();
+    expect(opts.mediaDuration).toBeUndefined();
+  });
+
+  it("includes image dimensions when provided", () => {
+    const opts = service.buildMessageOptions(fakeResult, IPFS_FILE_TYPE.IMAGE, {
+      mediaWidth: 1920,
+      mediaHeight: 1080,
+    });
+
+    expect(opts.mediaWidth).toBe(1920);
+    expect(opts.mediaHeight).toBe(1080);
+  });
+});
+
+describe("IpfsService constructor", () => {
+  it("parses host and port from gateway string", () => {
+    const service = new IpfsService("192.168.1.1:8080");
+    const opts = service.buildMessageOptions(
+      { hash: "Qm", key: Buffer.alloc(16), nonce: Buffer.alloc(12), nonceSize: 12 },
+      IPFS_FILE_TYPE.IMAGE,
+    );
+    expect(opts.ipfsIp).toBe("192.168.1.1:8080");
+  });
+
+  it("uses default gateway when none provided", () => {
+    const service = new IpfsService();
+    const opts = service.buildMessageOptions(
+      { hash: "Qm", key: Buffer.alloc(16), nonce: Buffer.alloc(12), nonceSize: 12 },
+      IPFS_FILE_TYPE.IMAGE,
+    );
+    expect(opts.ipfsIp).toBe("64.225.88.71:80");
+  });
+});
+
+describe("encrypt → upload → download → decrypt round-trip", () => {
+  it("data survives round-trip through encryption and key serialization", () => {
+    // Simulate the full data flow without a real IPFS server:
+    // 1. Encrypt (what upload does internally)
+    const original = Buffer.from("Hello IPFS image data!");
+    const { ciphertext, key, nonce } = encryptAesGcm(original);
+
+    // 2. Serialize key to wire format (what buildMessageOptions does)
+    const wireKeyBytes = keyToByteArray(key);
+    const nonceSize = nonce.length;
+
+    // 3. Deserialize and decrypt (what download does)
+    const restoredKey = byteArrayToKey(wireKeyBytes);
+    const decrypted = decryptAesGcm(ciphertext, restoredKey, nonceSize);
+
+    expect(decrypted.toString()).toBe(original.toString());
+  });
+});
+
+describe("IpfsService HTTP error handling", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("rejects on non-200 response", async () => {
+    // Mock http.request to return a 500 response
+    const mockRes = new EventEmitter() as any;
+    mockRes.statusCode = 500;
+
+    const mockReq = new EventEmitter() as any;
+    mockReq.write = vi.fn();
+    mockReq.end = vi.fn();
+    mockReq.destroy = vi.fn();
+
+    vi.spyOn(http, "request").mockImplementation((_opts: any, callback: any) => {
+      process.nextTick(() => {
+        callback(mockRes);
+        mockRes.emit("data", Buffer.from("Internal Server Error"));
+        mockRes.emit("end");
+      });
+      return mockReq;
+    });
+
+    const service = new IpfsService("127.0.0.1:5001");
+    await expect(service.upload(Buffer.from("test"))).rejects.toThrow("IPFS HTTP 500");
+  });
+
+  it("rejects on request timeout", async () => {
+    const mockReq = new EventEmitter() as any;
+    mockReq.write = vi.fn();
+    mockReq.end = vi.fn();
+    mockReq.destroy = vi.fn();
+
+    vi.spyOn(http, "request").mockImplementation(() => {
+      process.nextTick(() => {
+        mockReq.emit("timeout");
+      });
+      return mockReq;
+    });
+
+    const service = new IpfsService("127.0.0.1:5001");
+    await expect(service.upload(Buffer.from("test"))).rejects.toThrow("IPFS request timed out");
+  });
+
+  it("rejects on connection error", async () => {
+    const mockReq = new EventEmitter() as any;
+    mockReq.write = vi.fn();
+    mockReq.end = vi.fn();
+    mockReq.destroy = vi.fn();
+
+    vi.spyOn(http, "request").mockImplementation(() => {
+      process.nextTick(() => {
+        mockReq.emit("error", new Error("ECONNREFUSED"));
+      });
+      return mockReq;
+    });
+
+    const service = new IpfsService("127.0.0.1:5001");
+    await expect(service.upload(Buffer.from("test"))).rejects.toThrow("ECONNREFUSED");
+  });
+
+  it("download rejects on non-200 response", async () => {
+    const mockRes = new EventEmitter() as any;
+    mockRes.statusCode = 404;
+
+    const mockReq = new EventEmitter() as any;
+    mockReq.write = vi.fn();
+    mockReq.end = vi.fn();
+    mockReq.destroy = vi.fn();
+
+    vi.spyOn(http, "request").mockImplementation((_opts: any, callback: any) => {
+      process.nextTick(() => {
+        callback(mockRes);
+        mockRes.emit("data", Buffer.from("not found"));
+        mockRes.emit("end");
+      });
+      return mockReq;
+    });
+
+    const service = new IpfsService("127.0.0.1:5001");
+    await expect(
+      service.download("QmMissing", { encrypt: 1, encryptKeyBytes: Array.from(Buffer.alloc(16)), encryptNonceSize: 12 }),
+    ).rejects.toThrow("IPFS HTTP 404");
+  });
+});
+
+describe("buildFileMetadata", () => {
+  it("extracts extension from fileName", () => {
+    const result = buildFileMetadata({
+      buffer: Buffer.from("pdf content"),
+      contentType: "application/pdf",
+      fileName: "report.pdf",
+    });
+    expect(result.fileName).toBe("report.pdf");
+    expect(result.fileExt).toBe("pdf");
+    expect(result.fileSize).toBe(11);
+  });
+
+  it("derives extension from MIME when fileName has no extension", () => {
+    const result = buildFileMetadata({
+      buffer: Buffer.from("data"),
+      contentType: "application/pdf",
+      fileName: "report",
+    });
+    expect(result.fileName).toBe("report.pdf");
+    expect(result.fileExt).toBe("pdf");
+  });
+
+  it("derives extension from MIME when no fileName", () => {
+    const result = buildFileMetadata({
+      buffer: Buffer.from("data"),
+      contentType: "image/png",
+    });
+    expect(result.fileName).toBe("file.png");
+    expect(result.fileExt).toBe("png");
+  });
+
+  it("falls back to bin for unknown MIME and no fileName", () => {
+    const result = buildFileMetadata({
+      buffer: Buffer.from("data"),
+      contentType: "application/x-unknown",
+    });
+    expect(result.fileName).toBe("file.bin");
+    expect(result.fileExt).toBe("bin");
+  });
+
+  it("handles docx MIME type", () => {
+    const result = buildFileMetadata({
+      buffer: Buffer.from("docx"),
+      contentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      fileName: "letter.docx",
+    });
+    expect(result.fileExt).toBe("docx");
+    expect(result.fileName).toBe("letter.docx");
+  });
+
+  it("prefers fileName extension over MIME", () => {
+    const result = buildFileMetadata({
+      buffer: Buffer.from("data"),
+      contentType: "application/octet-stream",
+      fileName: "archive.tar.gz",
+    });
+    expect(result.fileExt).toBe("gz");
+    expect(result.fileName).toBe("archive.tar.gz");
+  });
+});

package/src/ipfs.ts

@@ -0,0 +1,268 @@
+import http from "http";
+import https from "https";
+import { encryptAesGcm, decryptAesGcm, keyToByteArray, byteArrayToKey } from "./crypto.js";
+import type { MessageOptions } from "./types.js";
+
+/** IPFS file type constants matching nMobile wire format. */
+export const IPFS_FILE_TYPE = {
+  FILE: 0,
+  IMAGE: 1,
+  AUDIO: 2,
+  VIDEO: 3,
+} as const;
+
+/** Map a MIME type string to an nMobile IPFS file type number. */
+export function mimeToIpfsFileType(mime?: string): number {
+  if (!mime) return IPFS_FILE_TYPE.IMAGE; // default to image
+  const lower = mime.toLowerCase();
+  if (lower.startsWith("image/")) return IPFS_FILE_TYPE.IMAGE;
+  if (lower.startsWith("audio/")) return IPFS_FILE_TYPE.AUDIO;
+  if (lower.startsWith("video/")) return IPFS_FILE_TYPE.VIDEO;
+  return IPFS_FILE_TYPE.FILE;
+}
+
+/** Common MIME → extension mappings for file transfers. */
+const MIME_TO_EXT: Record<string, string> = {
+  "application/pdf": "pdf",
+  "application/zip": "zip",
+  "application/x-zip-compressed": "zip",
+  "application/msword": "doc",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+  "application/vnd.ms-excel": "xls",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
+  "application/vnd.ms-powerpoint": "ppt",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation": "pptx",
+  "text/plain": "txt",
+  "text/csv": "csv",
+  "text/html": "html",
+  "application/json": "json",
+  "application/xml": "xml",
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/gif": "gif",
+  "image/webp": "webp",
+  "audio/aac": "aac",
+  "audio/mpeg": "mp3",
+  "audio/ogg": "ogg",
+  "audio/wav": "wav",
+  "video/mp4": "mp4",
+  "video/webm": "webm",
+};
+
+/**
+ * Build file metadata (fileName, fileExt, fileSize) for outbound media.
+ * Derives extension from the original filename or MIME type.
+ */
+export function buildFileMetadata(media: {
+  buffer: Buffer;
+  contentType?: string;
+  fileName?: string;
+}): { fileName: string; fileExt: string; fileSize: number } {
+  let ext: string | undefined;
+  let name = media.fileName;
+
+  // Try to get extension from filename
+  if (name) {
+    const dotIdx = name.lastIndexOf(".");
+    if (dotIdx > 0) {
+      ext = name.substring(dotIdx + 1).toLowerCase();
+    }
+  }
+
+  // Fall back to MIME type
+  if (!ext && media.contentType) {
+    ext = MIME_TO_EXT[media.contentType.toLowerCase()];
+  }
+
+  ext = ext || "bin";
+
+  // Ensure filename has extension
+  if (!name) {
+    name = `file.${ext}`;
+  } else if (!name.includes(".")) {
+    name = `${name}.${ext}`;
+  }
+
+  return { fileName: name, fileExt: ext, fileSize: media.buffer.length };
+}
+
+export interface IpfsUploadResult {
+  hash: string;
+  key: Buffer;
+  nonce: Buffer;
+  nonceSize: number;
+}
+
+const DEFAULT_TIMEOUT = 60_000;
+
+/**
+ * IPFS service for uploading/downloading encrypted media
+ * via an IPFS HTTP API gateway (compatible with nMobile).
+ */
+export class IpfsService {
+  private host: string;
+  private port: number;
+  private protocol: "http" | "https";
+
+  constructor(gateway?: string) {
+    const gw = gateway ?? "64.225.88.71:80";
+    const parts = gw.split(":");
+    this.host = parts[0];
+    this.port = parseInt(parts[1] ?? "80", 10);
+    this.protocol = this.port === 443 ? "https" : "http";
+  }
+
+  /**
+   * Encrypt plaintext with AES-128-GCM, then upload to IPFS via /api/v0/add.
+   */
+  async upload(plaintext: Buffer): Promise<IpfsUploadResult> {
+    const { ciphertext, key, nonce } = encryptAesGcm(plaintext);
+
+    const boundary = "----IpfsBoundary" + Date.now().toString(36);
+    const fieldName = "file";
+    const fileName = "upload";
+
+    // Build multipart form-data manually
+    const header = Buffer.from(
+      `--${boundary}\r\n` +
+        `Content-Disposition: form-data; name="${fieldName}"; filename="${fileName}"\r\n` +
+        `Content-Type: application/octet-stream\r\n\r\n`,
+    );
+    const footer = Buffer.from(`\r\n--${boundary}--\r\n`);
+    const body = Buffer.concat([header, ciphertext, footer]);
+
+    const responseBody = await this._request("POST", "/api/v0/add", body, {
+      "Content-Type": `multipart/form-data; boundary=${boundary}`,
+    });
+
+    const result = JSON.parse(responseBody);
+    const hash = result.Hash;
+    if (!hash) {
+      throw new Error(`IPFS add response missing Hash: ${responseBody}`);
+    }
+
+    return { hash, key, nonce, nonceSize: nonce.length };
+  }
+
+  /**
+   * Download from IPFS via /api/v0/cat, then decrypt with AES-128-GCM.
+   */
+  async download(
+    hash: string,
+    encryptOpts: {
+      encrypt?: number;
+      encryptKeyBytes?: number[];
+      encryptNonceSize?: number;
+    },
+  ): Promise<Buffer> {
+    const responseBody = await this._requestRaw("POST", `/api/v0/cat?arg=${hash}`);
+
+    if (!encryptOpts.encrypt || !encryptOpts.encryptKeyBytes) {
+      // Not encrypted — return raw
+      return responseBody;
+    }
+
+    const key = byteArrayToKey(encryptOpts.encryptKeyBytes);
+    const nonceSize = encryptOpts.encryptNonceSize ?? 12;
+    return decryptAesGcm(responseBody, key, nonceSize);
+  }
+
+  /**
+   * Build nMobile-compatible MessageOptions from an upload result.
+   */
+  buildMessageOptions(
+    uploadResult: IpfsUploadResult,
+    fileType: number,
+    extra?: {
+      fileMimeType?: string;
+      fileName?: string;
+      fileExt?: string;
+      fileSize?: number;
+      mediaWidth?: number;
+      mediaHeight?: number;
+      mediaDuration?: number;
+    },
+  ): MessageOptions {
+    const options: MessageOptions = {
+      ipfsHash: uploadResult.hash,
+      ipfsIp: `${this.host}:${this.port}`,
+      ipfsEncrypt: 1,
+      ipfsEncryptAlgorithm: "AES/GCM/NoPadding",
+      ipfsEncryptKeyBytes: keyToByteArray(uploadResult.key),
+      ipfsEncryptNonceSize: uploadResult.nonceSize,
+      fileType,
+    };
+
+    if (extra?.fileMimeType) options.fileMimeType = extra.fileMimeType;
+    if (extra?.fileName) options.fileName = extra.fileName;
+    if (extra?.fileExt) options.fileExt = extra.fileExt;
+    if (extra?.fileSize !== undefined) options.fileSize = extra.fileSize;
+    if (extra?.mediaWidth !== undefined) options.mediaWidth = extra.mediaWidth;
+    if (extra?.mediaHeight !== undefined) options.mediaHeight = extra.mediaHeight;
+    if (extra?.mediaDuration !== undefined) options.mediaDuration = extra.mediaDuration;
+
+    return options;
+  }
+
+  /** HTTP request returning text response. */
+  private _request(
+    method: string,
+    path: string,
+    body?: Buffer,
+    headers?: Record<string, string>,
+  ): Promise<string> {
+    return this._requestRaw(method, path, body, headers).then((buf) => buf.toString("utf-8"));
+  }
+
+  /** HTTP request returning raw Buffer response. */
+  private _requestRaw(
+    method: string,
+    path: string,
+    body?: Buffer,
+    headers?: Record<string, string>,
+  ): Promise<Buffer> {
+    const transport = this.protocol === "https" ? https : http;
+
+    return new Promise<Buffer>((resolve, reject) => {
+      const req = transport.request(
+        {
+          hostname: this.host,
+          port: this.port,
+          path,
+          method,
+          headers: {
+            ...headers,
+            ...(body ? { "Content-Length": body.length.toString() } : {}),
+          },
+          timeout: DEFAULT_TIMEOUT,
+        },
+        (res) => {
+          const chunks: Buffer[] = [];
+          res.on("data", (chunk: Buffer) => chunks.push(chunk));
+          res.on("end", () => {
+            const result = Buffer.concat(chunks);
+            if (res.statusCode && (res.statusCode < 200 || res.statusCode >= 300)) {
+              reject(
+                new Error(
+                  `IPFS HTTP ${res.statusCode}: ${result.toString("utf-8").slice(0, 200)}`,
+                ),
+              );
+              return;
+            }
+            resolve(result);
+          });
+          res.on("error", reject);
+        },
+      );
+
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error("IPFS request timed out"));
+      });
+      req.on("error", reject);
+
+      if (body) req.write(body);
+      req.end();
+    });
+  }
+}