@hasna/shortlinks 0.2.0 → 0.2.2

package/dist/mcp/http.d.ts

@@ -1,21 +1,26 @@
 import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { type McpHttpServerHandle } from "@hasna/mcp-harness";
 /**
- * open-shortlinks MCP transport/port boilerplate — thin shim over
- * `@hasna/mcp-harness`. The public API (names, signatures, health shape) is
- * preserved so `mcp/index.ts` is unchanged; only the hand-rolled `node:http` +
- * `StreamableHTTPServerTransport` server, port parsing, and health helpers
- * were removed in favor of the shared harness.
+ * open-shortlinks MCP transport/port boilerplate — self-contained, with NO
+ * external harness dependency. The prior version depended on the unpublished
+ * `@hasna/mcp-harness` (a `file:` link), which made `shortlinks-mcp`
+ * unstartable on a fresh `npm i` / `bun add -g`. This version inlines the tiny
+ * amount of transport glue using only the published `@modelcontextprotocol/sdk`
+ * and Bun's built-in HTTP server, matching the pattern used by the reference
+ * apps (open-conversations, open-mementos).
  *
- * shortlinks builds its MCP server with the low-level `Server` (not the
- * high-level `McpServer`); the harness's Node adapter is typed against
- * `McpServer` but only calls `.connect()`/`.close()` at runtime, both of
- * which `Server` implements identically — the cast below mirrors the same
- * pattern used by open-signatures.
+ * shortlinks builds its MCP server with the low-level `Server`; the WebStandard
+ * transport's `.connect()` works identically on `Server` and the high-level
+ * `McpServer`.
  */
 export declare const MCP_HTTP_SERVICE_NAME = "shortlinks";
+export declare const MCP_HTTP_HOST = "127.0.0.1";
 export declare const DEFAULT_MCP_HTTP_PORT = 8851;
-export type { McpHttpServerHandle };
+export interface McpHttpServerHandle {
+    port: number;
+    host: string;
+    url: string;
+    close(): Promise<void>;
+}
 export declare function isHttpMode(argv?: string[], env?: NodeJS.ProcessEnv): boolean;
 export declare function isStdioMode(argv?: string[], env?: NodeJS.ProcessEnv): boolean;
 export declare function resolveMcpHttpPort(argv?: string[], env?: NodeJS.ProcessEnv): number;

package/dist/mcp/index.js

@@ -38,7 +38,7 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 
-// ../open-contracts/dist/client/storage.js
+// node_modules/.pnpm/@hasna+contracts@0.5.2/node_modules/@hasna/contracts/dist/client/storage.js
 var __defProp2 = Object.defineProperty;
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -6497,6 +6497,13 @@ class CloudShortlinksStore {
     const domains = await this.listDomains();
     return domains.find((d) => d.default_domain) ?? domains[0] ?? null;
   }
+  async deleteDomain(hostnameOrId) {
+    const domain = await this.getDomain(hostnameOrId);
+    if (!domain)
+      throw new Error("Domain not found.");
+    await this.transport.del(`/domains/${enc(domain.hostname)}`);
+    return domain;
+  }
   async createLink(input) {
     return this.client.create("links", {
       url: input.destinationUrl,
@@ -6548,7 +6555,7 @@ class CloudShortlinksStore {
     const link = maybeSlug ? await this.getLink(domainOrSlug, maybeSlug) : await this.getLink(domainOrSlug);
     if (!link)
       throw new Error("Link not found.");
-    await this.client.delete("links", link.slug, maybeSlug ? { query: { domain: domainOrSlug } } : {});
+    await this.transport.del(`/links/${enc(link.slug)}`, undefined, maybeSlug ? { query: { domain: domainOrSlug } } : {});
     return link;
   }
   async recordClick(_link, _input = {}) {
@@ -6967,6 +6974,17 @@ class ShortlinksStore {
     `).get(normalized, hostnameOrId);
     return row ? domainFromRow(row) : null;
   }
+  deleteDomain(hostnameOrId) {
+    const domain = this.getDomain(hostnameOrId);
+    if (!domain)
+      throw new Error("Domain not found.");
+    this.database.db.query("DELETE FROM domains WHERE id = ?").run(domain.id);
+    const config = loadConfig();
+    if (config.defaultDomain && normalizeHostname(config.defaultDomain) === domain.hostname) {
+      updateConfig({ defaultDomain: undefined, publicBaseUrl: undefined });
+    }
+    return domain;
+  }
   getDefaultDomain() {
     const config = loadConfig();
     if (config.defaultDomain) {
@@ -7170,6 +7188,9 @@ class LocalStore {
   async getDefaultDomain() {
     return this.inner.getDefaultDomain();
   }
+  async deleteDomain(hostnameOrId) {
+    return this.inner.deleteDomain(hostnameOrId);
+  }
   async createLink(input) {
     return this.inner.createLink(input);
   }
@@ -7217,27 +7238,67 @@ async function withStore(fn, env = process.env, options = {}) {
 }
 
 // src/mcp/http.ts
-import {
-  isHttpMode as harnessIsHttpMode,
-  isStdioMode as harnessIsStdioMode,
-  resolveMcpHttpPort as harnessResolveMcpHttpPort
-} from "@hasna/mcp-harness";
-import { startMcpHttpServer as harnessStartMcpHttpServer } from "@hasna/mcp-harness/node";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 var MCP_HTTP_SERVICE_NAME = "shortlinks";
+var MCP_HTTP_HOST = "127.0.0.1";
 var DEFAULT_MCP_HTTP_PORT = 8851;
 function isHttpMode(argv = process.argv, env = process.env) {
-  return harnessIsHttpMode(argv, env);
+  return argv.includes("--http") || env.MCP_HTTP === "1";
 }
 function resolveMcpHttpPort(argv = process.argv, env = process.env) {
-  return harnessResolveMcpHttpPort({ argv, env, default: DEFAULT_MCP_HTTP_PORT });
+  const portIdx = argv.indexOf("--port");
+  if (portIdx >= 0 && argv[portIdx + 1]) {
+    const parsed = Number(argv[portIdx + 1]);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  if (env.MCP_HTTP_PORT) {
+    const parsed = Number(env.MCP_HTTP_PORT);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return DEFAULT_MCP_HTTP_PORT;
+}
+function healthPayload(name) {
+  return { status: "ok", name };
+}
+async function handleMcpRequest(req, buildServer) {
+  const transport = new WebStandardStreamableHTTPServerTransport({
+    sessionIdGenerator: undefined
+  });
+  const server = buildServer();
+  await server.connect(transport);
+  return transport.handleRequest(req);
 }
 async function startMcpHttpServer(buildServer, options) {
-  return harnessStartMcpHttpServer(buildServer, {
-    port: options?.port,
-    host: options?.host,
-    serviceName: options?.serviceName ?? MCP_HTTP_SERVICE_NAME,
-    defaultPort: DEFAULT_MCP_HTTP_PORT
+  const port = options?.port ?? DEFAULT_MCP_HTTP_PORT;
+  const host = options?.host ?? MCP_HTTP_HOST;
+  const serviceName = options?.serviceName ?? MCP_HTTP_SERVICE_NAME;
+  const server = Bun.serve({
+    hostname: host,
+    port,
+    async fetch(req) {
+      const url = new URL(req.url);
+      if (url.pathname === "/health" && req.method === "GET") {
+        return Response.json(healthPayload(serviceName));
+      }
+      if (url.pathname === "/mcp") {
+        return handleMcpRequest(req, buildServer);
+      }
+      return new Response("Not Found", { status: 404 });
+    }
   });
+  const boundPort = server.port ?? port;
+  const resolvedUrl = `http://${host}:${boundPort}/mcp`;
+  console.error(`${serviceName}-mcp HTTP listening on ${resolvedUrl}`);
+  return {
+    port: boundPort,
+    host,
+    url: resolvedUrl,
+    async close() {
+      await server.stop(true);
+    }
+  };
 }
 
 // src/mcp/index.ts
@@ -7344,6 +7405,15 @@ var TOOLS = [
       required: ["hostname"]
     }
   },
+  {
+    name: "delete_domain",
+    description: "Delete a shortlink domain and all of its links and clicks.",
+    inputSchema: {
+      type: "object",
+      properties: { hostname: { type: "string", description: "Hostname or domain id." } },
+      required: ["hostname"]
+    }
+  },
   {
     name: "stats",
     description: "Total domains/links/clicks counts.",
@@ -7385,6 +7455,8 @@ async function dispatch(name, args) {
         originUrl: args.origin_url,
         notes: args.notes
       }));
+    case "delete_domain":
+      return withStore((s) => s.deleteDomain(args.hostname));
     case "stats":
       return withStore((s) => s.totalStats());
     default:

package/dist/pg-store.d.ts

@@ -29,6 +29,7 @@ export declare class PgShortlinksStore {
     listDomains(): Promise<Domain[]>;
     getDomain(hostnameOrId: string): Promise<Domain | null>;
     getDefaultDomain(): Promise<Domain | null>;
+    deleteDomain(hostnameOrId: string): Promise<Domain>;
     createLink(input: CreateLinkInput): Promise<Link>;
     listLinks(options?: {
         domain?: string;

package/dist/pg-store.js

@@ -474,6 +474,13 @@ class PgShortlinksStore {
     `);
     return row ? domainFromRow(row) : null;
   }
+  async deleteDomain(hostnameOrId) {
+    const domain = await this.getDomain(hostnameOrId);
+    if (!domain)
+      throw new Error("Domain not found.");
+    await this.pg.run("DELETE FROM domains WHERE id = ?", domain.id);
+    return domain;
+  }
   async createLink(input) {
     const domain = input.domain ? await this.getDomain(input.domain) : await this.getDefaultDomain();
     if (!domain) {

package/dist/sdk/generated.d.ts

@@ -87,6 +87,10 @@ export interface DeleteResponse {
     "deleted": boolean;
     "slug"?: string;
 }
+export interface DomainDeleteResponse {
+    "deleted": boolean;
+    "hostname"?: string;
+}
 export interface HealthStatus {
     "status": string;
     "version": string;
@@ -139,6 +143,8 @@ export declare class ShortlinksApiClient {
     listDomains(init?: RequestInit): Promise<DomainList>;
     /** Add or update a domain. */
     addDomain(body: AddDomainRequest, init?: RequestInit): Promise<Domain>;
+    /** Delete a domain and all of its links and clicks. */
+    deleteDomain(hostname: string, init?: RequestInit): Promise<DomainDeleteResponse>;
     /** List shortlinks. */
     listLinks(query?: {
         "domain"?: string;

package/dist/sdk/index.js

@@ -115,6 +115,13 @@ class ShortlinksApiClient {
       init
     });
   }
+  async deleteDomain(hostname, init) {
+    return this.request("DELETE", `/v1/domains/${encodeURIComponent(String(hostname))}`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
   async listLinks(query, init) {
     return this.request("GET", `/v1/links`, {
       body: undefined,
@@ -311,6 +318,11 @@ function buildOpenApiDocument(version) {
           properties: { deleted: { type: "boolean" }, slug: { type: "string" } },
           required: ["deleted"]
         },
+        DomainDeleteResponse: {
+          type: "object",
+          properties: { deleted: { type: "boolean" }, hostname: { type: "string" } },
+          required: ["deleted"]
+        },
         HealthStatus: probe({ db_latency_ms: { type: "integer" } }),
         ReadyStatus: probe({ pending_migrations: { type: "array", items: { type: "string" } } }),
         VersionInfo: probe({ name: { type: "string" } }),
@@ -381,6 +393,19 @@ function buildOpenApiDocument(version) {
           }
         }
       },
+      "/v1/domains/{hostname}": {
+        delete: {
+          operationId: "deleteDomain",
+          summary: "Delete a domain and all of its links and clicks.",
+          security: [{ apiKey: [] }],
+          parameters: [
+            { name: "hostname", in: "path", required: true, schema: { type: "string" } }
+          ],
+          responses: {
+            "200": { content: { "application/json": { schema: { $ref: "#/components/schemas/DomainDeleteResponse" } } } }
+          }
+        }
+      },
       "/v1/links": {
         get: {
           operationId: "listLinks",