@standardagents/builder 0.37.0 → 0.37.1

package/dist/packing.js

@@ -1,8 +1,51 @@
-import * as fs2 from 'fs';
-import * as path2 from 'path';
+import * as fs3 from 'fs';
+import * as path3 from 'path';
 import MagicString from 'magic-string';
 
 // src/packing/packing-service.ts
+
+// src/packing/package-identifier.ts
+function assertSafePackageIdentifier(identifier) {
+  const value = identifier.trim();
+  if (!value || value.includes("\\") || value.includes("\0") || value.startsWith("/")) {
+    throw new Error("Invalid package identifier");
+  }
+  const parts = value.split("/");
+  const scoped = parts.length === 2 && parts[0].startsWith("@");
+  if (parts.length > 1 && !scoped) throw new Error("Invalid package identifier");
+  if (parts.some((part) => !part || part === "." || part === ".." || !/^@?[a-zA-Z0-9._-]+$/.test(part))) {
+    throw new Error("Invalid package identifier");
+  }
+  return value;
+}
+
+// src/packing/path-safety.ts
+function isWithin(base, candidate) {
+  const relative4 = path3.relative(base, candidate);
+  return relative4 === "" || !relative4.startsWith(`..${path3.sep}`) && relative4 !== ".." && !path3.isAbsolute(relative4);
+}
+function resolvePathWithin(base, ...segments) {
+  const resolvedBase = path3.resolve(base);
+  const candidate = path3.resolve(resolvedBase, ...segments);
+  if (!isWithin(resolvedBase, candidate)) {
+    throw new Error("Path must remain inside the configured AgentBuilder directory");
+  }
+  if (fs3.existsSync(resolvedBase)) {
+    const realBase = fs3.realpathSync(resolvedBase);
+    if (typeof realBase !== "string") return candidate;
+    let existing = candidate;
+    while (!fs3.existsSync(existing) && existing !== resolvedBase) {
+      existing = path3.dirname(existing);
+    }
+    if (fs3.existsSync(existing)) {
+      const realExisting = fs3.realpathSync(existing);
+      if (typeof realExisting === "string" && !isWithin(realBase, realExisting)) {
+        throw new Error("Path traverses a symlink outside the configured AgentBuilder directory");
+      }
+    }
+  }
+  return candidate;
+}
 var MetadataService = class {
   metadataDir;
   /**
@@ -11,7 +54,7 @@ var MetadataService = class {
    * @param agentsDir - Path to the agents/ directory
    */
   constructor(agentsDir) {
-    this.metadataDir = path2.join(agentsDir, ".standardagent");
+    this.metadataDir = path3.join(agentsDir, ".standardagent");
   }
   /**
    * Read metadata for an agent.
@@ -21,11 +64,11 @@ var MetadataService = class {
    */
   async read(agentName) {
     const filePath = this.getMetadataPath(agentName);
-    if (!fs2.existsSync(filePath)) {
+    if (!fs3.existsSync(filePath)) {
       return null;
     }
     try {
-      const content = fs2.readFileSync(filePath, "utf-8");
+      const content = fs3.readFileSync(filePath, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -38,11 +81,11 @@ var MetadataService = class {
    * @param metadata - Metadata to write
    */
   async write(agentName, metadata) {
-    if (!fs2.existsSync(this.metadataDir)) {
-      fs2.mkdirSync(this.metadataDir, { recursive: true });
+    if (!fs3.existsSync(this.metadataDir)) {
+      fs3.mkdirSync(this.metadataDir, { recursive: true });
     }
     const filePath = this.getMetadataPath(agentName);
-    fs2.writeFileSync(filePath, JSON.stringify(metadata, null, 2));
+    fs3.writeFileSync(filePath, JSON.stringify(metadata, null, 2));
   }
   /**
    * Delete metadata for an agent.
@@ -51,8 +94,8 @@ var MetadataService = class {
    */
   async delete(agentName) {
     const filePath = this.getMetadataPath(agentName);
-    if (fs2.existsSync(filePath)) {
-      fs2.unlinkSync(filePath);
+    if (fs3.existsSync(filePath)) {
+      fs3.unlinkSync(filePath);
     }
   }
   /**
@@ -133,7 +176,7 @@ var MetadataService = class {
    * Get the file path for an agent's metadata.
    */
   getMetadataPath(agentName) {
-    return path2.join(this.metadataDir, `${agentName}.json`);
+    return path3.join(this.metadataDir, `${agentName}.json`);
   }
 };
 var _ts;
@@ -505,9 +548,9 @@ var PackingService = class {
    * @returns Version specifier (e.g., '^1.2.3') or '*' if not found
    */
   resolvePackageVersion(pkgName, rootDir) {
-    const pkgJsonPath = path2.join(rootDir, "node_modules", pkgName, "package.json");
+    const pkgJsonPath = path3.join(rootDir, "node_modules", pkgName, "package.json");
     try {
-      const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
       return `^${pkgJson.version}`;
     } catch {
       return "*";
@@ -524,7 +567,7 @@ var PackingService = class {
    * @returns Analysis result with all discovered constituents
    */
   async analyzeAgent(agentName, rootDir) {
-    const agentsDir = path2.join(rootDir, "agents");
+    const agentsDir = path3.join(rootDir, "agents");
     const analysis = {
       agent: agentName,
       primaryPrompt: "",
@@ -548,7 +591,7 @@ var PackingService = class {
       warnings: [],
       errors: []
     };
-    const agentFilePath = await this.findFile(path2.join(agentsDir, "agents"), agentName);
+    const agentFilePath = await this.findFile(path3.join(agentsDir, "agents"), agentName);
     if (!agentFilePath) {
       analysis.errors.push(`Agent file not found: ${agentName}`);
       return analysis;
@@ -559,7 +602,7 @@ var PackingService = class {
       discoveredVia: "static",
       sharedWith: []
     });
-    const agentSource = fs2.readFileSync(agentFilePath, "utf-8");
+    const agentSource = fs3.readFileSync(agentFilePath, "utf-8");
     const agentPrompts = await extractAgentPrompts(agentSource);
     if (agentPrompts.sideA) {
       analysis.primaryPrompt = agentPrompts.sideA;
@@ -584,13 +627,13 @@ var PackingService = class {
    * @returns Object with generatedReadme and agentDescription
    */
   async generateReadmeForAnalysis(analysis, rootDir) {
-    const agentsDir = path2.join(rootDir, "agents");
+    const agentsDir = path3.join(rootDir, "agents");
     const metadataService = new MetadataService(agentsDir);
     let agentDescription;
     const agentItem = analysis.constituents.agents.find((a) => a.name === analysis.agent);
     if (agentItem?.filePath) {
       try {
-        const agentSource = fs2.readFileSync(agentItem.filePath, "utf-8");
+        const agentSource = fs3.readFileSync(agentItem.filePath, "utf-8");
         agentDescription = await extractAgentDescription(agentSource) || void 0;
       } catch {
       }
@@ -614,7 +657,7 @@ var PackingService = class {
    * include all endpoint modules discovered under agents/api.
    */
   async analyzeThreadEndpoints(agentsDir, analysis) {
-    const apiDir = path2.join(agentsDir, "api");
+    const apiDir = path3.join(agentsDir, "api");
     const endpoints = this.scanThreadEndpointFiles(apiDir);
     for (const endpoint of endpoints) {
       if (analysis.constituents.threadEndpoints.some((item) => item.name === endpoint.name)) {
@@ -636,15 +679,15 @@ var PackingService = class {
    * - `admin/users/[userId]/sync.post`
    */
   scanThreadEndpointFiles(apiDir, relativeDir = "") {
-    if (!fs2.existsSync(apiDir)) {
+    if (!fs3.existsSync(apiDir)) {
       return [];
     }
     const endpoints = [];
-    const currentDir = relativeDir ? path2.join(apiDir, relativeDir) : apiDir;
-    if (!fs2.existsSync(currentDir)) {
+    const currentDir = relativeDir ? path3.join(apiDir, relativeDir) : apiDir;
+    if (!fs3.existsSync(currentDir)) {
       return endpoints;
     }
-    const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
+    const entries = fs3.readdirSync(currentDir, { withFileTypes: true });
     if (entries.length > 0 && typeof entries[0] === "string") {
       return endpoints;
     }
@@ -652,8 +695,8 @@ var PackingService = class {
       const entryName = typeof entry === "string" ? entry : entry.name;
       const isDirectory = typeof entry === "string" ? false : entry.isDirectory();
       const isFile = typeof entry === "string" ? true : entry.isFile();
-      const entryRelative = relativeDir ? path2.posix.join(relativeDir.replace(/\\/g, "/"), entryName) : entryName;
-      const absolutePath = path2.join(apiDir, entryRelative);
+      const entryRelative = relativeDir ? path3.posix.join(relativeDir.replace(/\\/g, "/"), entryName) : entryName;
+      const absolutePath = path3.join(apiDir, entryRelative);
       if (isDirectory) {
         endpoints.push(...this.scanThreadEndpointFiles(apiDir, entryRelative));
         continue;
@@ -680,7 +723,7 @@ var PackingService = class {
    * include all effect modules discovered under agents/effects.
    */
   async analyzeEffects(agentsDir, analysis) {
-    const effectsDir = path2.join(agentsDir, "effects");
+    const effectsDir = path3.join(agentsDir, "effects");
     const effects = this.scanEffectFiles(effectsDir);
     for (const effect of effects) {
       if (analysis.constituents.effects.some((item) => item.name === effect.name)) {
@@ -702,15 +745,15 @@ var PackingService = class {
    * - `notifications/digest`
    */
   scanEffectFiles(effectsDir, relativeDir = "") {
-    if (!fs2.existsSync(effectsDir)) {
+    if (!fs3.existsSync(effectsDir)) {
       return [];
     }
     const effects = [];
-    const currentDir = relativeDir ? path2.join(effectsDir, relativeDir) : effectsDir;
-    if (!fs2.existsSync(currentDir)) {
+    const currentDir = relativeDir ? path3.join(effectsDir, relativeDir) : effectsDir;
+    if (!fs3.existsSync(currentDir)) {
       return effects;
     }
-    const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
+    const entries = fs3.readdirSync(currentDir, { withFileTypes: true });
     if (entries.length > 0 && typeof entries[0] === "string") {
       return effects;
     }
@@ -718,8 +761,8 @@ var PackingService = class {
       const entryName = typeof entry === "string" ? entry : entry.name;
       const isDirectory = typeof entry === "string" ? false : entry.isDirectory();
       const isFile = typeof entry === "string" ? true : entry.isFile();
-      const entryRelative = relativeDir ? path2.posix.join(relativeDir.replace(/\\/g, "/"), entryName) : entryName;
-      const absolutePath = path2.join(effectsDir, entryRelative);
+      const entryRelative = relativeDir ? path3.posix.join(relativeDir.replace(/\\/g, "/"), entryName) : entryName;
+      const absolutePath = path3.join(effectsDir, entryRelative);
       if (isDirectory) {
         effects.push(...this.scanEffectFiles(effectsDir, entryRelative));
         continue;
@@ -743,7 +786,7 @@ var PackingService = class {
    * Recursively analyze a prompt and its dependencies.
    */
   async analyzePrompt(promptName, agentsDir, analysis, visited, parentKey) {
-    const promptFilePath = await this.findFile(path2.join(agentsDir, "prompts"), promptName);
+    const promptFilePath = await this.findFile(path3.join(agentsDir, "prompts"), promptName);
     if (!promptFilePath) {
       analysis.warnings.push(`Prompt file not found: ${promptName}`);
       return;
@@ -762,7 +805,7 @@ var PackingService = class {
       return;
     }
     visited.add(`prompt:${promptName}`);
-    const promptSource = fs2.readFileSync(promptFilePath, "utf-8");
+    const promptSource = fs3.readFileSync(promptFilePath, "utf-8");
     const modelName = await extractPromptModel(promptSource);
     if (modelName) {
       await this.analyzeModel(modelName, agentsDir, analysis, visited, thisKey);
@@ -788,17 +831,17 @@ var PackingService = class {
    */
   async analyzeTool(toolName, agentsDir, analysis, visited, discoveredVia, parentKey) {
     const thisKey = `tool:${toolName}`;
-    const promptFilePath = await this.findFile(path2.join(agentsDir, "prompts"), toolName);
+    const promptFilePath = await this.findFile(path3.join(agentsDir, "prompts"), toolName);
     if (promptFilePath) {
       await this.analyzePrompt(toolName, agentsDir, analysis, visited, parentKey);
       return;
     }
-    const agentFilePath = await this.findFile(path2.join(agentsDir, "agents"), toolName);
+    const agentFilePath = await this.findFile(path3.join(agentsDir, "agents"), toolName);
     if (agentFilePath) {
       await this.analyzeNestedAgent(toolName, agentsDir, analysis, visited, parentKey);
       return;
     }
-    const toolFilePath = await this.findFile(path2.join(agentsDir, "tools"), toolName);
+    const toolFilePath = await this.findFile(path3.join(agentsDir, "tools"), toolName);
     if (!toolFilePath) {
       analysis.warnings.push(`Tool file not found: ${toolName}`);
       return;
@@ -816,7 +859,7 @@ var PackingService = class {
       return;
     }
     visited.add(`tool:${toolName}`);
-    const toolSource = fs2.readFileSync(toolFilePath, "utf-8");
+    const toolSource = fs3.readFileSync(toolFilePath, "utf-8");
     const { uses } = await extractToolUses(toolSource);
     for (const usedItem of uses) {
       await this.analyzeTool(usedItem, agentsDir, analysis, visited, "uses", thisKey);
@@ -826,7 +869,7 @@ var PackingService = class {
    * Analyze a nested agent (used as a handoff target).
    */
   async analyzeNestedAgent(agentName, agentsDir, analysis, visited, parentKey) {
-    const agentFilePath = await this.findFile(path2.join(agentsDir, "agents"), agentName);
+    const agentFilePath = await this.findFile(path3.join(agentsDir, "agents"), agentName);
     if (!agentFilePath) {
       analysis.warnings.push(`Agent file not found: ${agentName}`);
       return;
@@ -845,7 +888,7 @@ var PackingService = class {
       return;
     }
     visited.add(`agent:${agentName}`);
-    const agentSource = fs2.readFileSync(agentFilePath, "utf-8");
+    const agentSource = fs3.readFileSync(agentFilePath, "utf-8");
     const agentPrompts = await extractAgentPrompts(agentSource);
     if (agentPrompts.sideA) {
       await this.analyzePrompt(agentPrompts.sideA, agentsDir, analysis, visited, thisKey);
@@ -858,7 +901,7 @@ var PackingService = class {
    * Analyze a model and its fallbacks.
    */
   async analyzeModel(modelName, agentsDir, analysis, visited, parentKey) {
-    const modelFilePath = await this.findFile(path2.join(agentsDir, "models"), modelName);
+    const modelFilePath = await this.findFile(path3.join(agentsDir, "models"), modelName);
     if (!modelFilePath) {
       analysis.warnings.push(`Model file not found: ${modelName}`);
       return;
@@ -877,7 +920,7 @@ var PackingService = class {
       return;
     }
     visited.add(`model:${modelName}`);
-    const modelSource = fs2.readFileSync(modelFilePath, "utf-8");
+    const modelSource = fs3.readFileSync(modelFilePath, "utf-8");
     const fallbacks = await extractModelFallbacks(modelSource);
     for (const fallbackName of fallbacks) {
       await this.analyzeModel(fallbackName, agentsDir, analysis, visited, thisKey);
@@ -887,13 +930,13 @@ var PackingService = class {
    * Check which items are shared with other agents.
    */
   async checkSharedItems(agentsDir, analysis) {
-    const agentsPath = path2.join(agentsDir, "agents");
-    if (!fs2.existsSync(agentsPath)) return;
-    const agentFiles = fs2.readdirSync(agentsPath).filter((f) => f.endsWith(".ts"));
+    const agentsPath = path3.join(agentsDir, "agents");
+    if (!fs3.existsSync(agentsPath)) return;
+    const agentFiles = fs3.readdirSync(agentsPath).filter((f) => f.endsWith(".ts"));
     for (const agentFile of agentFiles) {
       const otherAgentName = agentFile.replace(".ts", "");
       if (otherAgentName === analysis.agent) continue;
-      const otherAnalysis = await this.analyzeAgentLight(otherAgentName, path2.dirname(agentsDir));
+      const otherAnalysis = await this.analyzeAgentLight(otherAgentName, path3.dirname(agentsDir));
       for (const prompt of analysis.constituents.prompts) {
         if (otherAnalysis.prompts.includes(prompt.name)) {
           prompt.sharedWith.push(otherAgentName);
@@ -925,19 +968,19 @@ var PackingService = class {
    */
   async analyzeAgentLight(agentName, rootDir) {
     const result = { prompts: [], tools: [], models: [] };
-    const agentsDir = path2.join(rootDir, "agents");
+    const agentsDir = path3.join(rootDir, "agents");
     const visited = /* @__PURE__ */ new Set();
-    const agentFilePath = await this.findFile(path2.join(agentsDir, "agents"), agentName);
+    const agentFilePath = await this.findFile(path3.join(agentsDir, "agents"), agentName);
     if (!agentFilePath) return result;
-    const agentSource = fs2.readFileSync(agentFilePath, "utf-8");
+    const agentSource = fs3.readFileSync(agentFilePath, "utf-8");
     const agentPrompts = await extractAgentPrompts(agentSource);
     const analyzePromptLight = async (promptName) => {
       if (visited.has(promptName)) return;
       visited.add(promptName);
       result.prompts.push(promptName);
-      const promptFilePath = await this.findFile(path2.join(agentsDir, "prompts"), promptName);
+      const promptFilePath = await this.findFile(path3.join(agentsDir, "prompts"), promptName);
       if (!promptFilePath) return;
-      const promptSource = fs2.readFileSync(promptFilePath, "utf-8");
+      const promptSource = fs3.readFileSync(promptFilePath, "utf-8");
       const modelName = await extractPromptModel(promptSource);
       if (modelName && !result.models.includes(modelName)) {
         result.models.push(modelName);
@@ -1010,14 +1053,15 @@ var PackingService = class {
         return result;
       }
       result.warnings = analysis.warnings;
-      const pkgOutputDir = path2.join(outputDir, packageId);
-      fs2.mkdirSync(path2.join(pkgOutputDir, "dist", "agents"), { recursive: true });
-      fs2.mkdirSync(path2.join(pkgOutputDir, "dist", "prompts"), { recursive: true });
-      fs2.mkdirSync(path2.join(pkgOutputDir, "dist", "tools"), { recursive: true });
-      fs2.mkdirSync(path2.join(pkgOutputDir, "dist", "models"), { recursive: true });
-      fs2.mkdirSync(path2.join(pkgOutputDir, "dist", "hooks"), { recursive: true });
-      fs2.mkdirSync(path2.join(pkgOutputDir, "dist", "effects"), { recursive: true });
-      fs2.mkdirSync(path2.join(pkgOutputDir, "dist", "thread-endpoints"), { recursive: true });
+      const safePackageId = assertSafePackageIdentifier(packageId);
+      const pkgOutputDir = resolvePathWithin(outputDir, safePackageId);
+      fs3.mkdirSync(path3.join(pkgOutputDir, "dist", "agents"), { recursive: true });
+      fs3.mkdirSync(path3.join(pkgOutputDir, "dist", "prompts"), { recursive: true });
+      fs3.mkdirSync(path3.join(pkgOutputDir, "dist", "tools"), { recursive: true });
+      fs3.mkdirSync(path3.join(pkgOutputDir, "dist", "models"), { recursive: true });
+      fs3.mkdirSync(path3.join(pkgOutputDir, "dist", "hooks"), { recursive: true });
+      fs3.mkdirSync(path3.join(pkgOutputDir, "dist", "effects"), { recursive: true });
+      fs3.mkdirSync(path3.join(pkgOutputDir, "dist", "thread-endpoints"), { recursive: true });
       const seenItems = /* @__PURE__ */ new Set();
       const allItems = [];
       for (const a of analysis.constituents.agents) {
@@ -1071,13 +1115,13 @@ var PackingService = class {
       }
       const externalDeps = /* @__PURE__ */ new Map();
       for (const item of allItems) {
-        const outputPath = path2.join(
+        const outputPath = resolvePathWithin(
           pkgOutputDir,
           "dist",
           this.getTypeDir(item.type),
           `${item.name}.js`
         );
-        fs2.mkdirSync(path2.dirname(outputPath), { recursive: true });
+        fs3.mkdirSync(path3.dirname(outputPath), { recursive: true });
         const deps = await this.bundleFile(item.filePath, outputPath, rootDir);
         for (const [depName, depVersion] of deps) {
           if (!externalDeps.has(depName)) {
@@ -1087,12 +1131,12 @@ var PackingService = class {
         result.filesCreated.push(outputPath);
       }
       const indexJs = this.generateReExportIndex(analysis, meta);
-      const indexJsPath = path2.join(pkgOutputDir, "dist", "index.js");
-      fs2.writeFileSync(indexJsPath, indexJs);
+      const indexJsPath = resolvePathWithin(pkgOutputDir, "dist", "index.js");
+      fs3.writeFileSync(indexJsPath, indexJs);
       result.filesCreated.push(indexJsPath);
       const indexDts = this.generateIndexDts(analysis);
-      const indexDtsPath = path2.join(pkgOutputDir, "dist", "index.d.ts");
-      fs2.writeFileSync(indexDtsPath, indexDts);
+      const indexDtsPath = resolvePathWithin(pkgOutputDir, "dist", "index.d.ts");
+      fs3.writeFileSync(indexDtsPath, indexDts);
       result.filesCreated.push(indexDtsPath);
       const pkgJson = this.generatePackageJson(
         finalPackageName,
@@ -1105,13 +1149,13 @@ var PackingService = class {
         license,
         licenseOwner
       );
-      const pkgJsonPath = path2.join(pkgOutputDir, "package.json");
-      fs2.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+      const pkgJsonPath = path3.join(pkgOutputDir, "package.json");
+      fs3.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
       result.filesCreated.push(pkgJsonPath);
       if (license) {
         const licenseContent = this.generateLicenseFile(license, licenseOwner);
-        const licensePath = path2.join(pkgOutputDir, "LICENSE");
-        fs2.writeFileSync(licensePath, licenseContent);
+        const licensePath = path3.join(pkgOutputDir, "LICENSE");
+        fs3.writeFileSync(licensePath, licenseContent);
         result.filesCreated.push(licensePath);
       }
       let readmeContent = readme;
@@ -1119,7 +1163,7 @@ var PackingService = class {
         const agentItem = analysis.constituents.agents.find((a) => a.name === agentName);
         let agentDescription;
         if (agentItem?.filePath) {
-          const agentSource = fs2.readFileSync(agentItem.filePath, "utf-8");
+          const agentSource = fs3.readFileSync(agentItem.filePath, "utf-8");
           agentDescription = await extractAgentDescription(agentSource) || void 0;
         }
         readmeContent = this.generateReadme(
@@ -1130,21 +1174,21 @@ var PackingService = class {
           agentDescription
         );
       }
-      const readmePath = path2.join(pkgOutputDir, "README.md");
-      fs2.writeFileSync(readmePath, readmeContent);
+      const readmePath = path3.join(pkgOutputDir, "README.md");
+      fs3.writeFileSync(readmePath, readmeContent);
       result.filesCreated.push(readmePath);
       if (removeOriginals || itemSelections) {
         result.filesRemoved = [];
         for (const item of allItems) {
           const selection = itemSelections?.find((s) => s.name === item.name && s.type === item.type);
           const shouldRemove = selection ? selection.mode === "extract" : removeOriginals && item.sharedWith.length === 0 && item.type !== "thread-endpoint" && item.type !== "effect";
-          if (shouldRemove && fs2.existsSync(item.filePath)) {
-            fs2.unlinkSync(item.filePath);
+          if (shouldRemove && fs3.existsSync(item.filePath)) {
+            fs3.unlinkSync(item.filePath);
             result.filesRemoved.push(item.filePath);
           }
         }
       }
-      const agentsDir = path2.join(rootDir, "agents");
+      const agentsDir = path3.join(rootDir, "agents");
       const metadataService = new MetadataService(agentsDir);
       const metadata = {
         packageName: finalPackageName,
@@ -1178,7 +1222,7 @@ var PackingService = class {
     const commonjs = (await import('@rollup/plugin-commonjs')).default;
     const esbuild = (await import('rollup-plugin-esbuild')).default;
     const externalDeps = /* @__PURE__ */ new Map();
-    const agentsDir = path2.join(rootDir, "agents");
+    const agentsDir = path3.join(rootDir, "agents");
     const resolveVersion = this.resolvePackageVersion.bind(this);
     const trackExternalsPlugin = {
       name: "track-externals",
@@ -1187,14 +1231,14 @@ var PackingService = class {
           return null;
         }
         if (source.startsWith("./") || source.startsWith("../")) {
-          const resolved = path2.resolve(path2.dirname(importer), source);
+          const resolved = path3.resolve(path3.dirname(importer), source);
           let tsResolved = resolved;
           if (!resolved.endsWith(".ts") && !resolved.endsWith(".js")) {
-            if (fs2.existsSync(`${resolved}.ts`)) {
+            if (fs3.existsSync(`${resolved}.ts`)) {
               tsResolved = `${resolved}.ts`;
-            } else if (fs2.existsSync(`${resolved}.js`)) {
+            } else if (fs3.existsSync(`${resolved}.js`)) {
               tsResolved = `${resolved}.js`;
-            } else if (fs2.existsSync(`${resolved}/index.ts`)) {
+            } else if (fs3.existsSync(`${resolved}/index.ts`)) {
               tsResolved = `${resolved}/index.ts`;
             }
           }
@@ -1243,11 +1287,11 @@ var PackingService = class {
         exports: "named"
       });
       const bundledCode = output[0].code;
-      const header = `// Bundled from: ${path2.relative(rootDir, inputPath)}
+      const header = `// Bundled from: ${path3.relative(rootDir, inputPath)}
 // Local dependencies have been inlined
 
 `;
-      fs2.writeFileSync(outputPath, header + bundledCode);
+      fs3.writeFileSync(outputPath, header + bundledCode);
       await bundle.close();
     } catch (error) {
       await bundle.close();
@@ -1672,30 +1716,31 @@ Copyright (c) ${year} ${copyrightHolder}
    * @returns Package info or null if not found
    */
   getPackedInfo(packageId, rootDir) {
-    const packedDir = path2.join(rootDir, "agents", "packed");
-    let packageDir = path2.join(packedDir, packageId);
-    if (!fs2.existsSync(packageDir)) {
-      if (!fs2.existsSync(packedDir)) {
+    const packedDir = path3.join(rootDir, "agents", "packed");
+    const safePackageId = assertSafePackageIdentifier(packageId);
+    let packageDir = resolvePathWithin(packedDir, safePackageId);
+    if (!fs3.existsSync(packageDir)) {
+      if (!fs3.existsSync(packedDir)) {
         return null;
       }
-      const dirs = fs2.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      const dirs = fs3.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
       const matchingDir = dirs.find(
         (d) => d === packageId || d === `standardagent-${packageId}` || d === `standardagent-${packageId.replace(/_/g, "-")}`
       );
       if (!matchingDir) {
         return null;
       }
-      packageDir = path2.join(packedDir, matchingDir);
+      packageDir = path3.join(packedDir, matchingDir);
     }
-    const pkgJsonPath = path2.join(packageDir, "package.json");
-    if (!fs2.existsSync(pkgJsonPath)) {
+    const pkgJsonPath = path3.join(packageDir, "package.json");
+    if (!fs3.existsSync(pkgJsonPath)) {
       return null;
     }
-    const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+    const pkgJson = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
     let readme;
-    const readmePath = path2.join(packageDir, "README.md");
-    if (fs2.existsSync(readmePath)) {
-      readme = fs2.readFileSync(readmePath, "utf-8");
+    const readmePath = path3.join(packageDir, "README.md");
+    if (fs3.existsSync(readmePath)) {
+      readme = fs3.readFileSync(readmePath, "utf-8");
     }
     return {
       packageName: pkgJson.name,
@@ -1713,11 +1758,11 @@ Copyright (c) ${year} ${copyrightHolder}
    * @returns Array of package directory names
    */
   listPackedPackages(rootDir) {
-    const packedDir = path2.join(rootDir, "agents", "packed");
-    if (!fs2.existsSync(packedDir)) {
+    const packedDir = path3.join(rootDir, "agents", "packed");
+    if (!fs3.existsSync(packedDir)) {
       return [];
     }
-    return fs2.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    return fs3.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   }
   /**
    * Generate README.md content for a packed agent.
@@ -1764,17 +1809,17 @@ ${license || "See LICENSE file"}
    * Find a file by name in a directory.
    */
   async findFile(dir, name) {
-    if (!fs2.existsSync(dir)) {
+    if (!fs3.existsSync(dir)) {
       return null;
     }
-    const exactPath = path2.join(dir, `${name}.ts`);
-    if (fs2.existsSync(exactPath)) {
+    const exactPath = resolvePathWithin(dir, `${name}.ts`);
+    if (fs3.existsSync(exactPath)) {
       return exactPath;
     }
-    const files = fs2.readdirSync(dir).filter((f) => f.endsWith(".ts"));
+    const files = fs3.readdirSync(dir).filter((f) => f.endsWith(".ts"));
     for (const file of files) {
-      const filePath = path2.join(dir, file);
-      const source = fs2.readFileSync(filePath, "utf-8");
+      const filePath = path3.join(dir, file);
+      const source = fs3.readFileSync(filePath, "utf-8");
       const extractedName = await extractDefinitionName(source);
       if (extractedName === name) {
         return filePath;
@@ -1786,15 +1831,15 @@ ${license || "See LICENSE file"}
    * List all agents in the workspace.
    */
   async listAgents(rootDir) {
-    const agentsDir = path2.join(rootDir, "agents", "agents");
-    if (!fs2.existsSync(agentsDir)) {
+    const agentsDir = path3.join(rootDir, "agents", "agents");
+    if (!fs3.existsSync(agentsDir)) {
       return [];
     }
-    const files = fs2.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
+    const files = fs3.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
     const agents = [];
     for (const file of files) {
-      const filePath = path2.join(agentsDir, file);
-      const source = fs2.readFileSync(filePath, "utf-8");
+      const filePath = path3.join(agentsDir, file);
+      const source = fs3.readFileSync(filePath, "utf-8");
       const name = await extractDefinitionName(source);
       if (name) {
         agents.push(name);
@@ -1810,7 +1855,7 @@ var PackageDiscoveryService = class {
   constructor(config) {
     this.config = {
       rootDir: config.rootDir,
-      packedDir: config.packedDir ?? path2.join(config.rootDir, "agents", "packed"),
+      packedDir: config.packedDir ?? path3.join(config.rootDir, "agents", "packed"),
       scanNpm: config.scanNpm ?? true,
       scanLocal: config.scanLocal ?? true
     };
@@ -1843,19 +1888,19 @@ var PackageDiscoveryService = class {
    */
   async discoverNpmPackages() {
     const packages = [];
-    const nodeModulesDir = path2.join(this.config.rootDir, "node_modules");
-    if (!fs2.existsSync(nodeModulesDir)) {
+    const nodeModulesDir = path3.join(this.config.rootDir, "node_modules");
+    if (!fs3.existsSync(nodeModulesDir)) {
       return packages;
     }
     const rootEntries = await this.scanDirectory(nodeModulesDir);
     for (const entry of rootEntries) {
       if (entry.startsWith(".")) continue;
       if (entry.startsWith("@")) {
-        const scopeDir = path2.join(nodeModulesDir, entry);
+        const scopeDir = path3.join(nodeModulesDir, entry);
         const scopeEntries = await this.scanDirectory(scopeDir);
         for (const scopedPkg of scopeEntries) {
           if (scopedPkg.startsWith(".")) continue;
-          const pkgDir = path2.join(scopeDir, scopedPkg);
+          const pkgDir = path3.join(scopeDir, scopedPkg);
           const fullName = `${entry}/${scopedPkg}`;
           const pkg = await this.checkNpmPackage(pkgDir, fullName);
           if (pkg) {
@@ -1863,7 +1908,7 @@ var PackageDiscoveryService = class {
           }
         }
       } else {
-        const pkgDir = path2.join(nodeModulesDir, entry);
+        const pkgDir = path3.join(nodeModulesDir, entry);
         const pkg = await this.checkNpmPackage(pkgDir, entry);
         if (pkg) {
           packages.push(pkg);
@@ -1879,12 +1924,12 @@ var PackageDiscoveryService = class {
    * which must contain `entryAgents` array.
    */
   async checkNpmPackage(pkgDir, pkgName) {
-    const pkgJsonPath = path2.join(pkgDir, "package.json");
-    if (!fs2.existsSync(pkgJsonPath)) {
+    const pkgJsonPath = path3.join(pkgDir, "package.json");
+    if (!fs3.existsSync(pkgJsonPath)) {
       return null;
     }
     try {
-      const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
       const isStandardAgent = (
         // Has "standardagent" keyword
         pkgJson.keywords?.includes("standardagent") || // Has "standardagent-*" prefix
@@ -1921,21 +1966,21 @@ var PackageDiscoveryService = class {
    */
   async discoverLocalPackages() {
     const packages = [];
-    if (!fs2.existsSync(this.config.packedDir)) {
+    if (!fs3.existsSync(this.config.packedDir)) {
       return packages;
     }
     const entries = await this.scanDirectory(this.config.packedDir);
     for (const entry of entries) {
       if (entry.startsWith(".")) continue;
-      const pkgDir = path2.join(this.config.packedDir, entry);
-      const stat = fs2.statSync(pkgDir);
+      const pkgDir = path3.join(this.config.packedDir, entry);
+      const stat = fs3.statSync(pkgDir);
       if (!stat.isDirectory()) continue;
       if (entry.startsWith("@")) {
         const scopeEntries = await this.scanDirectory(pkgDir);
         for (const scopedPkg of scopeEntries) {
           if (scopedPkg.startsWith(".")) continue;
-          const scopedPkgDir = path2.join(pkgDir, scopedPkg);
-          const scopedStat = fs2.statSync(scopedPkgDir);
+          const scopedPkgDir = path3.join(pkgDir, scopedPkg);
+          const scopedStat = fs3.statSync(scopedPkgDir);
           if (!scopedStat.isDirectory()) continue;
           const fullName = `${entry}/${scopedPkg}`;
           const pkg = await this.checkLocalPackage(scopedPkgDir, fullName);
@@ -1958,12 +2003,12 @@ var PackageDiscoveryService = class {
    * Detection is based on the `standardagent` field in package.json.
    */
   async checkLocalPackage(pkgDir, dirName) {
-    const pkgJsonPath = path2.join(pkgDir, "package.json");
-    if (!fs2.existsSync(pkgJsonPath)) {
+    const pkgJsonPath = path3.join(pkgDir, "package.json");
+    if (!fs3.existsSync(pkgJsonPath)) {
       return null;
     }
     try {
-      const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
       if (!pkgJson.standardagent?.entryAgents) {
         return null;
       }
@@ -1988,10 +2033,10 @@ var PackageDiscoveryService = class {
    * Scan a directory and return entry names.
    */
   async scanDirectory(dir) {
-    if (!fs2.existsSync(dir)) {
+    if (!fs3.existsSync(dir)) {
       return [];
     }
-    const entries = fs2.readdirSync(dir);
+    const entries = fs3.readdirSync(dir);
     return entries;
   }
   /**
@@ -2088,29 +2133,29 @@ var UnpackingService = class {
       }
       analysis.version = pkg.version;
       analysis.source = pkg.source;
-      const indexPath = path2.join(pkg.path, "dist", "index.js");
-      if (!fs2.existsSync(indexPath)) {
+      const indexPath = path3.join(pkg.path, "dist", "index.js");
+      if (!fs3.existsSync(indexPath)) {
         analysis.errors.push(`Package index not found: ${indexPath}`);
         return analysis;
       }
-      const indexContent = fs2.readFileSync(indexPath, "utf-8");
+      const indexContent = fs3.readFileSync(indexPath, "utf-8");
       const registryItems = await this.parseIndexExports(indexContent);
       const availableItems = /* @__PURE__ */ new Map();
       for (const item of registryItems) {
         availableItems.set(`${item.type}:${item.name}`, item);
       }
-      const agentsDir = path2.join(rootDir, "agents");
+      const agentsDir = path3.join(rootDir, "agents");
       const itemsWithRelations = [];
       for (const item of registryItems) {
-        const targetPath = path2.join(agentsDir, TYPE_TO_TARGET_DIR[item.type], `${item.name}.ts`);
-        const sourcePath = path2.join(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
+        const targetPath = resolvePathWithin(agentsDir, TYPE_TO_TARGET_DIR[item.type], `${item.name}.ts`);
+        const sourcePath = resolvePathWithin(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
         const existsGlobally = this.fileExists(targetPath);
-        const sourceExists = fs2.existsSync(sourcePath);
+        const sourceExists = fs3.existsSync(sourcePath);
         if (!sourceExists) {
           analysis.warnings.push(`Source file not found for ${item.type} "${item.name}": ${sourcePath}`);
           continue;
         }
-        const bundledCode = fs2.readFileSync(sourcePath, "utf-8");
+        const bundledCode = fs3.readFileSync(sourcePath, "utf-8");
         const children = await this.discoverRelationships(item.type, item.name, bundledCode, availableItems);
         itemsWithRelations.push({
           name: item.name,
@@ -2120,10 +2165,10 @@ var UnpackingService = class {
           action: existsGlobally ? "skip" : "generate"
         });
         for (const child of children) {
-          const childTargetPath = path2.join(agentsDir, TYPE_TO_TARGET_DIR[child.type], `${child.name}.ts`);
-          const childSourcePath = path2.join(pkg.path, "dist", TYPE_TO_DIR[child.type], `${child.name}.js`);
+          const childTargetPath = resolvePathWithin(agentsDir, TYPE_TO_TARGET_DIR[child.type], `${child.name}.ts`);
+          const childSourcePath = resolvePathWithin(pkg.path, "dist", TYPE_TO_DIR[child.type], `${child.name}.js`);
           const childExists = this.fileExists(childTargetPath);
-          const childSourceExists = fs2.existsSync(childSourcePath);
+          const childSourceExists = fs3.existsSync(childSourcePath);
           if (!childSourceExists) {
             continue;
           }
@@ -2226,8 +2271,8 @@ var UnpackingService = class {
         return result;
       }
       const itemsToProcess = this.applySelections(analysis.items, itemSelections);
-      const pkgJsonPath = path2.join(pkg.path, "package.json");
-      const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJsonPath = path3.join(pkg.path, "package.json");
+      const pkgJson = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
       let author = "";
       if (typeof pkgJson.author === "string") {
         author = pkgJson.author;
@@ -2252,18 +2297,19 @@ var UnpackingService = class {
           continue;
         }
         try {
-          const sourcePath = path2.join(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
-          const bundledCode = fs2.readFileSync(sourcePath, "utf-8");
+          const sourcePath = resolvePathWithin(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
+          const targetPath = resolvePathWithin(path3.join(rootDir, "agents"), path3.relative(path3.join(rootDir, "agents"), item.targetPath));
+          const bundledCode = fs3.readFileSync(sourcePath, "utf-8");
           let tsCode = await transformBundledJs(bundledCode);
           if (item.type === "agent") {
             tsCode = await injectAgentMetadata(tsCode, agentMetadata);
           }
-          const dir = path2.dirname(item.targetPath);
-          if (!fs2.existsSync(dir)) {
-            fs2.mkdirSync(dir, { recursive: true });
+          const dir = path3.dirname(targetPath);
+          if (!fs3.existsSync(dir)) {
+            fs3.mkdirSync(dir, { recursive: true });
           }
-          fs2.writeFileSync(item.targetPath, tsCode);
-          result.filesGenerated.push(item.targetPath);
+          fs3.writeFileSync(targetPath, tsCode);
+          result.filesGenerated.push(targetPath);
         } catch (error) {
           result.warnings.push(
             `Failed to generate ${item.type} "${item.name}": ${error instanceof Error ? error.message : String(error)}`
@@ -2272,7 +2318,12 @@ var UnpackingService = class {
       }
       if (deletePackage && pkg.source === "local") {
         try {
-          this.deleteDirectory(pkg.path);
+          const localPackedRoot = path3.join(rootDir, "agents", "packed");
+          const safePackagePath = resolvePathWithin(
+            localPackedRoot,
+            path3.relative(localPackedRoot, pkg.path)
+          );
+          this.deleteDirectory(safePackagePath);
           result.packageDeleted = true;
         } catch (error) {
           result.warnings.push(
@@ -2351,14 +2402,14 @@ var UnpackingService = class {
    */
   async resolvePackage(pkgIdentifier, rootDir) {
     if (pkgIdentifier.startsWith("/") || pkgIdentifier.startsWith("./")) {
-      const absolutePath = path2.isAbsolute(pkgIdentifier) ? pkgIdentifier : path2.join(rootDir, pkgIdentifier);
-      const pkgJsonPath2 = path2.join(absolutePath, "package.json");
-      if (fs2.existsSync(pkgJsonPath2)) {
+      const absolutePath = path3.isAbsolute(pkgIdentifier) ? pkgIdentifier : path3.join(rootDir, pkgIdentifier);
+      const pkgJsonPath2 = path3.join(absolutePath, "package.json");
+      if (fs3.existsSync(pkgJsonPath2)) {
         try {
-          const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath2, "utf-8"));
+          const pkgJson = JSON.parse(fs3.readFileSync(pkgJsonPath2, "utf-8"));
           if (pkgJson.standardagent?.entryAgents) {
             return {
-              packageId: pkgJson.name || path2.basename(absolutePath),
+              packageId: pkgJson.name || path3.basename(absolutePath),
               version: pkgJson.version || "0.0.0",
               source: "local",
               path: absolutePath,
@@ -2370,11 +2421,12 @@ var UnpackingService = class {
       }
       return null;
     }
-    const packedDir = path2.join(rootDir, "agents", "packed", pkgIdentifier);
-    const pkgJsonPath = path2.join(packedDir, "package.json");
-    if (fs2.existsSync(pkgJsonPath)) {
+    const safeIdentifier = assertSafePackageIdentifier(pkgIdentifier);
+    const packedDir = resolvePathWithin(path3.join(rootDir, "agents", "packed"), safeIdentifier);
+    const pkgJsonPath = path3.join(packedDir, "package.json");
+    if (fs3.existsSync(pkgJsonPath)) {
       try {
-        const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+        const pkgJson = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
         if (pkgJson.standardagent?.entryAgents) {
           return {
             packageId: pkgJson.name || pkgIdentifier,
@@ -2415,18 +2467,18 @@ var UnpackingService = class {
    * Check if a file exists.
    */
   fileExists(filePath) {
-    if (fs2.existsSync(filePath)) {
+    if (fs3.existsSync(filePath)) {
       return true;
     }
     const withoutExt = filePath.replace(/\.(ts|js)$/, "");
-    return fs2.existsSync(`${withoutExt}.ts`) || fs2.existsSync(`${withoutExt}.js`);
+    return fs3.existsSync(`${withoutExt}.ts`) || fs3.existsSync(`${withoutExt}.js`);
   }
   /**
    * Recursively delete a directory.
    */
   deleteDirectory(dirPath) {
-    if (fs2.existsSync(dirPath)) {
-      fs2.rmSync(dirPath, { recursive: true, force: true });
+    if (fs3.existsSync(dirPath)) {
+      fs3.rmSync(dirPath, { recursive: true, force: true });
     }
   }
   /**