droid-mode 0.0.9 → 0.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "droid-mode",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "Progressive Code-Mode MCP integration for Factory.ai Droid - access MCP tools without context bloat",
   "type": "module",
   "main": "dist/cli.js",

package/templates/skills/droid-mode/lib/hydrate.mjs

@@ -1,6 +1,6 @@
 import path from "node:path";
 import fs from "node:fs";
-import { ensureDir, nowIsoCompact, safeIdentifier, writeJson, getDroidModeDataDir } from "./util.mjs";
+import { ensureDir, nowIsoCompact, safeIdentifier, uniqueSafeToolMap, writeJson, getDroidModeDataDir, serverNameToDirName } from "./util.mjs";
 
 /** @param {string} s */
 function toPascalCase(s) {
@@ -89,9 +89,10 @@ function schemaToTs(schema, depth = 0) {
  */
 export function hydrateTools(opts) {
   const ts = nowIsoCompact();
+  const serverDir = serverNameToDirName(opts.serverName);
   const baseOut =
     opts.outDir ||
-    path.join(getDroidModeDataDir(), "hydrated", opts.serverName, ts);
+    path.join(getDroidModeDataDir(), "hydrated", serverDir, ts);
 
   ensureDir(baseOut);
 
@@ -103,11 +104,9 @@ export function hydrateTools(opts) {
     if (t) selected.push(t);
   }
 
-  const toolmap = {};
-  for (const t of selected) {
-    const safe = safeIdentifier(t?.name || "tool");
-    toolmap[safe] = t?.name || safe;
-  }
+  // Build collision-free toolmap using shared function
+  const selectedNames = selected.map(t => t?.name || "tool");
+  const toolmap = uniqueSafeToolMap(selectedNames);
 
   writeJson(path.join(baseOut, "tools.json"), selected);
   writeJson(path.join(baseOut, "toolmap.json"), toolmap);
@@ -116,15 +115,22 @@ export function hydrateTools(opts) {
   const toolmapModule = `// Auto-generated by droid-mode.\nexport default ${JSON.stringify(toolmap, null, 2)};\n`;
   fs.writeFileSync(path.join(baseOut, "toolmap.mjs"), toolmapModule, "utf-8");
 
-  // types.d.ts
+  // types.d.ts - use toolmap keys (already collision-free)
   const typeLines = [
     `// Auto-generated by droid-mode (best-effort).`,
     `// This file exists to improve IDE autocomplete; it is NOT a contract.`,
     ``,
   ];
 
+  // Build reverse map: toolName -> safeName for lookup
+  const nameToSafe = Object.create(null);
+  for (const [safe, name] of Object.entries(toolmap)) {
+    nameToSafe[name] = safe;
+  }
+
   for (const t of selected) {
-    const safe = safeIdentifier(t?.name || "tool");
+    const toolName = t?.name || "tool";
+    const safe = nameToSafe[toolName] || safeIdentifier(toolName);
     const pascal = toPascalCase(safe);
     const inSchema = t?.inputSchema || t?.parameters || null;
     const outSchema = t?.outputSchema || null;

package/templates/skills/droid-mode/lib/run.mjs

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import vm from "node:vm";
-import { nowIsoCompact, sha256Hex, safeIdentifier, ensureDir, getDroidModeDataDir, writeJson } from "./util.mjs";
+import { nowIsoCompact, sha256Hex, uniqueSafeToolMap, ensureDir, getDroidModeDataDir, writeJson, serverNameToDirName } from "./util.mjs";
 
 /**
  * Static, best-effort disallow list for sandboxed workflows.
@@ -100,13 +100,10 @@ export function createToolApi(opts) {
     throw lastError;
   };
 
-  // safe-name wrapper map
+  // Build collision-free toolmap using shared function
+  const toolmap = uniqueSafeToolMap(opts.toolNames ?? []);
   const t = {};
-  const toolmap = {};
-
-  for (const toolName of opts.toolNames) {
-    const safe = safeIdentifier(toolName);
-    toolmap[safe] = toolName;
+  for (const [safe, toolName] of Object.entries(toolmap)) {
     t[safe] = (args) => call(toolName, args);
   }
 
@@ -200,10 +197,12 @@ export async function executeWorkflow(opts) {
 export function writeRunArtifact(opts) {
   const dataDir = getDroidModeDataDir();
   const ts = nowIsoCompact();
-  const outDir = path.join(dataDir, "runs", opts.serverName, ts);
+  const serverDir = serverNameToDirName(opts.serverName);
+  const outDir = path.join(dataDir, "runs", serverDir, ts);
   ensureDir(outDir);
   const payload = {
     serverName: opts.serverName,
+    serverDir,
     workflowPath: opts.workflowPath,
     tools: opts.tools,
     finishedAt: new Date().toISOString(),

package/templates/skills/droid-mode/lib/tool_index.mjs

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { getDroidModeDataDir, readJsonFileIfExists, writeJson } from "./util.mjs";
+import { getDroidModeDataDir, readJsonFileIfExists, writeJson, serverNameToDirName } from "./util.mjs";
 
 /**
  * @param {import("./mcp_client.mjs").McpClient} client
@@ -27,7 +27,8 @@ export async function fetchAllTools(client) {
  */
 export async function getToolsCached(opts) {
   const dataDir = getDroidModeDataDir();
-  const cacheFile = path.join(dataDir, "cache", opts.serverName, "tools.json");
+  const serverDir = serverNameToDirName(opts.serverName);
+  const cacheFile = path.join(dataDir, "cache", serverDir, "tools.json");
   const maxAgeMs = typeof opts.maxAgeMs === "number" ? opts.maxAgeMs : 30 * 60 * 1000; // 30 minutes
 
   if (!opts.refresh) {
@@ -46,6 +47,7 @@ export async function getToolsCached(opts) {
   const payload = {
     fetchedAt: new Date().toISOString(),
     serverName: opts.serverName,
+    serverDir,
     protocolVersion: opts.client.negotiatedProtocolVersion,
     serverInfo: opts.client.serverInfo,
     capabilities: opts.client.serverCapabilities,

package/templates/skills/droid-mode/lib/util.mjs

@@ -17,6 +17,25 @@ export function sha256Hex(s) {
   return crypto.createHash("sha256").update(s).digest("hex");
 }
 
+/**
+ * Convert an arbitrary server name into a safe directory segment.
+ * Always sanitizes and appends hash suffix for safety.
+ * @param {string} serverName
+ * @returns {string}
+ */
+export function serverNameToDirName(serverName) {
+  const raw = String(serverName ?? "");
+  const hash = sha256Hex(raw).slice(0, 8);
+  const base = raw
+    .replace(/[/\\]/g, "_")           // block path separators
+    .replace(/\.\./g, "_")            // block traversal
+    .replace(/[^a-zA-Z0-9._-]/g, "_") // whitelist safe chars
+    .replace(/^\.+/g, "")             // avoid dotfiles
+    .slice(0, 40);
+
+  return `${base || "server"}-${hash}`;
+}
+
 /**
  * Convert a tool name (often snake_case or kebab-case) to a safe camelCase identifier.
  * @param {string} toolName
@@ -37,6 +56,55 @@ export function safeIdentifier(toolName) {
   return "_" + camel;
 }
 
+/**
+ * Build a collision-free safeName -> toolName map.
+ * All colliding tools get a hash suffix (not just the "losers").
+ * Guarantees deterministic output regardless of input order.
+ * 
+ * @param {string[]} toolNames
+ * @returns {Record<string, string>} safeName -> originalToolName
+ */
+export function uniqueSafeToolMap(toolNames) {
+  const map = Object.create(null);
+  
+  // Phase 1: Group by base identifier, caching base names
+  // Handle undefined/null names with fallback (matches prior behavior)
+  const groups = new Map(); // base -> [{name, base}, ...]
+  for (const rawName of toolNames) {
+    // Matches exact prior semantics: t?.name || "tool"
+    // Only null/undefined/empty-string fall back; whitespace-only IS kept
+    const toolName = rawName || "tool";
+    const base = safeIdentifier(toolName);
+    if (!groups.has(base)) groups.set(base, []);
+    groups.get(base).push({ name: toolName, base });
+  }
+
+  // Phase 2: Assign safe names (sort colliding groups for determinism)
+  for (const [base, tools] of groups) {
+    if (tools.length === 1) {
+      // No collision: use base name directly
+      map[base] = tools[0].name;
+    } else {
+      // Collision: sort by string comparison for determinism
+      // (localeCompare varies by OS/locale; relational operators are consistent)
+      tools.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+      for (const { name: toolName, base: cachedBase } of tools) {
+        const suffix = sha256Hex(toolName).slice(0, 8); // 8 chars = 4B combinations
+        let safe = `${cachedBase}_${suffix}`;
+        // Guarantee uniqueness even on hash collision (extremely rare)
+        let counter = 0;
+        while (map[safe] !== undefined) {
+          counter++;
+          safe = `${cachedBase}_${suffix}_${counter}`;
+        }
+        map[safe] = toolName;
+      }
+    }
+  }
+
+  return map;
+}
+
 /**
  * Lightweight CLI args parser (supports: --k=v, --k v, flags, positional args).
  * Returns { _: string[], flags: Record<string, string|boolean> }.