@tinycloud/mcp 0.2.2 → 0.3.0

package/dist/http.cjs

@@ -0,0 +1,1093 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/http.ts
+var http_exports = {};
+__export(http_exports, {
+  createHostedMcpApp: () => createHostedMcpApp
+});
+module.exports = __toCommonJS(http_exports);
+var import_server4 = require("@modelcontextprotocol/server");
+
+// src/oauth.ts
+var import_server = require("@modelcontextprotocol/server");
+var import_jose = require("jose");
+var OWNER_DIDS_CLAIM = "https://tinycloud.xyz/owner_dids";
+function createOpenKeyTokenVerifier(config) {
+  const jwks = (0, import_jose.createRemoteJWKSet)(new URL(config.jwksUri));
+  return {
+    async verifyAccessToken(token) {
+      try {
+        const { payload } = await (0, import_jose.jwtVerify)(token, jwks, {
+          issuer: config.issuer,
+          audience: config.audience
+        });
+        return authInfo(token, payload, config);
+      } catch (error) {
+        if (error instanceof import_jose.errors.JOSEError) {
+          throw new import_server.OAuthError(import_server.OAuthErrorCode.InvalidToken, "The OpenKey access token is invalid.");
+        }
+        throw error;
+      }
+    }
+  };
+}
+function authInfo(token, payload, config) {
+  if (typeof payload.sub !== "string" || payload.sub.length === 0) {
+    throw new import_server.OAuthError(import_server.OAuthErrorCode.InvalidToken, "The OpenKey access token does not identify a subject.");
+  }
+  if (typeof payload.exp !== "number") {
+    throw new import_server.OAuthError(import_server.OAuthErrorCode.InvalidToken, "The OpenKey access token has no expiry.");
+  }
+  const scopes = typeof payload.scope === "string" ? payload.scope.split(/\s+/).filter(Boolean) : [];
+  if (config.requiredScope !== void 0 && !scopes.includes(config.requiredScope)) {
+    throw new import_server.OAuthError(
+      import_server.OAuthErrorCode.InsufficientScope,
+      "The OpenKey access token is missing the TinyCloud MCP scope."
+    );
+  }
+  const clientId = firstString(payload.azp, payload.client_id) ?? "unknown";
+  const ownerDids = Array.isArray(payload[OWNER_DIDS_CLAIM]) ? payload[OWNER_DIDS_CLAIM].filter((value) => typeof value === "string") : [];
+  if (ownerDids.length === 0) {
+    throw new import_server.OAuthError(
+      import_server.OAuthErrorCode.InvalidToken,
+      "The OpenKey access token has no TinyCloud owner identity."
+    );
+  }
+  return {
+    token,
+    clientId,
+    scopes,
+    expiresAt: payload.exp,
+    resource: new URL(config.audience),
+    extra: {
+      subject: payload.sub,
+      ownerDids
+    }
+  };
+}
+function firstString(...values) {
+  return values.find((value) => typeof value === "string" && value.length > 0);
+}
+
+// src/remote-store.ts
+var import_node_crypto = require("crypto");
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_node_sdk = require("@tinycloud/node-sdk");
+var import_node_sdk_wasm = require("@tinycloud/node-sdk-wasm");
+var import_operations = require("@tinycloud/operations");
+var PROFILE = "agent";
+var MAX_CALLBACK_BYTES = 256 * 1024;
+var BOOTSTRAP_PERMISSIONS = [
+  {
+    service: "tinycloud.kv",
+    space: "account",
+    path: "spaces/",
+    actions: ["tinycloud.kv/get", "tinycloud.kv/list"]
+  },
+  {
+    service: "tinycloud.kv",
+    space: "account",
+    path: "applications/",
+    actions: ["tinycloud.kv/get", "tinycloud.kv/list"]
+  }
+];
+var RemoteTenantStore = class {
+  #config;
+  #initializing = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.#config = config;
+  }
+  tenantStateRoot(subject) {
+    return (0, import_node_path.join)(this.#config.stateDir, "tenants", this.#tenantId(subject));
+  }
+  async connectStatus(subject, ownerDids = []) {
+    const tenant = await this.#ensureTenant(subject);
+    if (await this.#hasValidSession(tenant, ownerDids)) {
+      return { connected: true, sessionDid: tenant.sessionDid };
+    }
+    const pending = await this.#createPending(subject, ownerDids, "bootstrap", BOOTSTRAP_PERMISSIONS);
+    return {
+      connected: false,
+      sessionDid: tenant.sessionDid,
+      approvalUrl: this.#connectUrl(pending),
+      expiresAt: pending.expiresAt
+    };
+  }
+  async decorateAuthorityResult(subject, ownerDids, result) {
+    if (!isRecord(result) || result.status !== "authority_required") return result;
+    const request = isRecord(result.request) ? result.request : void 0;
+    const requestId = typeof request?.requestId === "string" ? request.requestId : void 0;
+    const requested = Array.isArray(request?.requested) ? request.requested.filter(isPermissionEntry) : [];
+    if (requestId === void 0 || requested.length === 0) return result;
+    const pending = await this.#createPending(subject, ownerDids, "delegation", requested, requestId);
+    return {
+      ...result,
+      approval: {
+        ...isRecord(result.approval) ? result.approval : {},
+        kind: "openkey",
+        requestId,
+        url: this.#connectUrl(pending),
+        fallback: "Open the approval URL, then retry the same MCP tool."
+      }
+    };
+  }
+  async approvalRedirect(state) {
+    const pending = await this.#readPending(state, false);
+    const tenant = await this.#readTenant(pending.tenantId);
+    const callback = new URL("/connect/callback", this.#config.publicUrl);
+    callback.searchParams.set("state", state);
+    const params = new URLSearchParams({
+      did: tenant.sessionDid,
+      callback: callback.toString(),
+      host: this.#config.nodeHost,
+      jwk: Buffer.from(JSON.stringify(publicJwk(tenant.jwk))).toString("base64url"),
+      permissions: Buffer.from(JSON.stringify({
+        permissions: pending.permissions,
+        reason: pending.kind === "bootstrap" ? "Connect this TinyCloud account to the hosted MCP delegate." : "Approve the exact capabilities requested by the TinyCloud MCP operation."
+      })).toString("base64url"),
+      expiry: this.#config.delegationExpiry
+    });
+    return `${this.#config.openkeyHost.replace(/\/+$/, "")}/delegate?${params.toString()}`;
+  }
+  async completeApproval(state, request) {
+    const length = Number(request.headers.get("content-length") ?? "0");
+    if (Number.isFinite(length) && length > MAX_CALLBACK_BYTES) throw new Error("Callback body is too large.");
+    const text = await request.text();
+    if (Buffer.byteLength(text) > MAX_CALLBACK_BYTES) throw new Error("Callback body is too large.");
+    const data = JSON.parse(text);
+    if (!isRecord(data)) throw new Error("Callback body is invalid.");
+    const pending = await this.#readPending(state, true);
+    try {
+      const tenant = await this.#readTenant(pending.tenantId);
+      if (pending.kind === "bootstrap") {
+        await this.#storeBootstrap(tenant, pending, data);
+      } else {
+        await this.#storeDelegation(tenant, pending, data);
+      }
+      await (0, import_promises.rm)(this.#pendingPath(tenant.stateRoot, pending.nonce) + ".processing", { force: true });
+    } catch (error) {
+      await this.#restorePending(pending).catch(() => void 0);
+      throw error;
+    }
+  }
+  async #storeBootstrap(tenant, pending, data) {
+    const session = sessionFromCallback(data, tenant.jwk);
+    const node = new import_node_sdk.TinyCloudNode({ host: this.#config.nodeHost });
+    await node.restoreSession(session);
+    if (!samePrincipal(node.sessionDid, tenant.sessionDid)) {
+      throw new Error("The approved delegation targets a different session.");
+    }
+    if (pending.ownerDids.length > 0 && !pending.ownerDids.some((did) => samePrincipal(node.did, did))) {
+      throw new Error("The approved delegation belongs to a different OpenKey user.");
+    }
+    const granted = [...node.getVerifiedSessionCapabilities()];
+    if (!permissionsCover(pending.permissions, granted)) {
+      throw new Error("The approved delegation does not cover the requested account access.");
+    }
+    const profile = await readJson(this.#profilePath(tenant.stateRoot));
+    await secureWrite(this.#profilePath(tenant.stateRoot), {
+      ...profile,
+      ownerDid: normalizeDid(node.did),
+      spaceId: session.spaceId
+    });
+    await secureWrite(this.#sessionPath(tenant.stateRoot), {
+      authMethod: "openkey",
+      ...session
+    });
+  }
+  async #storeDelegation(tenant, pending, data) {
+    if (pending.requestId === void 0) throw new Error("Authority request is missing.");
+    const delegation = portableFromCallback(data, pending.permissions, this.#config.nodeHost);
+    const result = await (0, import_operations.invokeOperation)(
+      "tinycloud.auth.import",
+      1,
+      { profile: PROFILE, stateRoot: tenant.stateRoot },
+      {
+        requestId: pending.requestId,
+        delegationCid: delegation.cid,
+        delegation
+      }
+    );
+    if (result.status !== "ok") throw new Error("TinyCloud rejected the approved delegation.");
+  }
+  async #ensureTenant(subject) {
+    const tenantId = this.#tenantId(subject);
+    const current = this.#initializing.get(tenantId);
+    if (current !== void 0) return current;
+    const initializing = this.#initializeTenant(tenantId).finally(() => {
+      this.#initializing.delete(tenantId);
+    });
+    this.#initializing.set(tenantId, initializing);
+    return initializing;
+  }
+  async #hasValidSession(tenant, ownerDids) {
+    const raw = await readJson(this.#sessionPath(tenant.stateRoot));
+    if (raw === null) return false;
+    try {
+      const node = new import_node_sdk.TinyCloudNode({ host: this.#config.nodeHost });
+      await node.restoreSession(raw);
+      return samePrincipal(node.sessionDid, tenant.sessionDid) && ownerDids.some((did) => samePrincipal(node.did, did));
+    } catch {
+      await (0, import_promises.rm)(this.#sessionPath(tenant.stateRoot), { force: true });
+      return false;
+    }
+  }
+  async #initializeTenant(tenantId) {
+    const stateRoot = (0, import_node_path.join)(this.#config.stateDir, "tenants", tenantId);
+    const keyPath = this.#keyPath(stateRoot);
+    await secureDirectory((0, import_node_path.join)(stateRoot, ".tinycloud", "profiles", PROFILE));
+    let jwk = await readJson(keyPath);
+    let sessionDid;
+    if (jwk === null) {
+      const generated = generateSessionKey();
+      jwk = generated.jwk;
+      sessionDid = generated.did;
+      await secureWrite(keyPath, jwk);
+    } else {
+      sessionDid = didFromJwk(jwk);
+    }
+    const profilePath = this.#profilePath(stateRoot);
+    if (!await fileExists(profilePath)) {
+      await secureWrite(profilePath, {
+        name: PROFILE,
+        host: this.#config.nodeHost,
+        chainId: 1,
+        spaceName: "default",
+        did: sessionDid,
+        sessionDid,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        posture: "delegate-session",
+        operatorType: "agent",
+        authMethod: "openkey",
+        openkeyHost: this.#config.openkeyHost
+      });
+    }
+    return { stateRoot, sessionDid, jwk };
+  }
+  async #readTenant(tenantId) {
+    if (!/^[a-f0-9]{64}$/.test(tenantId)) throw new Error("Approval state is invalid.");
+    const stateRoot = (0, import_node_path.join)(this.#config.stateDir, "tenants", tenantId);
+    const jwk = await readJson(this.#keyPath(stateRoot));
+    if (jwk === null) throw new Error("The TinyCloud delegate no longer exists.");
+    return { stateRoot, jwk, sessionDid: didFromJwk(jwk) };
+  }
+  async #createPending(subject, ownerDids, kind, permissions, requestId) {
+    const tenant = await this.#ensureTenant(subject);
+    const tenantId = this.#tenantId(subject);
+    const reusable = await reusablePending(
+      this.#pendingDirectory(tenant.stateRoot),
+      { tenantId, kind, requestId, permissions, ownerDids: ownerDids.map(normalizeDid) }
+    );
+    if (reusable !== void 0) return reusable;
+    const nonce = (0, import_node_crypto.randomBytes)(24).toString("base64url");
+    const created = Date.now();
+    const pending = {
+      version: 1,
+      nonce,
+      tenantId,
+      kind,
+      ...requestId === void 0 ? {} : { requestId },
+      permissions,
+      ownerDids: ownerDids.map(normalizeDid),
+      createdAt: new Date(created).toISOString(),
+      expiresAt: new Date(created + this.#config.approvalTtlSeconds * 1e3).toISOString()
+    };
+    await secureWrite(this.#pendingPath(tenant.stateRoot, nonce), pending);
+    return pending;
+  }
+  async #readPending(state, consume) {
+    const [tenantId, nonce, signature] = state.split(".");
+    if (tenantId === void 0 || nonce === void 0 || signature === void 0) {
+      throw new Error("Approval state is invalid.");
+    }
+    const expected = this.#signState(tenantId, nonce);
+    const supplied = Buffer.from(signature, "base64url");
+    const expectedBytes = Buffer.from(expected, "base64url");
+    if (supplied.length !== expectedBytes.length || !(0, import_node_crypto.timingSafeEqual)(supplied, expectedBytes)) {
+      throw new Error("Approval state is invalid.");
+    }
+    const stateRoot = (0, import_node_path.join)(this.#config.stateDir, "tenants", tenantId);
+    const path = this.#pendingPath(stateRoot, nonce);
+    const claimed = `${path}.processing`;
+    if (consume) await (0, import_promises.rename)(path, claimed);
+    try {
+      const pending = await readJson(consume ? claimed : path);
+      if (pending === null || pending.version !== 1 || pending.tenantId !== tenantId || pending.nonce !== nonce) {
+        throw new Error("Approval state is invalid or already used.");
+      }
+      if (new Date(pending.expiresAt).getTime() <= Date.now()) {
+        await (0, import_promises.rm)(consume ? claimed : path, { force: true });
+        throw new Error("Approval state has expired.");
+      }
+      return pending;
+    } catch (error) {
+      if (consume) await (0, import_promises.rename)(claimed, path).catch(() => void 0);
+      throw error;
+    }
+  }
+  async #restorePending(pending) {
+    const stateRoot = (0, import_node_path.join)(this.#config.stateDir, "tenants", pending.tenantId);
+    const path = this.#pendingPath(stateRoot, pending.nonce);
+    await (0, import_promises.rename)(`${path}.processing`, path);
+  }
+  #connectUrl(pending) {
+    const url = new URL("/connect", this.#config.publicUrl);
+    url.searchParams.set("state", `${pending.tenantId}.${pending.nonce}.${this.#signState(pending.tenantId, pending.nonce)}`);
+    return url.toString();
+  }
+  #tenantId(subject) {
+    return (0, import_node_crypto.createHmac)("sha256", this.#config.stateSecret).update(`tenant:${subject}`).digest("hex");
+  }
+  #signState(tenantId, nonce) {
+    return (0, import_node_crypto.createHmac)("sha256", this.#config.stateSecret).update(`approval:${tenantId}:${nonce}`).digest("base64url");
+  }
+  #profilePath(stateRoot) {
+    return (0, import_node_path.join)(stateRoot, ".tinycloud", "profiles", PROFILE, "profile.json");
+  }
+  #keyPath(stateRoot) {
+    return (0, import_node_path.join)(stateRoot, ".tinycloud", "profiles", PROFILE, "key.json");
+  }
+  #sessionPath(stateRoot) {
+    return (0, import_node_path.join)(stateRoot, ".tinycloud", "profiles", PROFILE, "session.json");
+  }
+  #pendingPath(stateRoot, nonce) {
+    return (0, import_node_path.join)(this.#pendingDirectory(stateRoot), `${nonce}.json`);
+  }
+  #pendingDirectory(stateRoot) {
+    return (0, import_node_path.join)(stateRoot, ".tinycloud", "profiles", PROFILE, "pending");
+  }
+};
+var wasmInitialized = false;
+function generateSessionKey() {
+  ensureWasm();
+  const manager = new import_node_sdk_wasm.TCWSessionManager();
+  const keyId = manager.createSessionKey("hosted-mcp");
+  const serialized = manager.jwk(keyId);
+  if (!serialized) throw new Error("Could not generate the hosted delegate key.");
+  return { jwk: JSON.parse(serialized), did: manager.getDID(keyId) };
+}
+function didFromJwk(jwk) {
+  ensureWasm();
+  const manager = new import_node_sdk_wasm.TCWSessionManager();
+  const keyId = (0, import_node_sdk_wasm.importKey)(manager, JSON.stringify(jwk), "hosted-mcp");
+  return manager.getDID(keyId);
+}
+function ensureWasm() {
+  if (wasmInitialized) return;
+  (0, import_node_sdk_wasm.initPanicHook)();
+  wasmInitialized = true;
+}
+function sessionFromCallback(data, privateJwk) {
+  const delegationHeader = data.delegationHeader;
+  if (!isRecord(delegationHeader) || typeof delegationHeader.Authorization !== "string" || typeof data.delegationCid !== "string" || typeof data.spaceId !== "string" || typeof data.verificationMethod !== "string") {
+    throw new Error("OpenKey returned an incomplete delegation.");
+  }
+  return {
+    delegationHeader: { Authorization: delegationHeader.Authorization },
+    delegationCid: data.delegationCid,
+    spaceId: data.spaceId,
+    jwk: privateJwk,
+    verificationMethod: data.verificationMethod,
+    ...typeof data.address === "string" ? { address: data.address } : {},
+    ...typeof data.chainId === "number" ? { chainId: data.chainId } : {},
+    ...typeof data.siwe === "string" ? { siwe: data.siwe } : {},
+    ...typeof data.signature === "string" ? { signature: data.signature } : {}
+  };
+}
+function portableFromCallback(data, permissions, host) {
+  const primary = permissions.find((permission) => permission.service !== "tinycloud.encryption") ?? permissions[0];
+  if (primary === void 0) throw new Error("The authority request has no permissions.");
+  const session = sessionFromCallback(data, {});
+  const expiry = delegationExpiry(data);
+  return {
+    cid: session.delegationCid,
+    delegationHeader: session.delegationHeader,
+    spaceId: session.spaceId,
+    path: primary.path,
+    actions: [...primary.actions],
+    resources: permissions.map((permission) => ({
+      service: permission.service.startsWith("tinycloud.") ? permission.service.slice("tinycloud.".length) : permission.service,
+      space: permission.service === "tinycloud.encryption" ? requiredPermissionSpace(permission) : session.spaceId,
+      path: permission.path,
+      actions: [...permission.actions]
+    })),
+    expiry,
+    delegateDID: session.verificationMethod,
+    ownerAddress: typeof data.address === "string" ? data.address : "",
+    chainId: typeof data.chainId === "number" ? data.chainId : 1,
+    host
+  };
+}
+function delegationExpiry(data) {
+  for (const key of ["expiry", "expiresAt", "expirationTime"]) {
+    const parsed = parseDate(data[key]);
+    if (parsed !== void 0) return parsed;
+  }
+  if (typeof data.siwe === "string") {
+    const match = data.siwe.match(/^Expiration Time:\s*(.+)$/im);
+    const parsed = parseDate(match?.[1]?.trim());
+    if (parsed !== void 0) return parsed;
+  }
+  throw new Error("OpenKey did not return a delegation expiry.");
+}
+function permissionsCover(requested, granted) {
+  return requested.every((request) => granted.some(
+    (grant) => normalizeService(grant.service) === normalizeService(request.service) && typeof grant.space === "string" && typeof request.space === "string" && sameSpace(grant.space, request.space) && grant.path === request.path && request.actions.every((action) => grant.actions.includes(action))
+  ));
+}
+function sameSpace(granted, requested) {
+  return granted === requested || granted.endsWith(`:${requested}`);
+}
+function normalizeService(service) {
+  return service.startsWith("tinycloud.") ? service : `tinycloud.${service}`;
+}
+function requiredPermissionSpace(permission) {
+  if (typeof permission.space !== "string") throw new Error("The authority request has no space.");
+  return permission.space;
+}
+function publicJwk(jwk) {
+  const copy = { ...jwk };
+  for (const field of ["d", "p", "q", "dp", "dq", "qi", "oth", "k"]) delete copy[field];
+  return copy;
+}
+function samePrincipal(left, right) {
+  if (typeof left !== "string") return false;
+  try {
+    return (0, import_node_sdk.principalDidEquals)(left, right);
+  } catch {
+    return false;
+  }
+}
+function normalizeDid(value) {
+  return value.split("#", 1)[0];
+}
+function isPermissionEntry(value) {
+  return isRecord(value) && typeof value.service === "string" && typeof value.space === "string" && typeof value.path === "string" && Array.isArray(value.actions) && value.actions.every((action) => typeof action === "string");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseDate(value) {
+  if (typeof value !== "string" && typeof value !== "number") return void 0;
+  const date = new Date(typeof value === "number" && value < 1e10 ? value * 1e3 : value);
+  return Number.isNaN(date.getTime()) ? void 0 : date;
+}
+async function secureDirectory(path) {
+  await (0, import_promises.mkdir)(path, { recursive: true, mode: 448 });
+  await (0, import_promises.chmod)(path, 448);
+}
+async function secureWrite(path, value) {
+  const directory = (0, import_node_path.dirname)(path);
+  await secureDirectory(directory);
+  const temporary = `${path}.${process.pid}.${(0, import_node_crypto.randomBytes)(8).toString("hex")}.tmp`;
+  await (0, import_promises.writeFile)(temporary, `${JSON.stringify(value, jsonReplacer, 2)}
+`, { mode: 384 });
+  await (0, import_promises.rename)(temporary, path);
+  await (0, import_promises.chmod)(path, 384);
+}
+function jsonReplacer(_key, value) {
+  return value instanceof Date ? value.toISOString() : value;
+}
+async function readJson(path) {
+  try {
+    return JSON.parse(await (0, import_promises.readFile)(path, "utf8"));
+  } catch (error) {
+    if (isRecord(error) && error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+async function fileExists(path) {
+  return await readJson(path) !== null;
+}
+async function reusablePending(directory, expected) {
+  let names;
+  try {
+    names = await (0, import_promises.readdir)(directory);
+  } catch (error) {
+    if (isRecord(error) && error.code === "ENOENT") return void 0;
+    throw error;
+  }
+  const active = [];
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    const path = (0, import_node_path.join)(directory, name);
+    const pending = await readJson(path).catch(() => null);
+    if (pending === null || new Date(pending.expiresAt).getTime() <= Date.now()) {
+      await (0, import_promises.rm)(path, { force: true });
+      continue;
+    }
+    active.push(pending);
+    if (samePendingRequest(pending, expected)) return pending;
+  }
+  if (active.length >= 64) {
+    active.sort((left, right) => Date.parse(left.createdAt) - Date.parse(right.createdAt));
+    await (0, import_promises.rm)((0, import_node_path.join)(directory, `${active[0].nonce}.json`), { force: true });
+  }
+  return void 0;
+}
+function samePendingRequest(pending, expected) {
+  return pending.version === 1 && pending.tenantId === expected.tenantId && pending.kind === expected.kind && pending.requestId === expected.requestId && JSON.stringify(pending.permissions) === JSON.stringify(expected.permissions) && JSON.stringify(pending.ownerDids) === JSON.stringify(expected.ownerDids);
+}
+
+// src/server.ts
+var import_server3 = require("@modelcontextprotocol/server");
+var import_stdio = require("@modelcontextprotocol/server/stdio");
+
+// src/tools.ts
+var import_node_module = require("module");
+var import_node_path2 = require("path");
+var import_server2 = require("@modelcontextprotocol/server");
+var import_ajv = require("@modelcontextprotocol/server/validators/ajv");
+var import_operations2 = require("@tinycloud/operations");
+
+// src/results.ts
+function toMcpToolResult(result) {
+  const canonical = isCanonicalOperationResult(result) ? result : {
+    status: "error",
+    operation: {},
+    context: {},
+    error: { code: "INTERNAL_ERROR" }
+  };
+  return {
+    content: [{ type: "text", text: resultSummary(canonical.status) }],
+    structuredContent: canonical
+  };
+}
+function isCanonicalOperationResult(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const status = value.status;
+  return status === "ok" || status === "authority_required" || status === "setup_required" || status === "error";
+}
+function resultSummary(status) {
+  switch (status) {
+    case "ok":
+      return "TinyCloud operation completed; use the structured result.";
+    case "authority_required":
+      return "TinyCloud authority is required; use the structured request and approval action.";
+    case "setup_required":
+      return "TinyCloud setup is required; use the structured setup action.";
+    case "error":
+      return "TinyCloud operation failed; use the structured error.";
+  }
+}
+
+// src/tools.ts
+var import_meta = {};
+function invocationTargetForMcp(selection) {
+  return {
+    profile: selection.profile,
+    ...selection.explicitProfile && selection.allowOwnerProfile ? { allowOwnerProfile: true } : {},
+    ...selection.stateRoot === void 0 ? {} : { stateRoot: selection.stateRoot }
+  };
+}
+var packageRequire = (0, import_node_module.createRequire)(
+  typeof __dirname === "string" ? (0, import_node_path2.join)(__dirname, "tools.cjs") : import_meta.url
+);
+var generatedCatalog = packageRequire(
+  "@tinycloud/operations/operations.json"
+);
+var TOOL_BINDINGS = [
+  {
+    name: "tinycloud_status",
+    operationId: "tinycloud.status.get",
+    operationVersion: 1,
+    readOnlyHint: true,
+    idempotentHint: true,
+    destructiveHint: false,
+    openWorldHint: false
+  },
+  {
+    name: "tinycloud_auth_status",
+    operationId: "tinycloud.auth.status",
+    operationVersion: 1,
+    readOnlyHint: true,
+    idempotentHint: true,
+    destructiveHint: false,
+    openWorldHint: false
+  },
+  {
+    name: "tinycloud_auth_capabilities",
+    operationId: "tinycloud.auth.capabilities",
+    operationVersion: 1,
+    readOnlyHint: true,
+    idempotentHint: true,
+    destructiveHint: false,
+    openWorldHint: false
+  },
+  {
+    name: "tinycloud_auth_request",
+    operationId: "tinycloud.auth.request",
+    operationVersion: 1,
+    readOnlyHint: false,
+    idempotentHint: true,
+    destructiveHint: false,
+    openWorldHint: false
+  },
+  {
+    name: "tinycloud_auth_import",
+    operationId: "tinycloud.auth.import",
+    operationVersion: 1,
+    readOnlyHint: false,
+    idempotentHint: true,
+    destructiveHint: false,
+    openWorldHint: false
+  },
+  {
+    name: "tinycloud_account_spaces_list",
+    operationId: "tinycloud.account.spaces.list",
+    operationVersion: 1,
+    readOnlyHint: true,
+    idempotentHint: true,
+    destructiveHint: false,
+    openWorldHint: true
+  },
+  {
+    name: "tinycloud_account_applications_list",
+    operationId: "tinycloud.account.applications.list",
+    operationVersion: 1,
+    readOnlyHint: true,
+    idempotentHint: true,
+    destructiveHint: false,
+    openWorldHint: true
+  },
+  {
+    name: "tinycloud_kv_list",
+    operationId: "tinycloud.kv.list",
+    operationVersion: 1,
+    readOnlyHint: true,
+    idempotentHint: true,
+    destructiveHint: false,
+    openWorldHint: true
+  },
+  {
+    name: "tinycloud_kv_get",
+    operationId: "tinycloud.kv.get",
+    operationVersion: 1,
+    readOnlyHint: true,
+    idempotentHint: true,
+    destructiveHint: false,
+    openWorldHint: true
+  },
+  {
+    name: "tinycloud_kv_head",
+    operationId: "tinycloud.kv.head",
+    operationVersion: 1,
+    readOnlyHint: true,
+    idempotentHint: true,
+    destructiveHint: false,
+    openWorldHint: true
+  },
+  {
+    name: "tinycloud_kv_put",
+    operationId: "tinycloud.kv.put",
+    operationVersion: 1,
+    readOnlyHint: false,
+    idempotentHint: true,
+    destructiveHint: true,
+    openWorldHint: true
+  },
+  {
+    name: "tinycloud_kv_delete",
+    operationId: "tinycloud.kv.delete",
+    operationVersion: 1,
+    readOnlyHint: false,
+    idempotentHint: true,
+    destructiveHint: true,
+    openWorldHint: true
+  },
+  {
+    name: "tinycloud_sql_schema_inspect",
+    operationId: "tinycloud.sql.schema.inspect",
+    operationVersion: 1,
+    readOnlyHint: true,
+    idempotentHint: true,
+    destructiveHint: false,
+    openWorldHint: true
+  },
+  {
+    name: "tinycloud_sql_query",
+    operationId: "tinycloud.sql.query",
+    operationVersion: 1,
+    readOnlyHint: true,
+    idempotentHint: true,
+    destructiveHint: false,
+    openWorldHint: true
+  },
+  {
+    name: "tinycloud_sql_execute",
+    operationId: "tinycloud.sql.execute",
+    operationVersion: 1,
+    readOnlyHint: false,
+    idempotentHint: false,
+    destructiveHint: true,
+    openWorldHint: true
+  },
+  {
+    name: "tinycloud_secrets_get",
+    operationId: "tinycloud.secrets.get",
+    operationVersion: 1,
+    readOnlyHint: false,
+    idempotentHint: true,
+    destructiveHint: false,
+    openWorldHint: true
+  }
+];
+function createJsonSchemaValidator() {
+  const ajv = new import_ajv.Ajv({ strict: false });
+  (0, import_ajv.addFormats)(ajv);
+  return new import_ajv.AjvJsonSchemaValidator(ajv);
+}
+function registerTinyCloudTools(server, selection, validator) {
+  const definitions = new Map(
+    generatedCatalog.operations.map((operation) => [
+      `${operation.id}@${operation.version}`,
+      operation
+    ])
+  );
+  for (const binding of TOOL_BINDINGS) {
+    const operation = definitions.get(`${binding.operationId}@${binding.operationVersion}`);
+    if (operation === void 0) {
+      throw new Error(`Generated operations catalog is missing ${binding.operationId}@${binding.operationVersion}.`);
+    }
+    const inputSchema = (0, import_server2.fromJsonSchema)(
+      operation.input,
+      validator
+    );
+    const outputSchema = (0, import_server2.fromJsonSchema)(
+      operation.result,
+      validator
+    );
+    const annotations = {
+      readOnlyHint: binding.readOnlyHint,
+      idempotentHint: binding.idempotentHint,
+      destructiveHint: binding.destructiveHint,
+      openWorldHint: binding.openWorldHint
+    };
+    server.registerTool(
+      binding.name,
+      {
+        title: operation.title,
+        description: operation.description,
+        inputSchema,
+        outputSchema,
+        annotations
+      },
+      async (input) => {
+        const result = await (0, import_operations2.invokeOperation)(
+          binding.operationId,
+          binding.operationVersion,
+          invocationTargetForMcp(selection),
+          input
+        );
+        const projected = selection.transformOperationResult === void 0 ? result : await selection.transformOperationResult(result);
+        return toMcpToolResult(projected);
+      }
+    );
+  }
+}
+
+// package.json
+var package_default = {
+  name: "@tinycloud/mcp",
+  version: "0.3.0",
+  description: "TinyCloud delegated operations MCP server",
+  keywords: [
+    "tinycloud",
+    "mcp",
+    "model-context-protocol",
+    "agents",
+    "delegation",
+    "ucan",
+    "kv",
+    "sqlite"
+  ],
+  author: "TinyCloud, Inc.",
+  license: "EGPL",
+  type: "module",
+  main: "dist/index.cjs",
+  module: "dist/index.js",
+  types: "dist/index.d.ts",
+  bin: {
+    "tinycloud-mcp": "./bin/tinycloud-mcp",
+    "tinycloud-mcp-http": "./bin/tinycloud-mcp-http"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      require: "./dist/index.cjs"
+    },
+    "./server": {
+      types: "./dist/server.d.ts",
+      import: "./dist/server.js",
+      require: "./dist/server.cjs"
+    },
+    "./tools": {
+      types: "./dist/tools.d.ts",
+      import: "./dist/tools.js",
+      require: "./dist/tools.cjs"
+    },
+    "./results": {
+      types: "./dist/results.d.ts",
+      import: "./dist/results.js",
+      require: "./dist/results.cjs"
+    },
+    "./http": {
+      types: "./dist/http.d.ts",
+      import: "./dist/http.js",
+      require: "./dist/http.cjs"
+    }
+  },
+  files: [
+    "dist",
+    "bin",
+    "generated",
+    "skills"
+  ],
+  engines: {
+    node: ">=20"
+  },
+  scripts: {
+    build: "tsup",
+    clean: "rm -rf dist",
+    test: "bun run build && bun scripts/test.ts && bun run check:generated",
+    "test:stdio": "bun run build && bun test src/stdio.test.ts",
+    typecheck: "tsc -p tsconfig.json",
+    "start:http": "node dist/http-cli.js",
+    generate: "bun scripts/generate.ts",
+    "check:generated": "bun scripts/generate.ts --check"
+  },
+  dependencies: {
+    "@modelcontextprotocol/node": "2.0.0-beta.4",
+    "@modelcontextprotocol/server": "2.0.0-beta.4",
+    "@tinycloud/node-sdk": "2.9.0",
+    "@tinycloud/node-sdk-wasm": "1.7.5",
+    "@tinycloud/operations": "0.3.0",
+    jose: "6.1.3"
+  },
+  devDependencies: {
+    "@modelcontextprotocol/client": "2.0.0-beta.4",
+    "@types/node": "^20",
+    tsup: "^8.0.0",
+    typescript: "^5.9.3"
+  },
+  repository: {
+    type: "git",
+    url: "https://github.com/TinyCloudLabs/js-sdk"
+  },
+  homepage: "https://docs.tinycloud.xyz/cli/mcp"
+};
+
+// src/version.ts
+var MCP_VERSION = package_default.version;
+
+// src/server.ts
+var MCP_SERVER_NAME = "tinycloud-mcp";
+
+// src/http.ts
+var REQUIRED_SCOPE = "tinycloud:mcp";
+function createHostedMcpApp(config) {
+  const resourceUrl = canonicalResourceUrl(config.publicUrl);
+  const issuer = String(config.oauthMetadata.issuer);
+  const jwksUri = String(config.oauthMetadata.jwks_uri);
+  const verifier = createOpenKeyTokenVerifier({
+    issuer,
+    audience: resourceUrl.toString(),
+    jwksUri,
+    requiredScope: REQUIRED_SCOPE
+  });
+  const resourceMetadataUrl = (0, import_server4.getOAuthProtectedResourceMetadataUrl)(resourceUrl);
+  const authenticate = (0, import_server4.requireBearerAuth)({
+    verifier,
+    requiredScopes: [REQUIRED_SCOPE],
+    resourceMetadataUrl
+  });
+  const store = new RemoteTenantStore({ ...config, publicUrl: resourceUrl });
+  const handler = (0, import_server4.createMcpHandler)(async ({ authInfo: authInfo2 }) => {
+    const identity = oauthIdentity(authInfo2);
+    const { subject, ownerDids } = identity;
+    const stateRoot = store.tenantStateRoot(subject);
+    const validator = createJsonSchemaValidator();
+    const server = new import_server4.McpServer(
+      { name: MCP_SERVER_NAME, version: MCP_VERSION },
+      {
+        jsonSchemaValidator: validator,
+        instructions: "Call tinycloud_connect first. If an operation returns authority_required, open approval.url, then retry that operation unchanged."
+      }
+    );
+    registerTinyCloudTools(server, {
+      profile: "agent",
+      explicitProfile: true,
+      allowOwnerProfile: false,
+      stateRoot,
+      transformOperationResult: (result) => store.decorateAuthorityResult(subject, ownerDids, result)
+    }, validator);
+    registerConnectTool(server, validator, store, identity);
+    return server;
+  }, {
+    legacy: "stateless",
+    onerror: () => writeDiagnostic("MCP request failed")
+  });
+  const metadataOptions = {
+    oauthMetadata: config.oauthMetadata,
+    resourceServerUrl: resourceUrl,
+    serviceDocumentationUrl: new URL("https://docs.tinycloud.xyz/cli/mcp"),
+    scopesSupported: [REQUIRED_SCOPE],
+    resourceName: "TinyCloud hosted MCP"
+  };
+  const allowedHosts = [resourceUrl.hostname];
+  return {
+    async fetch(request) {
+      const metadata = (0, import_server4.oauthMetadataResponse)(request, metadataOptions);
+      if (metadata !== void 0) return metadata;
+      const url = new URL(request.url);
+      if (url.pathname === "/healthz") {
+        return request.method === "GET" ? json({ ok: true }) : methodNotAllowed("GET");
+      }
+      const hostFailure = (0, import_server4.hostHeaderValidationResponse)(request, allowedHosts);
+      if (hostFailure !== void 0) return hostFailure;
+      if (url.pathname === "/connect") {
+        if (request.method !== "GET") return methodNotAllowed("GET");
+        try {
+          const destination = await store.approvalRedirect(requiredState(url));
+          return Response.redirect(destination, 302);
+        } catch {
+          return json({ error: "The approval link is invalid or expired." }, 400);
+        }
+      }
+      if (url.pathname === "/connect/callback") {
+        if (request.method === "OPTIONS") return callbackCors(new Response(null, { status: 204 }), config.openkeyHost);
+        if (request.method !== "POST") return methodNotAllowed("POST");
+        const originFailure2 = validateCallbackOrigin(request, config.openkeyHost);
+        if (originFailure2 !== void 0) return callbackCors(originFailure2, config.openkeyHost);
+        try {
+          await store.completeApproval(requiredState(url), request);
+          return callbackCors(json({ success: true }), config.openkeyHost);
+        } catch {
+          return callbackCors(json({ error: "TinyCloud could not accept this delegation." }, 400), config.openkeyHost);
+        }
+      }
+      if (url.pathname !== resourceUrl.pathname) return json({ error: "Not found" }, 404);
+      const originFailure = validateOrigin(request, config.allowedOrigins);
+      if (originFailure !== void 0) return originFailure;
+      const auth = await authenticate(request);
+      if (auth instanceof Response) return auth;
+      return handler.fetch(request, { authInfo: auth });
+    },
+    close: () => handler.close()
+  };
+}
+function registerConnectTool(server, validator, store, identity) {
+  const inputSchema = (0, import_server4.fromJsonSchema)({ type: "object", properties: {}, additionalProperties: false }, validator);
+  const outputSchema = (0, import_server4.fromJsonSchema)({
+    type: "object",
+    properties: {
+      connected: { type: "boolean" },
+      sessionDid: { type: "string" },
+      approvalUrl: { type: "string", format: "uri" },
+      expiresAt: { type: "string", format: "date-time" }
+    },
+    required: ["connected", "sessionDid"],
+    additionalProperties: false
+  }, validator);
+  server.registerTool(
+    "tinycloud_connect",
+    {
+      title: "Connect TinyCloud",
+      description: "Check the hosted delegate connection and return a one-time OpenKey approval URL when setup is required.",
+      inputSchema,
+      outputSchema,
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: true,
+        destructiveHint: false,
+        openWorldHint: true
+      }
+    },
+    async () => {
+      const status = await store.connectStatus(identity.subject, identity.ownerDids);
+      return {
+        content: [{
+          type: "text",
+          text: status.connected ? "TinyCloud is connected." : "TinyCloud approval is required; open approvalUrl, then call this tool again."
+        }],
+        structuredContent: status
+      };
+    }
+  );
+}
+function oauthIdentity(authInfo2) {
+  const subject = authInfo2?.extra?.subject;
+  if (typeof subject !== "string" || subject.length === 0) {
+    throw new Error("The authenticated MCP request has no OpenKey subject.");
+  }
+  const ownerDids = authInfo2?.extra?.ownerDids;
+  if (!Array.isArray(ownerDids) || ownerDids.length === 0 || !ownerDids.every((did) => typeof did === "string")) {
+    throw new Error("The authenticated MCP request has no OpenKey owner identity.");
+  }
+  return { subject, ownerDids };
+}
+function canonicalResourceUrl(url) {
+  const resource = new URL(url);
+  resource.hash = "";
+  resource.search = "";
+  resource.pathname = resource.pathname.replace(/\/+$/, "") || "/mcp";
+  if (resource.pathname === "/") resource.pathname = "/mcp";
+  return resource;
+}
+function requiredState(url) {
+  const state = url.searchParams.get("state");
+  if (state === null || state.length > 512) throw new Error("Missing approval state.");
+  return state;
+}
+function validateOrigin(request, allowed) {
+  const origin = request.headers.get("origin");
+  if (origin === null) return void 0;
+  const allowlist = allowed ?? [];
+  return allowlist.includes(origin) ? void 0 : json({ error: "Origin is not allowed." }, 403);
+}
+function validateCallbackOrigin(request, openkeyHost) {
+  const origin = request.headers.get("origin");
+  return origin === null || origin === new URL(openkeyHost).origin ? void 0 : json({ error: "Origin is not allowed." }, 403);
+}
+function callbackCors(response, openkeyHost) {
+  const headers = new Headers(response.headers);
+  headers.set("access-control-allow-origin", new URL(openkeyHost).origin);
+  headers.set("access-control-allow-methods", "POST, OPTIONS");
+  headers.set("access-control-allow-headers", "content-type");
+  headers.set("vary", "Origin");
+  return new Response(response.body, { status: response.status, headers });
+}
+function json(value, status = 200) {
+  return Response.json(value, { status, headers: { "cache-control": "no-store" } });
+}
+function methodNotAllowed(allow) {
+  return new Response("Method not allowed", { status: 405, headers: { allow } });
+}
+function writeDiagnostic(message) {
+  process.stderr.write(`[tinycloud-mcp-http] ${message}
+`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createHostedMcpApp
+});
+//# sourceMappingURL=http.cjs.map