htmlship 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 HTMLShip
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,47 @@
+# htmlship
+
+CLI + MCP server for [HTMLShip](https://htmlship.com) — host and share HTML pages from LLMs and coding agents in one line.
+
+```bash
+# Publish an HTML file
+npx htmlship publish report.html
+
+# Pipe from stdin
+cat report.html | npx htmlship publish -
+
+# Inspect / update / delete using the saved owner key
+npx htmlship get <slug>
+npx htmlship update <slug> updated.html
+npx htmlship delete <slug>
+npx htmlship list-mine
+```
+
+## MCP server
+
+`htmlship mcp` starts a stdio MCP server with three tools: `publish_html`, `fetch_html`, `update_html`.
+
+### Claude Desktop / Claude Code / Cursor
+
+```json
+{
+  "mcpServers": {
+    "htmlship": {
+      "command": "npx",
+      "args": ["-y", "htmlship", "mcp"]
+    }
+  }
+}
+```
+
+That's the whole install. Restart your MCP client and ask the agent to publish HTML.
+
+## Configuration
+
+- `HTMLSHIP_API_URL` — API base URL (default `https://api.htmlship.com`)
+- `HTMLSHIP_KEYS_DIR` — directory for the owner-key store (default `~/.htmlship`)
+
+The owner-key store at `~/.htmlship/keys.json` is **format-compatible** with the [Python CLI](https://pypi.org/project/htmlship/). You can publish from one and update/delete from the other.
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,635 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/errors.ts
+var HTMLShipError, NotFoundError, AuthError, RateLimitError, APIError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    HTMLShipError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "HTMLShipError";
+      }
+    };
+    NotFoundError = class extends HTMLShipError {
+      constructor(message = "not found") {
+        super(message);
+        this.name = "NotFoundError";
+      }
+    };
+    AuthError = class extends HTMLShipError {
+      constructor(message = "unauthorized") {
+        super(message);
+        this.name = "AuthError";
+      }
+    };
+    RateLimitError = class extends HTMLShipError {
+      retryAfter;
+      constructor(message, retryAfter = null) {
+        super(message);
+        this.name = "RateLimitError";
+        this.retryAfter = retryAfter;
+      }
+    };
+    APIError = class extends HTMLShipError {
+      statusCode;
+      constructor(message, statusCode = null) {
+        super(message);
+        this.name = "APIError";
+        this.statusCode = statusCode;
+      }
+    };
+  }
+});
+
+// src/version.ts
+var VERSION;
+var init_version = __esm({
+  "src/version.ts"() {
+    "use strict";
+    VERSION = "0.1.1";
+  }
+});
+
+// src/client.ts
+var DEFAULT_API_URL, HTMLShipClient;
+var init_client = __esm({
+  "src/client.ts"() {
+    "use strict";
+    init_errors();
+    init_version();
+    DEFAULT_API_URL = "https://api.htmlship.com";
+    HTMLShipClient = class {
+      baseUrl;
+      apiKey;
+      timeoutMs;
+      fetchImpl;
+      constructor(options = {}) {
+        const envUrl = process.env["HTMLSHIP_API_URL"];
+        const envKey = process.env["HTMLSHIP_API_KEY"];
+        this.baseUrl = (options.baseUrl ?? envUrl ?? DEFAULT_API_URL).replace(/\/+$/, "");
+        this.apiKey = options.apiKey ?? envKey ?? null;
+        this.timeoutMs = options.timeoutMs ?? 3e4;
+        this.fetchImpl = options.fetchImpl ?? globalThis.fetch.bind(globalThis);
+      }
+      async publish(html, options = {}) {
+        const body = {
+          html,
+          sandbox_mode: options.sandboxMode ?? "strict"
+        };
+        if (options.title != null) body["title"] = options.title;
+        if (options.password != null) body["password"] = options.password;
+        if (options.expiresIn != null) body["expires_in"] = options.expiresIn;
+        if (options.parentSlug != null) body["parent_slug"] = options.parentSlug;
+        return await this.request("POST", "/api/v1/pastes", { body });
+      }
+      async get(slug) {
+        return await this.request("GET", `/api/v1/pastes/${encodeURIComponent(slug)}`);
+      }
+      async update(slug, html, ownerKey, options = {}) {
+        const body = { html };
+        if (options.title != null) body["title"] = options.title;
+        return await this.request(
+          "PATCH",
+          `/api/v1/pastes/${encodeURIComponent(slug)}`,
+          { body, headers: { "X-Owner-Key": ownerKey } }
+        );
+      }
+      async delete(slug, ownerKey) {
+        await this.request(
+          "DELETE",
+          `/api/v1/pastes/${encodeURIComponent(slug)}`,
+          { headers: { "X-Owner-Key": ownerKey }, expectNoBody: true }
+        );
+      }
+      async createVersion(parentSlug, html, options = {}) {
+        const body = {
+          html,
+          sandbox_mode: options.sandboxMode ?? "strict"
+        };
+        if (options.title != null) body["title"] = options.title;
+        if (options.password != null) body["password"] = options.password;
+        if (options.expiresIn != null) body["expires_in"] = options.expiresIn;
+        return await this.request(
+          "POST",
+          `/api/v1/pastes/${encodeURIComponent(parentSlug)}/version`,
+          { body }
+        );
+      }
+      // --- private ------------------------------------------------------------
+      async request(method, path, options = {}) {
+        const headers = {
+          "User-Agent": `htmlship-node/${VERSION}`,
+          ...options.headers ?? {}
+        };
+        if (this.apiKey) headers["Authorization"] = `Bearer ${this.apiKey}`;
+        if (options.body !== void 0) headers["Content-Type"] = "application/json";
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        let response;
+        try {
+          response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+            method,
+            headers,
+            body: options.body !== void 0 ? JSON.stringify(options.body) : void 0,
+            signal: controller.signal
+          });
+        } catch (err) {
+          clearTimeout(timer);
+          if (err instanceof Error && err.name === "AbortError") {
+            throw new HTMLShipError(`request timed out after ${this.timeoutMs}ms`);
+          }
+          throw new HTMLShipError(`network error: ${err.message}`);
+        }
+        clearTimeout(timer);
+        if (response.ok) {
+          if (options.expectNoBody) return void 0;
+          const text = await response.text();
+          if (!text) return void 0;
+          return JSON.parse(text);
+        }
+        const detail = await this.extractErrorDetail(response);
+        if (response.status === 404) throw new NotFoundError(detail);
+        if (response.status === 401 || response.status === 403) throw new AuthError(detail);
+        if (response.status === 429) {
+          const retryHeader = response.headers.get("Retry-After");
+          const retryAfter = retryHeader ? Number.parseFloat(retryHeader) : null;
+          throw new RateLimitError(detail, Number.isFinite(retryAfter) ? retryAfter : null);
+        }
+        throw new APIError(detail, response.status);
+      }
+      async extractErrorDetail(response) {
+        try {
+          const text = await response.text();
+          if (!text) return `HTTP ${response.status}`;
+          try {
+            const data = JSON.parse(text);
+            if (data && typeof data === "object" && "detail" in data) {
+              return String(data.detail);
+            }
+            return text;
+          } catch {
+            return text;
+          }
+        } catch {
+          return `HTTP ${response.status}`;
+        }
+      }
+    };
+  }
+});
+
+// src/mcp/server.ts
+var server_exports = {};
+__export(server_exports, {
+  buildMcpServer: () => buildMcpServer,
+  startMcpServer: () => startMcpServer
+});
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+function buildMcpServer(client) {
+  const c = client ?? new HTMLShipClient();
+  const server = new McpServer({ name: "htmlship", version: VERSION });
+  server.registerTool(
+    "publish_html",
+    {
+      description: "Publish an HTML document and get a public URL. The owner_key returned is the only credential to update or delete this paste later \u2014 save it.",
+      inputSchema: {
+        html: z.string().describe("The HTML body to publish."),
+        title: z.string().optional().describe("Optional human-readable title."),
+        expires_in_seconds: z.number().int().positive().optional().describe("Optional TTL in seconds.")
+      }
+    },
+    async ({ html, title, expires_in_seconds }) => {
+      try {
+        const paste = await c.publish(html, {
+          title: title ?? null,
+          expiresIn: expires_in_seconds ?? null
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  url: paste.url,
+                  slug: paste.slug,
+                  owner_key: paste.owner_key,
+                  expires_at: paste.expires_at
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        return errorResult("publish_html", err);
+      }
+    }
+  );
+  server.registerTool(
+    "fetch_html",
+    {
+      description: "Fetch a paste's metadata. To view the rendered HTML, open the `url` in a browser \u2014 the content is served from a sandboxed subdomain.",
+      inputSchema: {
+        slug: z.string().describe("The paste's short identifier.")
+      }
+    },
+    async ({ slug }) => {
+      try {
+        const paste = await c.get(slug);
+        return {
+          content: [{ type: "text", text: JSON.stringify(paste, null, 2) }]
+        };
+      } catch (err) {
+        if (err instanceof NotFoundError) {
+          return errorResult("fetch_html", new HTMLShipError(`paste '${slug}' not found`));
+        }
+        return errorResult("fetch_html", err);
+      }
+    }
+  );
+  server.registerTool(
+    "update_html",
+    {
+      description: "Replace the HTML for an existing paste. Requires the original owner_key.",
+      inputSchema: {
+        slug: z.string().describe("The paste's short identifier."),
+        html: z.string().describe("The new HTML body."),
+        owner_key: z.string().describe("The owner key returned at publish time."),
+        title: z.string().optional().describe("Optional new title.")
+      }
+    },
+    async ({ slug, html, owner_key, title }) => {
+      try {
+        const paste = await c.update(slug, html, owner_key, { title: title ?? null });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                { url: paste.url, slug: paste.slug, updated_at: paste.updated_at },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        if (err instanceof AuthError) {
+          return errorResult("update_html", new HTMLShipError(`invalid owner_key for '${slug}'`));
+        }
+        return errorResult("update_html", err);
+      }
+    }
+  );
+  return server;
+}
+function errorResult(tool, err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return {
+    isError: true,
+    content: [{ type: "text", text: `htmlship ${tool} failed: ${message}` }]
+  };
+}
+async function startMcpServer() {
+  const server = buildMcpServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+var init_server = __esm({
+  "src/mcp/server.ts"() {
+    "use strict";
+    init_client();
+    init_errors();
+    init_version();
+  }
+});
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/delete.ts
+init_client();
+init_errors();
+import { createInterface } from "readline/promises";
+
+// src/keystore.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function createKeyStore(overrideDir) {
+  const dir = overrideDir ?? process.env["HTMLSHIP_KEYS_DIR"] ?? join(homedir(), ".htmlship");
+  const file = join(dir, "keys.json");
+  function load() {
+    if (!existsSync(file)) return {};
+    try {
+      const text = readFileSync(file, "utf8");
+      const parsed = JSON.parse(text);
+      if (parsed && typeof parsed === "object") return parsed;
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  function save(data) {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const sorted = {};
+    for (const key of Object.keys(data).sort()) {
+      sorted[key] = data[key];
+    }
+    writeFileSync(file, JSON.stringify(sorted, null, 2), "utf8");
+    try {
+      chmodSync(file, 384);
+    } catch {
+    }
+  }
+  return {
+    dir,
+    file,
+    load,
+    save,
+    remember(slug, entry) {
+      const data = load();
+      data[slug] = {
+        owner_key: entry.owner_key,
+        url: entry.url,
+        title: entry.title,
+        saved_at: entry.saved_at ?? (/* @__PURE__ */ new Date()).toISOString()
+      };
+      save(data);
+    },
+    forget(slug) {
+      const data = load();
+      if (slug in data) {
+        delete data[slug];
+        save(data);
+      }
+    },
+    lookupOwnerKey(slug) {
+      const entry = load()[slug];
+      return entry ? entry.owner_key : null;
+    }
+  };
+}
+
+// src/commands/delete.ts
+function registerDelete(program) {
+  program.command("delete").description("Soft-delete a paste.").argument("<slug>", "Paste slug").option("--owner-key <key>", "Owner key (defaults to local store)").option("-y, --yes", "Skip confirmation").action(async function(slug, opts) {
+    const keys = createKeyStore();
+    const ownerKey = opts.ownerKey ?? keys.lookupOwnerKey(slug);
+    if (!ownerKey) {
+      throw new HTMLShipError(
+        `no owner key for '${slug}' in ${keys.file}; pass --owner-key explicitly`
+      );
+    }
+    if (!opts.yes) {
+      const rl = createInterface({ input: process.stdin, output: process.stderr });
+      const answer = await rl.question(`Delete paste '${slug}'? [y/N] `);
+      rl.close();
+      if (!/^y(es)?$/i.test(answer.trim())) {
+        process.stderr.write("Aborted.\n");
+        return;
+      }
+    }
+    const apiUrl = this.parent?.opts()?.apiUrl;
+    const client = new HTMLShipClient({ baseUrl: apiUrl });
+    await client.delete(slug, ownerKey);
+    keys.forget(slug);
+    process.stdout.write(`deleted ${slug}
+`);
+  });
+}
+
+// src/commands/get.ts
+init_client();
+init_errors();
+function registerGet(program) {
+  program.command("get").description("Show metadata for a paste.").argument("<slug>", "Paste slug").action(async function(slug) {
+    const apiUrl = this.parent?.opts()?.apiUrl;
+    const client = new HTMLShipClient({ baseUrl: apiUrl });
+    try {
+      const paste = await client.get(slug);
+      process.stdout.write(`${JSON.stringify(paste, null, 2)}
+`);
+    } catch (err) {
+      if (err instanceof NotFoundError) {
+        throw new HTMLShipError(`paste '${slug}' not found`);
+      }
+      throw err;
+    }
+  });
+}
+
+// src/commands/list-mine.ts
+init_client();
+init_errors();
+function registerListMine(program) {
+  program.command("list-mine").description("List pastes whose owner keys are saved locally.").option("--limit <n>", "max entries to show", "20").action(async function(opts) {
+    const keys = createKeyStore();
+    const data = keys.load();
+    const entries = Object.entries(data);
+    if (entries.length === 0) {
+      process.stdout.write(`No saved pastes in ${keys.file}.
+`);
+      return;
+    }
+    const limit = Number.parseInt(opts.limit ?? "20", 10);
+    const sorted = entries.sort((a, b) => (b[1].saved_at ?? "").localeCompare(a[1].saved_at ?? "")).slice(0, Number.isFinite(limit) ? limit : 20);
+    const apiUrl = this.parent?.opts()?.apiUrl;
+    const client = new HTMLShipClient({ baseUrl: apiUrl });
+    const rows = await Promise.all(
+      sorted.map(async ([slug, info]) => {
+        try {
+          const paste = await client.get(slug);
+          return {
+            slug,
+            url: info.url,
+            title: paste.title ?? info.title ?? "",
+            size: `${paste.size_bytes}B`,
+            views: String(paste.view_count),
+            status: "ok"
+          };
+        } catch (err) {
+          return {
+            slug,
+            url: info.url,
+            title: info.title ?? "",
+            size: "\u2014",
+            views: "\u2014",
+            status: err instanceof NotFoundError ? "gone" : "err"
+          };
+        }
+      })
+    );
+    const width = Math.max(...rows.map((r) => r.slug.length), 8);
+    for (const r of rows) {
+      const slug = r.slug.padEnd(width);
+      const status = r.status.padEnd(5);
+      const views = r.views.padStart(5);
+      const size = r.size.padStart(8);
+      process.stdout.write(`${slug}  ${status}  ${views} views  ${size}  ${r.title}
+`);
+      process.stdout.write(`  ${r.url}
+`);
+    }
+  });
+}
+
+// src/commands/publish.ts
+init_client();
+init_errors();
+
+// src/io.ts
+import { readFileSync as readFileSync2 } from "fs";
+function readHtmlFromSource(source, fileFlag) {
+  if (fileFlag) {
+    return readFileSync2(fileFlag, "utf8");
+  }
+  if (source === "-" || source === void 0) {
+    if (source === void 0 && process.stdin.isTTY) {
+      throw new CliUsageError("Provide a file path or pipe HTML on stdin.");
+    }
+    return readStdinSync();
+  }
+  return readFileSync2(source, "utf8");
+}
+var CliUsageError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CliUsageError";
+  }
+};
+function readStdinSync() {
+  try {
+    return readFileSync2(0, "utf8");
+  } catch (err) {
+    throw new CliUsageError(`failed to read stdin: ${err.message}`);
+  }
+}
+async function tryClipboardCopy(text) {
+  try {
+    const mod = await import("clipboardy");
+    await mod.default.write(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/publish.ts
+function registerPublish(program) {
+  program.command("publish").description("Publish an HTML document and get a URL.").argument("[source]", "file path, '-' for stdin (default: stdin if piped)").option("-f, --file <path>", "HTML file path").option("--title <title>", "Optional title").option("--password <password>", "Password-protect the paste").option("--expires-in <seconds>", "Seconds until expiry").option("--no-clipboard", "Don't copy URL to clipboard").option("-q, --quiet", "Print only the URL").action(async function(source, opts) {
+    const html = readHtmlFromSource(source, opts.file);
+    const apiUrl = this.parent?.opts()?.apiUrl;
+    const client = new HTMLShipClient({ baseUrl: apiUrl });
+    let paste;
+    try {
+      paste = await client.publish(html, {
+        title: opts.title ?? null,
+        password: opts.password ?? null,
+        expiresIn: opts.expiresIn ? Number.parseInt(opts.expiresIn, 10) : null
+      });
+    } catch (err) {
+      throw new HTMLShipError(`publish failed: ${err.message}`);
+    }
+    const keys = createKeyStore();
+    keys.remember(paste.slug, {
+      owner_key: paste.owner_key,
+      url: paste.url,
+      title: opts.title ?? null
+    });
+    if (opts.quiet) {
+      process.stdout.write(`${paste.url}
+`);
+      return;
+    }
+    process.stdout.write(`${paste.url}
+`);
+    process.stderr.write(`slug:      ${paste.slug}
+`);
+    process.stderr.write(`owner_key: ${paste.owner_key}  (saved to ${keys.file})
+`);
+    if (paste.expires_at) {
+      process.stderr.write(`expires:   ${paste.expires_at}
+`);
+    }
+    if (opts.noClipboard !== true) {
+      const copied = await tryClipboardCopy(paste.url);
+      if (copied) process.stderr.write("(URL copied to clipboard)\n");
+    }
+  });
+}
+
+// src/commands/update.ts
+init_client();
+init_errors();
+function registerUpdate(program) {
+  program.command("update").description("Replace HTML for an existing paste.").argument("<slug>", "Paste slug").argument("[source]", "file path, '-' for stdin").option("-f, --file <path>", "HTML file path").option("--title <title>", "Optional new title").option("--owner-key <key>", "Owner key (defaults to local store)").action(async function(slug, source, opts) {
+    const html = readHtmlFromSource(source, opts.file);
+    const keys = createKeyStore();
+    const ownerKey = opts.ownerKey ?? keys.lookupOwnerKey(slug);
+    if (!ownerKey) {
+      throw new HTMLShipError(
+        `no owner key for '${slug}' in ${keys.file}; pass --owner-key explicitly`
+      );
+    }
+    const apiUrl = this.parent?.opts()?.apiUrl;
+    const client = new HTMLShipClient({ baseUrl: apiUrl });
+    const paste = await client.update(slug, html, ownerKey, { title: opts.title ?? null });
+    process.stdout.write(`${paste.url}
+`);
+  });
+}
+
+// src/cli.ts
+init_errors();
+init_version();
+function buildProgram() {
+  const program = new Command();
+  program.name("htmlship").description("HTMLShip \u2014 host and share HTML in one line.").version(VERSION).option(
+    "--api-url <url>",
+    "API base URL (default: https://api.htmlship.com or $HTMLSHIP_API_URL)"
+  );
+  registerPublish(program);
+  registerGet(program);
+  registerUpdate(program);
+  registerDelete(program);
+  registerListMine(program);
+  program.command("mcp").description("Start an MCP stdio server (for Claude Desktop, Cursor, etc.).").action(async () => {
+    const { startMcpServer: startMcpServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+    await startMcpServer2();
+  });
+  return program;
+}
+async function runCli(argv) {
+  const program = buildProgram();
+  try {
+    await program.parseAsync(argv);
+  } catch (err) {
+    if (err instanceof HTMLShipError || err instanceof CliUsageError) {
+      process.stderr.write(`error: ${err.message}
+`);
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+
+// src/bin.ts
+runCli(process.argv).catch((err) => {
+  process.stderr.write(`error: ${err.message ?? String(err)}
+`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "htmlship",
+  "version": "0.1.1",
+  "description": "Host and share HTML pages from LLMs and coding agents in one line. CLI + MCP server.",
+  "keywords": [
+    "html",
+    "paste",
+    "llm",
+    "agent",
+    "mcp",
+    "hosting",
+    "cli",
+    "claude",
+    "cursor"
+  ],
+  "homepage": "https://htmlship.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/htmlship/htmlship.git",
+    "directory": "npm"
+  },
+  "license": "MIT",
+  "author": "HTMLShip",
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "htmlship": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "clipboardy": "^4.0.0",
+    "commander": "^12.1.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.0"
+  }
+}