trajectories-sh 1.2.2 → 1.4.0

package/dist/cli.js

@@ -81,7 +81,7 @@ program.command("upload <directory>").description("Upload a trajectory job direc
   Pushing ${directory} \u2192 ${chalk.cyan(slug)}
 `));
   try {
-    const { uploadJob } = await import("./upload-3SQPHPNI.js");
+    const { uploadJob } = await import("./upload-WZGAR4S4.js");
     const result = await uploadJob(directory, {
       slug,
       name: opts.name,
@@ -101,6 +101,26 @@ program.command("upload <directory>").description("Upload a trajectory job direc
     process.exit(1);
   }
 });
+program.command("download <url>").description("Download a trajectory job from trajectories.sh").option("-o, --output <dir>", "Output directory (default: slug name)").action(async (url, opts) => {
+  const chalk = (await import("chalk")).default;
+  console.log(chalk.bold(`
+  Downloading trajectory...
+`));
+  try {
+    const { downloadJob, parseJobId } = await import("./download-YWW2BV6K.js");
+    const outputDir = opts.output ?? parseJobId(url).replace(/^org:/, "").replace(/:/g, "-");
+    const result = await downloadJob(url, outputDir);
+    console.log(chalk.green.bold(`  \u2713 Downloaded ${result.files} files`));
+    console.log(`    Size: ${(result.totalSize / 1024 / 1024).toFixed(1)} MB`);
+    console.log(`    Output: ${outputDir}
+`);
+  } catch (e) {
+    console.error(chalk.red(`
+  \u2717 ${e.message}
+`));
+    process.exit(1);
+  }
+});
 program.command("whoami").description("Show current authentication status").action(async () => {
   const chalk = (await import("chalk")).default;
   const { status } = await import("./auth-UD3KTSHK.js");

package/dist/download-YWW2BV6K.js

@@ -0,0 +1,111 @@
+import {
+  getApiUrl,
+  getAuthHeader
+} from "./chunk-P6J5X7LP.js";
+
+// src/download.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+var UUID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+function parseJobId(input) {
+  const trimmed = input.trim();
+  if (UUID_RE.test(trimmed) && !trimmed.includes("/")) {
+    return trimmed.match(UUID_RE)[0];
+  }
+  const trajMatch = trimmed.match(/\/trajectories\/([0-9a-f-]{36})/i);
+  if (trajMatch) return trajMatch[1];
+  const trajViewerMatch = trimmed.match(/\/traj\/([0-9a-f-]{36})\/([^/]+)/i);
+  if (trajViewerMatch) {
+    return `org:${trajViewerMatch[1]}:${trajViewerMatch[2]}`;
+  }
+  const anyUuid = trimmed.match(UUID_RE);
+  if (anyUuid) return anyUuid[0];
+  throw new Error(`Could not find a trajectory job ID in: ${input}`);
+}
+async function downloadJob(input, outputDir) {
+  const apiUrl = getApiUrl();
+  const auth = await getAuthHeader();
+  const headers = {};
+  if (auth) headers["Authorization"] = auth;
+  let jobId = parseJobId(input);
+  if (jobId.startsWith("org:")) {
+    const [, orgId, slug2] = jobId.split(":");
+    const resp = await fetch(`${apiUrl}/api/org/trajectories/public/${orgId}?slug=${slug2}`, { headers });
+    if (!resp.ok) {
+      const configResp = await fetch(`${apiUrl}/api/viewer/${orgId}/${slug2}/api/jobs`, { headers });
+      if (!configResp.ok) throw new Error(`Could not resolve job: ${orgId}/${slug2}`);
+      const configData = await configResp.json();
+      const items = configData.items || [];
+      if (items.length > 0 && items[0].id) {
+        jobId = items[0].id;
+      } else {
+        throw new Error(`Could not resolve job ID for ${orgId}/${slug2}`);
+      }
+    } else {
+      const data = await resp.json();
+      jobId = data.id;
+    }
+  }
+  const listResp = await fetch(`${apiUrl}/api/cli/download/${jobId}/files`, {
+    headers,
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (!listResp.ok) {
+    const text = await listResp.text();
+    throw new Error(`Failed to list files: ${text}`);
+  }
+  const { slug, files } = await listResp.json();
+  console.log(`  Job: ${slug} (${jobId})`);
+  console.log(`  ${files.length} files to download`);
+  mkdirSync(outputDir, { recursive: true });
+  let downloaded = 0;
+  let totalSize = 0;
+  const concurrency = 8;
+  const pending = [];
+  for (const file of files) {
+    const task = (async () => {
+      for (let attempt = 0; attempt < 3; attempt++) {
+        try {
+          const fileResp = await fetch(
+            `${apiUrl}/api/cli/download/${jobId}/file?path=${encodeURIComponent(file.path)}`,
+            { headers, signal: AbortSignal.timeout(6e4) }
+          );
+          if (!fileResp.ok) throw new Error(`HTTP ${fileResp.status}`);
+          const data = Buffer.from(await fileResp.arrayBuffer());
+          const outPath = join(outputDir, file.path);
+          mkdirSync(dirname(outPath), { recursive: true });
+          writeFileSync(outPath, data);
+          downloaded++;
+          totalSize += data.length;
+          if (downloaded % 10 === 0 || downloaded === files.length) {
+            process.stdout.write(`  \u2193 ${downloaded}/${files.length} downloaded\r`);
+          }
+          return;
+        } catch {
+          if (attempt < 2) await new Promise((r) => setTimeout(r, 1e3 * (attempt + 1)));
+        }
+      }
+      console.log(`  \u2717 ${file.path}`);
+    })();
+    pending.push(task);
+    if (pending.length >= concurrency) {
+      await Promise.race(pending);
+      const next = [];
+      for (const p of pending) {
+        let settled = false;
+        p.then(() => settled = true, () => settled = true);
+        if (!settled) next.push(p);
+      }
+      if (next.length === pending.length) await Promise.race(pending);
+      pending.length = 0;
+      pending.push(...next);
+    }
+  }
+  await Promise.all(pending);
+  console.log("");
+  return { files: downloaded, totalSize };
+}
+export {
+  downloadJob,
+  parseJobId
+};

package/dist/{upload-3SQPHPNI.js → upload-WZGAR4S4.js}

@@ -4,8 +4,10 @@ import {
 } from "./chunk-P6J5X7LP.js";
 
 // src/upload.ts
-import { readdirSync, statSync, readFileSync } from "fs";
-import { join, relative } from "path";
+import { readdirSync, statSync, readFileSync, writeFileSync, mkdirSync, copyFileSync } from "fs";
+import { join, relative, dirname } from "path";
+import { tmpdir } from "os";
+import { randomBytes } from "crypto";
 var SKIP = /* @__PURE__ */ new Set(["__pycache__", ".DS_Store", ".git", "node_modules"]);
 var MAX_FILE_SIZE = 50 * 1024 * 1024;
 var CONCURRENCY = 12;
@@ -39,11 +41,94 @@ async function apiPost(path, body, timeout = 3e5) {
     signal: AbortSignal.timeout(timeout)
   });
 }
+async function convertToWebP(dir) {
+  const files = collectFiles(dir);
+  const pngs = files.filter((f) => f.relPath.toLowerCase().endsWith(".png"));
+  if (pngs.length === 0) {
+    return { convertedDir: dir, pngsConverted: 0, savedBytes: 0 };
+  }
+  let sharp;
+  try {
+    sharp = (await import("sharp")).default;
+  } catch {
+    console.log("  \u26A0 sharp not available, skipping WebP conversion");
+    return { convertedDir: dir, pngsConverted: 0, savedBytes: 0 };
+  }
+  const tmpDir = join(tmpdir(), `trajectories-webp-${randomBytes(4).toString("hex")}`);
+  function copyDir(src, dest) {
+    mkdirSync(dest, { recursive: true });
+    for (const entry of readdirSync(src, { withFileTypes: true })) {
+      if (SKIP.has(entry.name)) continue;
+      const srcPath = join(src, entry.name);
+      const destPath = join(dest, entry.name);
+      if (entry.isDirectory()) {
+        copyDir(srcPath, destPath);
+      } else {
+        copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+  copyDir(dir, tmpDir);
+  let converted = 0;
+  let savedBytes = 0;
+  const batchSize = 10;
+  for (let i = 0; i < pngs.length; i += batchSize) {
+    const batch = pngs.slice(i, i + batchSize);
+    await Promise.all(
+      batch.map(async (f) => {
+        const srcPath = join(tmpDir, f.relPath);
+        const webpPath = srcPath.replace(/\.png$/i, ".webp");
+        try {
+          await sharp(srcPath).webp({ quality: 80 }).toFile(webpPath);
+          const origSize = statSync(srcPath).size;
+          const newSize = statSync(webpPath).size;
+          if (newSize < origSize) {
+            const { unlinkSync } = await import("fs");
+            unlinkSync(srcPath);
+            savedBytes += origSize - newSize;
+            converted++;
+          } else {
+            const { unlinkSync } = await import("fs");
+            unlinkSync(webpPath);
+          }
+        } catch {
+        }
+      })
+    );
+    process.stdout.write(`  Converting: ${Math.min(i + batchSize, pngs.length)}/${pngs.length} PNGs\r`);
+  }
+  console.log("");
+  const trajFiles = collectFiles(tmpDir).filter((f) => f.relPath.endsWith("trajectory.json"));
+  for (const tf of trajFiles) {
+    try {
+      let content = readFileSync(tf.absPath, "utf-8");
+      const original = content;
+      content = content.replace(/screenshots\/([^"]+)\.png/g, (match, name) => {
+        const webpPath = join(dirname(tf.absPath), "screenshots", `${name}.webp`);
+        try {
+          statSync(webpPath);
+          return `screenshots/${name}.webp`;
+        } catch {
+          return match;
+        }
+      });
+      if (content !== original) {
+        writeFileSync(tf.absPath, content);
+      }
+    } catch {
+    }
+  }
+  return { convertedDir: tmpDir, pngsConverted: converted, savedBytes };
+}
 async function uploadJob(dir, opts) {
   const slug = opts.slug ?? dir.replace(/\/+$/, "").split("/").pop();
   const name = opts.name ?? slug;
   const visibility = opts.visibility ?? "private";
-  const files = collectFiles(dir);
+  const { convertedDir, pngsConverted, savedBytes } = await convertToWebP(dir);
+  if (pngsConverted > 0) {
+    console.log(`  \u2713 Converted ${pngsConverted} PNGs to WebP (saved ${(savedBytes / 1024 / 1024).toFixed(1)} MB)`);
+  }
+  const files = collectFiles(convertedDir);
   const totalSize = files.reduce((s, f) => s + f.size, 0);
   console.log(`  ${files.length} files, ${(totalSize / 1024 / 1024).toFixed(1)} MB`);
   const initResp = await apiPost("/api/cli/push/init", { slug, name, visibility });
@@ -59,6 +144,13 @@ async function uploadJob(dir, opts) {
     throw new Error(`Finalize failed: ${await finalResp.text()}`);
   }
   const result = await finalResp.json();
+  if (convertedDir !== dir) {
+    try {
+      const { rmSync } = await import("fs");
+      rmSync(convertedDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
   const apiUrl = getApiUrl();
   const siteUrl = apiUrl.includes("localhost") ? "http://localhost:3000" : apiUrl.replace("api.", "").replace(/\/$/, "");
   return {
@@ -134,9 +226,7 @@ async function uploadOneFile(file, signedUrl) {
     try {
       const resp = await fetch(signedUrl, {
         method: "PUT",
-        headers: {
-          "Content-Type": "application/octet-stream"
-        },
+        headers: { "Content-Type": "application/octet-stream" },
         body: data,
         signal: AbortSignal.timeout(12e4)
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trajectories-sh",
-  "version": "1.2.2",
+  "version": "1.4.0",
   "description": "CLI for uploading trajectory jobs to trajectories.sh",
   "type": "module",
   "bin": {
@@ -26,10 +26,11 @@
     "node": ">=18"
   },
   "dependencies": {
+    "chalk": "^5.0.0",
     "commander": "^13.0.0",
+    "sharp": "^0.34.5",
     "open": "^10.0.0",
     "ora": "^8.0.0",
-    "chalk": "^5.0.0",
     "tar": "^7.0.0"
   },
   "devDependencies": {