droid-mode 0.0.1

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

@@ -0,0 +1,164 @@
+import path from "node:path";
+import fs from "node:fs";
+import { ensureDir, nowIsoCompact, safeIdentifier, writeJson, getDroidModeDataDir } from "./util.mjs";
+
+/** @param {string} s */
+function toPascalCase(s) {
+  if (!s) return "Tool";
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+/**
+ * Best-effort JSON Schema → TypeScript type string.
+ * This is intentionally conservative: unknown/complex schemas become `any`.
+ * @param {any} schema
+ * @param {number} depth
+ */
+function schemaToTs(schema, depth = 0) {
+  if (!schema || typeof schema !== "object") return "any";
+  if (depth > 8) return "any";
+  if (schema.$ref) return "any";
+
+  // enum
+  if (Array.isArray(schema.enum) && schema.enum.length) {
+    const vals = schema.enum;
+    if (vals.length > 20) return typeof vals[0] === "number" ? "number" : "string";
+    return vals
+      .map((v) => (typeof v === "string" ? JSON.stringify(v) : typeof v === "number" ? String(v) : "any"))
+      .join(" | ");
+  }
+
+  // anyOf/oneOf/allOf
+  for (const key of ["oneOf", "anyOf"]) {
+    if (Array.isArray(schema[key]) && schema[key].length) {
+      return schema[key].map((s) => schemaToTs(s, depth + 1)).join(" | ");
+    }
+  }
+  if (Array.isArray(schema.allOf) && schema.allOf.length) {
+    return schema.allOf.map((s) => schemaToTs(s, depth + 1)).join(" & ");
+  }
+
+  const t = schema.type;
+
+  if (t === "string") return "string";
+  if (t === "number" || t === "integer") return "number";
+  if (t === "boolean") return "boolean";
+  if (t === "null") return "null";
+
+  if (t === "array") {
+    const item = schema.items ? schemaToTs(schema.items, depth + 1) : "any";
+    return `Array<${item}>`;
+  }
+
+  if (t === "object" || schema.properties || schema.additionalProperties) {
+    const props = schema.properties || {};
+    const req = new Set(Array.isArray(schema.required) ? schema.required : []);
+    const lines = ["{"];
+
+    for (const [k, v] of Object.entries(props)) {
+      const optional = req.has(k) ? "" : "?";
+      lines.push(`  ${JSON.stringify(k)}${optional}: ${schemaToTs(v, depth + 1)};`);
+    }
+
+    if (schema.additionalProperties) {
+      if (schema.additionalProperties === true) {
+        lines.push(`  [key: string]: any;`);
+      } else if (typeof schema.additionalProperties === "object") {
+        lines.push(`  [key: string]: ${schemaToTs(schema.additionalProperties, depth + 1)};`);
+      }
+    }
+
+    lines.push("}");
+    return lines.join("\n");
+  }
+
+  // If type omitted but properties exist
+  if (schema.properties) return schemaToTs({ ...schema, type: "object" }, depth + 1);
+
+  return "any";
+}
+
+/**
+ * Generate a hydration bundle (schemas + TS types + safe tool map).
+ * @param {{
+ *   serverName: string,
+ *   tools: any[],
+ *   toolNames: string[],
+ *   outDir?: string,
+ * }} opts
+ */
+export function hydrateTools(opts) {
+  const ts = nowIsoCompact();
+  const baseOut =
+    opts.outDir ||
+    path.join(getDroidModeDataDir(), "hydrated", opts.serverName, ts);
+
+  ensureDir(baseOut);
+
+  // Select tools by name
+  const byName = new Map(opts.tools.map((t) => [t?.name, t]));
+  const selected = [];
+  for (const n of opts.toolNames) {
+    const t = byName.get(n);
+    if (t) selected.push(t);
+  }
+
+  const toolmap = {};
+  for (const t of selected) {
+    const safe = safeIdentifier(t?.name || "tool");
+    toolmap[safe] = t?.name || safe;
+  }
+
+  writeJson(path.join(baseOut, "tools.json"), selected);
+  writeJson(path.join(baseOut, "toolmap.json"), toolmap);
+
+  // Also provide an ESM-friendly toolmap module (avoids JSON import assertions).
+  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
+  const typeLines = [
+    `// Auto-generated by droid-mode (best-effort).`,
+    `// This file exists to improve IDE autocomplete; it is NOT a contract.`,
+    ``,
+  ];
+
+  for (const t of selected) {
+    const safe = safeIdentifier(t?.name || "tool");
+    const pascal = toPascalCase(safe);
+    const inSchema = t?.inputSchema || t?.parameters || null;
+    const outSchema = t?.outputSchema || null;
+
+    const argsTs = schemaToTs(inSchema, 0);
+    const resTs = outSchema ? schemaToTs(outSchema, 0) : "any";
+
+    typeLines.push(`export type ${pascal}Args = ${argsTs};`);
+    typeLines.push(`export type ${pascal}Result = ${resTs};`);
+    typeLines.push("");
+  }
+
+  fs.writeFileSync(path.join(baseOut, "types.d.ts"), typeLines.join("\n"), "utf-8");
+
+  // api.mjs: convenience builder (requires you to provide callTool)
+  const apiLines = [
+    `// Auto-generated by droid-mode.`,
+    `// Usage:`,
+    `//   import { buildApi } from "./api.mjs";`,
+    `//   import toolmap from "./toolmap.mjs";`,
+    `//   const api = buildApi((name, args) => client.callTool({ name, arguments: args }));`,
+    `import toolmap from "./toolmap.mjs";`,
+    ``,
+    `export function buildApi(callTool) {`,
+    `  if (typeof callTool !== "function") throw new Error("buildApi requires a callTool(name,args) function");`,
+    `  const api = { call: callTool };`,
+    `  for (const [safeName, toolName] of Object.entries(toolmap)) {`,
+    `    api[safeName] = (args) => callTool(toolName, args || {});`,
+    `  }`,
+    `  return api;`,
+    `}`,
+    ``,
+  ];
+  fs.writeFileSync(path.join(baseOut, "api.mjs"), apiLines.join("\n"), "utf-8");
+
+  return { outDir: baseOut, selectedCount: selected.length, toolmap };
+}

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

@@ -0,0 +1,175 @@
+import { McpStdioTransport } from "./mcp_stdio.mjs";
+import { McpHttpTransport } from "./mcp_http.mjs";
+
+/**
+ * @typedef {{
+ *   type: "stdio",
+ *   command: string,
+ *   args?: string[],
+ *   env?: Record<string,string>,
+ * }} StdioServer
+ *
+ * @typedef {{
+ *   type: "http",
+ *   url: string,
+ *   headers?: Record<string,string>,
+ * }} HttpServer
+ */
+
+/**
+ * Minimal MCP client with lifecycle handling (initialize + notifications/initialized).
+ */
+export class McpClient {
+  /**
+   * @param {{ serverName?: string, entry: any }} cfg
+   */
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.serverName = cfg.serverName || "server";
+    this.entry = cfg.entry;
+    this.transport = null;
+    this.initialized = false;
+    this.negotiatedProtocolVersion = null;
+    this.serverInfo = null;
+    this.serverCapabilities = null;
+  }
+
+  async connect() {
+    if (this.transport) return;
+    const t = this.entry?.type;
+    if (t === "stdio") {
+      this.transport = new McpStdioTransport({
+        command: this.entry.command,
+        args: this.entry.args || [],
+        env: this.entry.env || {},
+      });
+      await this.transport.connect();
+      return;
+    }
+    if (t === "http") {
+      this.transport = new McpHttpTransport({
+        url: this.entry.url,
+        headers: this.entry.headers || {},
+      });
+      return;
+    }
+    throw new Error(`Unsupported MCP server type: ${t}`);
+  }
+
+  /**
+   * Perform MCP lifecycle initialization. Safe to call multiple times.
+   * @param {{ protocolVersion?: string, timeoutMs?: number }} opts
+   */
+  async init(opts = {}) {
+    if (this.initialized) return;
+    await this.connect();
+
+    const requested = opts.protocolVersion || process.env.DM_MCP_PROTOCOL_VERSION || "2025-06-18";
+    const timeoutMs = typeof opts.timeoutMs === "number" ? opts.timeoutMs : 60_000;
+
+    const initializeParams = {
+      protocolVersion: requested,
+      capabilities: {
+        // Keep minimal: we don't need special client features for this skill.
+        roots: { listChanged: false },
+        sampling: {},
+        elicitation: {},
+      },
+      clientInfo: {
+        name: "droid-mode",
+        title: "Droid Mode Skill",
+        version: "0.1.0",
+      },
+    };
+
+    const resp = await this.transport.request("initialize", initializeParams, { timeoutMs });
+    if (resp?.error) {
+      throw new Error(`MCP initialize error: ${resp.error.message || JSON.stringify(resp.error)}`);
+    }
+    const result = resp?.result;
+    this.negotiatedProtocolVersion = result?.protocolVersion || requested;
+    this.serverInfo = result?.serverInfo || null;
+    this.serverCapabilities = result?.capabilities || null;
+
+    // For HTTP transport, spec requires MCP-Protocol-Version header for subsequent requests.
+    if (typeof this.transport.setProtocolVersion === "function") {
+      this.transport.setProtocolVersion(this.negotiatedProtocolVersion);
+    }
+
+    // Required: send notifications/initialized
+    await this.transport.notify("notifications/initialized", undefined);
+
+    this.initialized = true;
+  }
+
+  /**
+   * List tools (supports pagination via cursor).
+   * @param {{ cursor?: string, timeoutMs?: number }} opts
+   */
+  async listTools(opts = {}) {
+    await this.init({ timeoutMs: opts.timeoutMs });
+    const resp = await this.transport.request("tools/list", opts.cursor ? { cursor: opts.cursor } : undefined, {
+      timeoutMs: opts.timeoutMs,
+    });
+    if (resp?.error) throw new Error(`tools/list error: ${resp.error.message || JSON.stringify(resp.error)}`);
+    return resp?.result;
+  }
+
+  /**
+   * Call tool by name with args.
+   * Returns normalized result with convenience fields.
+   * @param {{ name: string, arguments?: any, timeoutMs?: number }} req
+   */
+  async callTool(req) {
+    await this.init({ timeoutMs: req.timeoutMs });
+    const resp = await this.transport.request(
+      "tools/call",
+      { name: req.name, arguments: req.arguments ?? {} },
+      { timeoutMs: req.timeoutMs }
+    );
+    if (resp?.error) throw new Error(`tools/call error: ${resp.error.message || JSON.stringify(resp.error)}`);
+    const result = resp?.result;
+    return normalizeToolCallResult(result);
+  }
+
+  async close() {
+    if (!this.transport) return;
+    if (typeof this.transport.close === "function") await this.transport.close();
+  }
+}
+
+/**
+ * Normalize an MCP tool call result into a stable shape.
+ * MCP results generally contain `content` items; some servers also provide `structuredContent`.
+ * @param {any} result
+ */
+export function normalizeToolCallResult(result) {
+  const out = {
+    raw: result,
+    isError: !!result?.isError,
+    structured: result?.structuredContent ?? null,
+    text: "",
+    content: result?.content ?? [],
+  };
+
+  if (Array.isArray(result?.content)) {
+    const texts = [];
+    for (const c of result.content) {
+      if (!c) continue;
+      if (c.type === "text" && typeof c.text === "string") texts.push(c.text);
+      // Some servers include objects or embedded resources; leave in raw.
+    }
+    out.text = texts.join("\n").trim();
+  }
+
+  // If structured is missing but text looks like JSON, try to parse.
+  if (!out.structured && out.text) {
+    const t = out.text.trim();
+    if ((t.startsWith("{") && t.endsWith("}")) || (t.startsWith("[") && t.endsWith("]"))) {
+      try {
+        out.structured = JSON.parse(t);
+      } catch {}
+    }
+  }
+  return out;
+}

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

@@ -0,0 +1,132 @@
+import { setTimeout as delay } from "node:timers/promises";
+
+/**
+ * Minimal HTTP transport for MCP servers.
+ * This implementation prefers plain JSON POST responses, but can also parse simple SSE responses.
+ */
+export class McpHttpTransport {
+  /**
+   * @param {{ url: string, headers?: Record<string,string> }} cfg
+   */
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.nextId = 1;
+    this.protocolVersion = null;
+    this.sessionId = null;
+  }
+
+  /** @param {string|null} v */
+  setProtocolVersion(v) {
+    this.protocolVersion = v;
+  }
+
+  async request(method, params, opts = {}) {
+    const id = this.nextId++;
+    const msg = { jsonrpc: "2.0", id, method, params };
+    const timeoutMs = typeof opts.timeoutMs === "number" ? opts.timeoutMs : 60_000;
+
+    const controller = new AbortController();
+    const t = setTimeout(() => controller.abort(), timeoutMs);
+
+    try {
+      const headers = {
+        Accept: "application/json, text/event-stream",
+        "Content-Type": "application/json",
+        ...(this.cfg.headers || {}),
+      };
+      if (this.protocolVersion) headers["MCP-Protocol-Version"] = this.protocolVersion;
+      if (this.sessionId) headers["Mcp-Session-Id"] = this.sessionId;
+
+      const res = await fetch(this.cfg.url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(msg),
+        signal: controller.signal,
+      });
+
+      // Capture session id if provided
+      const sid =
+        res.headers.get("mcp-session-id") ||
+        res.headers.get("Mcp-Session-Id") ||
+        res.headers.get("MCP-Session-Id");
+      if (sid) this.sessionId = sid;
+
+      const ct = (res.headers.get("content-type") || "").toLowerCase();
+      if (ct.includes("application/json")) {
+        const json = await res.json();
+        return json;
+      }
+
+      if (ct.includes("text/event-stream")) {
+        const msg = await this._readSseForId(res, id, timeoutMs);
+        return msg;
+      }
+
+      // Fallback: try text → json
+      const txt = await res.text();
+      try {
+        return JSON.parse(txt);
+      } catch {
+        throw new Error(`Unexpected MCP HTTP response content-type=${ct}. Body:\n${txt.slice(0, 5000)}`);
+      }
+    } finally {
+      clearTimeout(t);
+    }
+  }
+
+  async notify(method, params) {
+    const msg = { jsonrpc: "2.0", method, params };
+    const headers = {
+      Accept: "application/json, text/event-stream",
+      "Content-Type": "application/json",
+      ...(this.cfg.headers || {}),
+    };
+    if (this.protocolVersion) headers["MCP-Protocol-Version"] = this.protocolVersion;
+    if (this.sessionId) headers["Mcp-Session-Id"] = this.sessionId;
+
+    await fetch(this.cfg.url, { method: "POST", headers, body: JSON.stringify(msg) });
+  }
+
+  async _readSseForId(res, id, timeoutMs) {
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder("utf-8");
+    let buf = "";
+    const start = Date.now();
+
+    const tryParseEvent = (eventText) => {
+      // eventText is lines separated by \n
+      const lines = eventText.split("\n");
+      const dataLines = lines.filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim());
+      if (!dataLines.length) return null;
+      const dataStr = dataLines.join("\n");
+      try {
+        const obj = JSON.parse(dataStr);
+        return obj;
+      } catch {
+        return null;
+      }
+    };
+
+    while (true) {
+      if (Date.now() - start > timeoutMs) {
+        throw new Error(`Timeout waiting for SSE response id=${id}`);
+      }
+      const { value, done } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+
+      // SSE events end with a blank line
+      let idx;
+      while ((idx = buf.indexOf("\n\n")) !== -1) {
+        const rawEvent = buf.slice(0, idx);
+        buf = buf.slice(idx + 2);
+        const parsed = tryParseEvent(rawEvent);
+        if (parsed && Object.prototype.hasOwnProperty.call(parsed, "id") && parsed.id === id) {
+          return parsed;
+        }
+      }
+    }
+
+    throw new Error(`SSE stream ended before receiving response id=${id}`);
+  }
+}

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

@@ -0,0 +1,152 @@
+import { spawn } from "node:child_process";
+import readline from "node:readline";
+
+/**
+ * Minimal JSON-RPC stdio transport for MCP servers.
+ * Assumes line-delimited JSON messages on stdout.
+ */
+export class McpStdioTransport {
+  /**
+   * @param {{ command: string, args?: string[], env?: Record<string,string>, cwd?: string }} cfg
+   */
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.proc = null;
+    this.rl = null;
+    this.nextId = 1;
+    /** @type {Map<string|number, {resolve: Function, reject: Function, timeout: any}>} */
+    this.pending = new Map();
+    /** @type {any[]} */
+    this.notifications = [];
+  }
+
+  async connect() {
+    if (this.proc) return;
+    const { command, args = [], env = {}, cwd } = this.cfg;
+    const mergedEnv = { ...process.env };
+    for (const [k, v] of Object.entries(env || {})) mergedEnv[k] = String(v);
+
+    this.proc = spawn(command, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: mergedEnv,
+      cwd: cwd || process.cwd(),
+    });
+
+    this.proc.on("exit", (code, signal) => {
+      // Reject any pending requests
+      for (const [id, p] of this.pending.entries()) {
+        clearTimeout(p.timeout);
+        p.reject(new Error(`MCP stdio server exited (${signal || code}) while waiting for response id=${id}`));
+      }
+      this.pending.clear();
+    });
+
+    this.proc.stderr.on("data", (buf) => {
+      // Avoid noisy output; keep it available for debugging.
+      // You can enable by setting DM_DEBUG=1.
+      if (process.env.DM_DEBUG === "1") {
+        process.stderr.write(String(buf));
+      }
+    });
+
+    this.rl = readline.createInterface({ input: this.proc.stdout });
+
+    this.rl.on("line", (line) => {
+      if (!line) return;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch (err) {
+        if (process.env.DM_DEBUG === "1") {
+          process.stderr.write(`[dm] Failed to parse JSON from server: ${line}\n`);
+        }
+        return;
+      }
+      if (Object.prototype.hasOwnProperty.call(msg, "id")) {
+        const id = msg.id;
+        const pending = this.pending.get(id);
+        if (!pending) return;
+        clearTimeout(pending.timeout);
+        this.pending.delete(id);
+        pending.resolve(msg);
+      } else {
+        this.notifications.push(msg);
+      }
+    });
+  }
+
+  /**
+   * Send a JSON-RPC request and await its response.
+   * @param {string} method
+   * @param {any} params
+   * @param {{ timeoutMs?: number }} opts
+   */
+  async request(method, params, opts = {}) {
+    await this.connect();
+    const id = this.nextId++;
+    const msg = { jsonrpc: "2.0", id, method, params };
+    const timeoutMs = typeof opts.timeoutMs === "number" ? opts.timeoutMs : 60_000;
+
+    const p = new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`Timeout waiting for MCP stdio response (method=${method}, id=${id})`));
+      }, timeoutMs);
+      this.pending.set(id, { resolve, reject, timeout });
+    });
+
+    this.proc.stdin.write(JSON.stringify(msg) + "\n");
+    const resp = await p;
+    return resp;
+  }
+
+  /**
+   * Send a JSON-RPC notification (no response expected).
+   * @param {string} method
+   * @param {any} params
+   */
+  async notify(method, params) {
+    await this.connect();
+    const msg = { jsonrpc: "2.0", method, params };
+    this.proc.stdin.write(JSON.stringify(msg) + "\n");
+  }
+
+  async close() {
+    if (!this.proc) return;
+
+    // Close readline interface first
+    if (this.rl) {
+      try {
+        this.rl.close();
+      } catch {}
+      this.rl = null;
+    }
+
+    // Close stdin
+    try {
+      this.proc.stdin.end();
+    } catch {}
+
+    // Give server time to exit gracefully
+    await new Promise((r) => setTimeout(r, 500));
+
+    // If still running, terminate
+    if (this.proc && !this.proc.killed) {
+      try {
+        this.proc.kill("SIGTERM");
+      } catch {}
+
+      // Wait briefly for SIGTERM
+      await new Promise((r) => setTimeout(r, 300));
+
+      // Force kill if still running
+      if (this.proc && !this.proc.killed) {
+        try {
+          this.proc.kill("SIGKILL");
+        } catch {}
+      }
+    }
+
+    this.proc = null;
+  }
+}