@vee3/upload 0.1.0

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@vee3/upload",
+  "version": "0.1.0",
+  "description": "Upload local files to Vee3.",
+  "type": "module",
+  "bin": {
+    "vee3-upload": "./src/index.js"
+  },
+  "files": ["src"],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vee3io/Vee3.git",
+    "directory": "packages/upload"
+  },
+  "keywords": ["vee3", "upload", "cli", "mcp"],
+  "license": "MIT"
+}

package/src/api.js

@@ -0,0 +1,34 @@
+export const DEFAULT_API_BASE_URL = "https://api.vee3.io";
+
+async function formatApiError(response) {
+  const responseText = await response.text();
+  try {
+    const payload = JSON.parse(responseText);
+    if (payload && typeof payload.error === "object") {
+      const requestId = payload.error.request_id ? ` (request_id=${payload.error.request_id})` : "";
+      return `${payload.error.code}: ${payload.error.message}${requestId}`;
+    }
+  } catch {
+    // Fall through to raw response text.
+  }
+  return responseText || `HTTP ${response.status}`;
+}
+
+export async function resolveUpload({ apiBaseUrl, uploadCode, contentType }) {
+  const response = await fetch(`${apiBaseUrl.replace(/\/$/, "")}/v1/agent-uploads/resolve`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      upload_code: uploadCode,
+      content_type: contentType
+    })
+  });
+
+  if (!response.ok) {
+    throw new Error(await formatApiError(response));
+  }
+
+  return await response.json();
+}

package/src/detectContentType.js

@@ -0,0 +1,90 @@
+import { open } from "node:fs/promises";
+import { extname } from "node:path";
+
+const extensionContentTypes = new Map([
+  [".jpg", "image/jpeg"],
+  [".jpeg", "image/jpeg"],
+  [".png", "image/png"],
+  [".gif", "image/gif"],
+  [".webp", "image/webp"],
+  [".bmp", "image/bmp"],
+  [".tif", "image/tiff"],
+  [".tiff", "image/tiff"],
+  [".svg", "image/svg+xml"],
+  [".mp4", "video/mp4"],
+  [".m4v", "video/mp4"],
+  [".webm", "video/webm"],
+  [".mov", "video/quicktime"],
+  [".avi", "video/x-msvideo"],
+  [".mkv", "video/x-matroska"],
+  [".mpeg", "video/mpeg"],
+  [".mpg", "video/mpeg"],
+  [".3gp", "video/3gpp"],
+  [".mp3", "audio/mpeg"],
+  [".m4a", "audio/mp4"],
+  [".wav", "audio/wav"],
+  [".ogg", "audio/ogg"],
+  [".pdf", "application/pdf"],
+  [".zip", "application/zip"],
+  [".json", "application/json"],
+  [".txt", "text/plain"],
+  [".csv", "text/csv"]
+]);
+
+function matchesBytes(bytes, expectedBytes, offset = 0) {
+  if (bytes.length < offset + expectedBytes.length) {
+    return false;
+  }
+  return expectedBytes.every((byte, index) => bytes[offset + index] === byte);
+}
+
+function readAscii(bytes, start, end) {
+  return Buffer.from(bytes.subarray(start, end)).toString("ascii");
+}
+
+async function readSignature(filePath) {
+  const file = await open(filePath, "r");
+  try {
+    const buffer = Buffer.alloc(64);
+    const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
+    return buffer.subarray(0, bytesRead);
+  } finally {
+    await file.close();
+  }
+}
+
+export async function detectContentType(filePath) {
+  const signature = await readSignature(filePath);
+
+  if (matchesBytes(signature, [0xff, 0xd8, 0xff])) {
+    return "image/jpeg";
+  }
+  if (matchesBytes(signature, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])) {
+    return "image/png";
+  }
+  if (readAscii(signature, 0, 6) === "GIF87a" || readAscii(signature, 0, 6) === "GIF89a") {
+    return "image/gif";
+  }
+  if (readAscii(signature, 0, 4) === "RIFF" && readAscii(signature, 8, 12) === "WEBP") {
+    return "image/webp";
+  }
+  if (readAscii(signature, 0, 4) === "%PDF") {
+    return "application/pdf";
+  }
+  if (matchesBytes(signature, [0x50, 0x4b, 0x03, 0x04])) {
+    return "application/zip";
+  }
+  if (readAscii(signature, 0, 4) === "RIFF" && readAscii(signature, 8, 12) === "AVI ") {
+    return "video/x-msvideo";
+  }
+  if (matchesBytes(signature, [0x1a, 0x45, 0xdf, 0xa3])) {
+    return extname(filePath).toLowerCase() === ".mkv" ? "video/x-matroska" : "video/webm";
+  }
+  if (readAscii(signature, 4, 8) === "ftyp") {
+    const brand = readAscii(signature, 8, 12);
+    return brand === "qt  " ? "video/quicktime" : "video/mp4";
+  }
+
+  const extension = extname(filePath).toLowerCase();
+  return extensionContentTypes.get(extension) ?? "application/octet-stream";
+}

package/src/index.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+import { stat } from "node:fs/promises";
+import { DEFAULT_API_BASE_URL, resolveUpload } from "./api.js";
+import { detectContentType } from "./detectContentType.js";
+import { uploadFileToSignedUrl } from "./uploadFile.js";
+
+function printUsage() {
+  console.error(
+    "Usage: vee3-upload <upload_code> <file_path> [--api-base-url https://api.vee3.io] [--json]"
+  );
+}
+
+function parseArguments(argumentsList) {
+  const positionalArguments = [];
+  let apiBaseUrl = DEFAULT_API_BASE_URL;
+  let outputJson = false;
+
+  for (let index = 0; index < argumentsList.length; index += 1) {
+    const argument = argumentsList[index];
+    if (argument === "--api-base-url") {
+      const nextArgument = argumentsList[index + 1];
+      if (!nextArgument) {
+        throw new Error("--api-base-url requires a value");
+      }
+      apiBaseUrl = nextArgument;
+      index += 1;
+      continue;
+    }
+    if (argument === "--json") {
+      outputJson = true;
+      continue;
+    }
+    positionalArguments.push(argument);
+  }
+
+  if (positionalArguments.length !== 2) {
+    throw new Error("Expected upload_code and file_path");
+  }
+
+  return {
+    uploadCode: positionalArguments[0],
+    filePath: positionalArguments[1],
+    apiBaseUrl,
+    outputJson
+  };
+}
+
+async function main() {
+  const { uploadCode, filePath, apiBaseUrl, outputJson } = parseArguments(
+    process.argv.slice(2)
+  );
+  const fileStat = await stat(filePath);
+  if (!fileStat.isFile()) {
+    throw new Error(`File path is not a file: ${filePath}`);
+  }
+
+  const contentType = await detectContentType(filePath);
+  const resolvedUpload = await resolveUpload({
+    apiBaseUrl,
+    uploadCode,
+    contentType
+  });
+
+  if (fileStat.size > resolvedUpload.max_bytes) {
+    throw new Error(
+      `File is too large: ${fileStat.size} bytes exceeds ${resolvedUpload.max_bytes} bytes`
+    );
+  }
+
+  await uploadFileToSignedUrl({
+    uploadUrl: resolvedUpload.upload_url,
+    filePath,
+    fileSizeBytes: fileStat.size,
+    requiredHeaders: resolvedUpload.required_headers
+  });
+
+  if (outputJson) {
+    console.log(
+      JSON.stringify({
+        upload_id: resolvedUpload.upload_id,
+        content_type: contentType,
+        size_bytes: fileStat.size
+      })
+    );
+    return;
+  }
+
+  console.log(resolvedUpload.upload_id);
+}
+
+main().catch((error) => {
+  printUsage();
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/src/uploadFile.js

@@ -0,0 +1,25 @@
+import { createReadStream } from "node:fs";
+
+export async function uploadFileToSignedUrl({
+  uploadUrl,
+  filePath,
+  fileSizeBytes,
+  requiredHeaders
+}) {
+  const headers = {
+    ...requiredHeaders,
+    "Content-Length": String(fileSizeBytes)
+  };
+
+  const response = await fetch(uploadUrl, {
+    method: "PUT",
+    headers,
+    body: createReadStream(filePath),
+    duplex: "half"
+  });
+
+  if (!response.ok) {
+    const responseText = await response.text();
+    throw new Error(responseText || `Upload failed with HTTP ${response.status}`);
+  }
+}