@prompd/core 0.5.0-beta.14 → 0.5.0-beta.17

package/dist/index.cjs

@@ -3136,12 +3136,35 @@ function isBinaryAsset(name) {
   const dot = name.lastIndexOf(".");
   return dot >= 0 && BINARY_ASSET_EXT.has(name.slice(dot + 1).toLowerCase());
 }
+var MAX_FILE_SIZE_IN_ZIP = 10 * 1024 * 1024;
+var MAX_TOTAL_EXTRACTED_SIZE = 500 * 1024 * 1024;
+function isSymlinkEntry(perms) {
+  return typeof perms === "number" && (perms & 61440) === 40960;
+}
 async function extractPdpkg(buffer) {
   const zip = await JSZip__default.default.loadAsync(buffer);
   const out = /* @__PURE__ */ new Map();
+  let total = 0;
   for (const entry of Object.values(zip.files)) {
+    if (entry.name.includes("\0")) {
+      throw new Error(`Security violation: null byte in entry name: ${entry.name}`);
+    }
+    if (entry.name.startsWith("/") || /(^|\/)\.\.(\/|$)/.test(entry.name)) {
+      throw new Error(`Security violation: path traversal in entry: ${entry.name}`);
+    }
+    if (isSymlinkEntry(entry.unixPermissions)) {
+      throw new Error(`Security violation: symlink entry in archive: ${entry.name}`);
+    }
     if (entry.dir || isBinaryAsset(entry.name)) continue;
-    out.set(entry.name, await entry.async("string"));
+    const bytes = await entry.async("uint8array");
+    if (bytes.length > MAX_FILE_SIZE_IN_ZIP) {
+      throw new Error(`File too large in package: ${entry.name} (${bytes.length} bytes, max ${MAX_FILE_SIZE_IN_ZIP})`);
+    }
+    total += bytes.length;
+    if (total > MAX_TOTAL_EXTRACTED_SIZE) {
+      throw new Error(`Package total decompressed size exceeds limit (${MAX_TOTAL_EXTRACTED_SIZE} bytes). Possible decompression bomb.`);
+    }
+    out.set(entry.name, new TextDecoder().decode(bytes));
   }
   return out;
 }
@@ -3384,11 +3407,55 @@ function normalizeSegments(p) {
   }
   return out.join("/");
 }
-function resolveInstallDir(root, type, name) {
+function slugify(name) {
+  return name.toLowerCase().replace(/[@/]+/g, "-").replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function resolvePackageDir(root, type, name) {
   return joinPosix3(root, ".prompd", getInstallDirForType(type), name);
 }
+function resolveInstallDir(root, type, name, version) {
+  return joinPosix3(resolvePackageDir(root, type, name), version);
+}
+async function addWorkspaceDependency(store, root, name, version) {
+  if (!store.readFile) return;
+  const manifestPath = joinPosix3(root, "prompd.json");
+  try {
+    const existing = await store.readFile(manifestPath);
+    const manifest = existing && existing.trim() ? JSON.parse(existing) : {};
+    if (!manifest.dependencies || typeof manifest.dependencies !== "object") manifest.dependencies = {};
+    manifest.dependencies[name] = version;
+    await store.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+  } catch {
+  }
+}
+async function removeWorkspaceDependency(store, root, name) {
+  if (!store.readFile) return;
+  const manifestPath = joinPosix3(root, "prompd.json");
+  try {
+    const existing = await store.readFile(manifestPath);
+    if (!existing || !existing.trim()) return;
+    const manifest = JSON.parse(existing);
+    const deps = manifest.dependencies;
+    if (!deps || typeof deps !== "object") return;
+    delete deps[name];
+    await store.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+  } catch {
+  }
+}
+function readManifest(files) {
+  const raw = files.get("manifest.json") ?? files.get("prompd.json");
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
 async function installPackage(opts) {
-  const { ref, type, root, store, download } = opts;
+  return installInternal(opts, /* @__PURE__ */ new Set());
+}
+async function installInternal(opts, visited) {
+  const { ref, root, store, download, global, tools, deployTool } = opts;
   const parsed = parsePackageReference(ref);
   const bytes = await download(parsed.name, parsed.version);
   if (bytes.length > MAX_PACKAGE_SIZE) {
@@ -3398,41 +3465,77 @@ async function installPackage(opts) {
   if (files.size === 0) {
     throw new Error(`Package "${parsed.name}" contains no installable files.`);
   }
-  let name = parsed.name;
-  let version = parsed.version;
-  const manifest = files.get("manifest.json") ?? files.get("prompd.json");
-  if (manifest) {
-    try {
-      const m = JSON.parse(manifest);
-      if (typeof m.name === "string" && m.name) name = m.name;
-      if (typeof m.version === "string" && m.version) version = m.version;
-    } catch {
+  const m = readManifest(files);
+  const name = typeof m.name === "string" && m.name ? m.name : parsed.name;
+  const version = typeof m.version === "string" && m.version ? m.version : parsed.version;
+  const type = typeof m.type === "string" && isValidPackageType(m.type) ? m.type : opts.type && isValidPackageType(opts.type) ? opts.type : "package";
+  visited.add(name);
+  if (m.dependencies && typeof m.dependencies === "object") {
+    for (const [depName, depVersion] of Object.entries(m.dependencies)) {
+      if (depName === name || visited.has(depName)) continue;
+      await installInternal({ ...opts, ref: `${depName}@${depVersion}`, type: void 0 }, visited);
     }
   }
-  const installedPath = resolveInstallDir(root, type, name);
-  const baseSegments = normalizeSegments(installedPath);
-  await store.removeDir?.(installedPath);
+  let installedPath;
   const written = [];
-  for (const [rel, content] of files) {
-    const dest = joinPosix3(installedPath, rel);
-    const destSegments = normalizeSegments(dest);
-    if (destSegments !== baseSegments && !destSegments.startsWith(baseSegments + "/")) {
-      throw new Error(`Security violation: extracted path escapes install directory: ${rel}`);
+  if (type === "node-template") {
+    if (!store.writeBytes) {
+      throw new Error("Installing a node-template requires a PackageStore with writeBytes (binary). This host does not support it.");
+    }
+    const dir = joinPosix3(root, ".prompd", getInstallDirForType("node-template"));
+    installedPath = joinPosix3(dir, `${slugify(name)}-${version}.pdpkg`);
+    await store.writeBytes(installedPath, bytes);
+  } else {
+    installedPath = resolveInstallDir(root, type, name, version);
+    const base = normalizeSegments(installedPath);
+    await store.removeDir?.(installedPath);
+    for (const [rel, content] of files) {
+      const dest = joinPosix3(installedPath, rel);
+      if (normalizeSegments(dest) !== base && !normalizeSegments(dest).startsWith(base + "/")) {
+        throw new Error(`Security violation: extracted path escapes install directory: ${rel}`);
+      }
+      await store.writeFile(dest, content);
+      written.push(rel);
+    }
+    await store.writeFile(joinPosix3(installedPath, ".prmdmeta"), JSON.stringify(m, null, 2) + "\n");
+    if (tools && tools.length > 0) {
+      if (type !== "skill") throw new Error(`Tool deploy is only valid for skills, but '${name}' is a ${type}.`);
+      if (!deployTool) throw new Error("tools were requested but no deployTool hook was provided.");
+      for (const tool of tools) await deployTool({ installedPath, name, tool });
     }
-    await store.writeFile(dest, content);
-    written.push(rel);
   }
-  return { name, version, scope: parsed.scope, installedPath, files: written };
+  if (!global) await addWorkspaceDependency(store, root, name, version);
+  return { name, version, scope: parsed.scope, type, installedPath, files: written };
 }
 async function uninstallPackage(opts) {
-  const { ref, type, root, store } = opts;
-  if (!store.removeDir) {
-    throw new Error("Uninstall requires a PackageStore with removeDir.");
+  const { root, store, global } = opts;
+  if (!store.removeDir) throw new Error("Uninstall requires a PackageStore with removeDir.");
+  const parsed = parsePackageReference(opts.ref);
+  const name = parsed.name;
+  const removed = [];
+  for (const type of ["package", "workflow", "skill", "node-template"]) {
+    if (type === "node-template") {
+      const dir = joinPosix3(root, ".prompd", getInstallDirForType("node-template"));
+      if (!store.readdir || !store.removeFile) continue;
+      try {
+        const prefix = `${slugify(name)}-`;
+        for (const entry of await store.readdir(dir)) {
+          if (entry.startsWith(prefix) && entry.endsWith(".pdpkg")) {
+            const p = joinPosix3(dir, entry);
+            await store.removeFile(p);
+            removed.push(p);
+          }
+        }
+      } catch {
+      }
+    } else {
+      const dir = resolvePackageDir(root, type, name);
+      await store.removeDir(dir);
+      removed.push(dir);
+    }
   }
-  const parsed = parsePackageReference(ref);
-  const installedPath = resolveInstallDir(root, type, parsed.name);
-  await store.removeDir(installedPath);
-  return { name: parsed.name, scope: parsed.scope, installedPath };
+  if (!global) await removeWorkspaceDependency(store, root, name);
+  return { name, scope: parsed.scope, removed };
 }
 
 // src/lib/compiler/index.ts