drops-mcp 0.1.0

package/install.mjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+/**
+ * drops-install — wire the drops MCP server (and `drop` CLI) into your agents.
+ *
+ * Open-source, self-hosted counterpart to a one-command installer: detects the agent
+ * CLIs you have and registers the `drops` MCP server, symlinks `drop` onto your PATH,
+ * and prints copy-paste config for GUI MCP clients.
+ *
+ *   node skill/install.mjs            # register into detected agents
+ *   node skill/install.mjs --print    # just print config, change nothing
+ *
+ * Run `drop setup` (or `drop init` + `drop setup`) afterwards to provision the Blob token.
+ */
+
+import { spawnSync } from "node:child_process";
+import { existsSync, symlinkSync, mkdirSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const MCP = join(__dirname, "mcp.mjs");
+const DROP = join(__dirname, "drop.mjs");
+const PRINT = process.argv.includes("--print");
+
+// When installed from npm, wire agents to the published runner (survives upgrades);
+// from a local clone, point at the local mcp.mjs.
+const PUBLISHED = __dirname.includes(`${require_sep()}node_modules${require_sep()}`);
+function require_sep() { return process.platform === "win32" ? "\\" : "/"; }
+const MCP_CMD = PUBLISHED ? ["npx", "-y", "drops-mcp"] : [process.execPath, MCP];
+
+const ok = (m) => console.log(`\x1b[32m✓\x1b[0m ${m}`);
+const dim = (m) => console.log(`\x1b[2m${m}\x1b[0m`);
+const has = (cmd) => spawnSync(process.platform === "win32" ? "where" : "which", [cmd], { stdio: "ignore", shell: process.platform === "win32" }).status === 0;
+
+// CLI agents that support `<cli> mcp add <name> -- <command>`.
+const CLI_AGENTS = ["claude", "codex", "opencode", "amp"];
+
+console.log("drops-install — wiring the drops MCP into your agents\n");
+
+let wired = 0;
+for (const cli of CLI_AGENTS) {
+  if (!has(cli)) continue;
+  const args = ["mcp", "add", "drops", "--", ...MCP_CMD];
+  if (PRINT) { dim(`${cli} ${args.join(" ")}`); wired++; continue; }
+  const r = spawnSync(cli, args, { stdio: "inherit", shell: process.platform === "win32" });
+  if (r.status === 0) { ok(`registered drops MCP in ${cli}`); wired++; }
+  else dim(`skipped ${cli} (add failed — may already exist)`);
+}
+if (!wired) dim("no CLI agents detected (claude / codex / opencode / amp)");
+
+// Symlink `drop` onto PATH for shell/agent use.
+const bin = join(homedir(), ".local", "bin");
+const link = join(bin, "drop");
+if (PRINT) {
+  dim(`ln -s ${DROP} ${link}`);
+} else {
+  try {
+    mkdirSync(bin, { recursive: true });
+    if (existsSync(link)) rmSync(link);
+    symlinkSync(DROP, link);
+    ok(`linked 'drop' → ${link}  (ensure ${bin} is on your PATH)`);
+  } catch (e) { dim(`could not symlink drop: ${e.message}`); }
+}
+
+// Copy-paste config for GUI MCP clients (Cursor / Claude Desktop / Windsurf / Zed).
+console.log("\nFor GUI MCP clients, add this to your MCP config:\n");
+console.log(JSON.stringify({ mcpServers: { drops: { command: MCP_CMD[0], args: MCP_CMD.slice(1) } } }, null, 2));
+
+console.log("\nNext:  drop init --domain ...   (BYO domain/Blob)   then   drop setup --token vercel_blob_rw_...");

package/mcp.mjs

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+/**
+ * drops MCP server — the MCP-native publish primitive for HTML/artifacts your agents make.
+ *
+ * Open-source, self-hosted counterpart to Stacktree's MCP: an agent calls `publish_html`
+ * and gets back a branded, password-protected, zero-knowledge link on YOUR own domain.
+ * Every tool shells out to the battle-tested `drop` CLI (drop.mjs --json) so the MCP and
+ * CLI share one pipeline. Nothing is hosted by a third party — it's your Vercel Blob.
+ *
+ * Wire it into an agent (stdio):
+ *   claude mcp add drops -- npx -y --prefix <repo>/skill drops-mcp     # once published
+ *   # or, from a clone:
+ *   claude mcp add drops -- node <repo>/skill/mcp.mjs
+ *
+ * Requires `drop setup` to have run (BLOB_READ_WRITE_TOKEN in ~/.drop/.env).
+ */
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { spawn } from "node:child_process";
+import { writeFile, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DROP = join(__dirname, "drop.mjs");
+
+// Run the drop CLI with --json and return the parsed result.
+function runDrop(args) {
+  return new Promise((resolve, reject) => {
+    const p = spawn(process.execPath, [DROP, ...args, "--json"], { stdio: ["ignore", "pipe", "pipe"] });
+    let out = "", err = "";
+    p.stdout.on("data", (d) => (out += d));
+    p.stderr.on("data", (d) => (err += d));
+    p.on("error", reject);
+    p.on("close", (code) => {
+      if (code !== 0) return reject(new Error(err.trim() || `drop exited ${code}`));
+      const line = out.trim().split("\n").filter(Boolean).pop() || "{}";
+      try { resolve(JSON.parse(line)); } catch { resolve({ raw: out.trim() }); }
+    });
+  });
+}
+
+async function withTempFile(name, content, fn) {
+  const dir = await mkdtemp(join(tmpdir(), "drops-mcp-"));
+  const path = join(dir, name);
+  await writeFile(path, content);
+  try { return await fn(path); }
+  finally { await rm(dir, { recursive: true, force: true }); }
+}
+
+const textResult = (obj) => ({ content: [{ type: "text", text: JSON.stringify(obj, null, 2) }] });
+const errResult = (e) => ({ isError: true, content: [{ type: "text", text: `Error: ${e.message || e}` }] });
+
+const server = new McpServer({ name: "drops", version: "1.0.0" });
+
+server.tool(
+  "publish_html",
+  "Publish raw HTML as a branded, password-protected (zero-knowledge AES-256) link on your own domain. Returns the URL and (if locked) the password. Locked by default.",
+  {
+    html: z.string().describe("The full HTML document to publish."),
+    slug: z.string().optional().describe("Force the URL slug (e.g. 'q3-report'). Otherwise auto-generated."),
+    password: z.string().optional().describe("Set a specific password. Otherwise an unguessable one is generated when locked."),
+    lock: z.boolean().optional().describe("Encrypt + password-protect (default true). Set false for a public branded page."),
+    expire: z.string().optional().describe("Auto-expire after this long: '7d', '24h', '2w', or a date. Enforce deletion with the host's `drop gc` cron."),
+  },
+  async ({ html, slug, password, lock, expire }) => {
+    try {
+      const args = [];
+      if (slug) args.push("-s", slug);
+      if (lock === false) args.push("--no-lock");
+      else if (password) args.push("-p", password);
+      if (expire) args.push("--expire", expire);
+      const res = await withTempFile((slug || "page") + ".html", html, (p) => runDrop([p, ...args]));
+      return textResult(res);
+    } catch (e) { return errResult(e); }
+  }
+);
+
+server.tool(
+  "publish_file",
+  "Publish a file from a local path. Non-HTML files get an unguessable URL; pass page=true to wrap any file in a branded download page (optionally password-protected).",
+  {
+    path: z.string().describe("Absolute path to the local file to publish."),
+    slug: z.string().optional(),
+    page: z.boolean().optional().describe("Wrap the file in a branded download page."),
+    password: z.string().optional().describe("Password-protect the download page (requires page=true)."),
+  },
+  async ({ path, slug, page, password }) => {
+    try {
+      const args = [path];
+      if (slug) args.push("-s", slug);
+      if (page) args.push("--page");
+      if (password) args.push("-p", password);
+      return textResult(await runDrop(args));
+    } catch (e) { return errResult(e); }
+  }
+);
+
+server.tool(
+  "update_site",
+  "Replace the content of an existing drop in place — same URL/slug, new HTML. (Set a password to re-lock; zero-knowledge means content can't be re-keyed without re-supplying it.)",
+  {
+    slug: z.string().describe("The slug to overwrite."),
+    html: z.string().describe("The new HTML document."),
+    password: z.string().optional(),
+    lock: z.boolean().optional(),
+    expire: z.string().optional().describe("Auto-expire: '7d', '24h', '2w', or a date."),
+  },
+  async ({ slug, html, password, lock, expire }) => {
+    try {
+      const args = ["-s", slug];
+      if (lock === false) args.push("--no-lock");
+      else if (password) args.push("-p", password);
+      if (expire) args.push("--expire", expire);
+      const res = await withTempFile(slug + ".html", html, (p) => runDrop([p, ...args]));
+      return textResult(res);
+    } catch (e) { return errResult(e); }
+  }
+);
+
+server.tool(
+  "list_sites",
+  "List the drops currently live in your store (slug, URL, size, password if known locally, upload date).",
+  {},
+  async () => {
+    try { return textResult(await runDrop(["list"])); }
+    catch (e) { return errResult(e); }
+  }
+);
+
+server.tool(
+  "delete_site",
+  "Delete a drop (and any sibling file) by slug. Burns the artifact immediately.",
+  { slug: z.string().describe("The slug to delete.") },
+  async ({ slug }) => {
+    try { return textResult(await runDrop(["rm", slug])); }
+    catch (e) { return errResult(e); }
+  }
+);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "drops-mcp",
+  "version": "0.1.0",
+  "description": "Open-source artifact sharing — publish HTML/Markdown/files as branded, password-protected, zero-knowledge links on your own domain, from any AI agent. CLI + MCP server. The open-source, self-hosted Stacktree alternative.",
+  "type": "module",
+  "bin": {
+    "drop": "./drop.mjs",
+    "drops-mcp": "./mcp.mjs",
+    "drops-install": "./install.mjs"
+  },
+  "files": [
+    "drop.mjs",
+    "mcp.mjs",
+    "install.mjs",
+    "brand/",
+    "SKILL.md",
+    "SETUP.md"
+  ],
+  "keywords": [
+    "mcp", "ai-agents", "claude", "claude-code", "artifacts", "file-sharing",
+    "zero-knowledge", "cli", "self-hosted", "staticrypt", "vercel-blob",
+    "password-protection", "stacktree-alternative", "publish-html"
+  ],
+  "repository": { "type": "git", "url": "https://github.com/maxtechera/drops-share" },
+  "homepage": "https://drops.maxtechera.dev",
+  "bugs": "https://github.com/maxtechera/drops-share/issues",
+  "author": "Max Techera (https://maxtechera.dev)",
+  "license": "MIT",
+  "engines": { "node": ">=18" },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@vercel/blob": "^0.27.0",
+    "adm-zip": "^0.5.17",
+    "marked": "^18.0.5",
+    "zod": "^3.23.0"
+  }
+}