@tinycloud/mcp 0.2.2 → 0.3.0

package/dist/index.js

@@ -69,7 +69,8 @@ var TOOL_NAMES = [
 function invocationTargetForMcp(selection) {
   return {
     profile: selection.profile,
-    ...selection.explicitProfile && selection.allowOwnerProfile ? { allowOwnerProfile: true } : {}
+    ...selection.explicitProfile && selection.allowOwnerProfile ? { allowOwnerProfile: true } : {},
+    ...selection.stateRoot === void 0 ? {} : { stateRoot: selection.stateRoot }
   };
 }
 var packageRequire = createRequire(
@@ -271,7 +272,8 @@ function registerTinyCloudTools(server, selection, validator) {
           invocationTargetForMcp(selection),
           input
         );
-        return toMcpToolResult(result);
+        const projected = selection.transformOperationResult === void 0 ? result : await selection.transformOperationResult(result);
+        return toMcpToolResult(projected);
       }
     );
   }
@@ -280,7 +282,7 @@ function registerTinyCloudTools(server, selection, validator) {
 // package.json
 var package_default = {
   name: "@tinycloud/mcp",
-  version: "0.2.2",
+  version: "0.3.0",
   description: "TinyCloud delegated operations MCP server",
   keywords: [
     "tinycloud",
@@ -299,7 +301,8 @@ var package_default = {
   module: "dist/index.js",
   types: "dist/index.d.ts",
   bin: {
-    "tinycloud-mcp": "./bin/tinycloud-mcp"
+    "tinycloud-mcp": "./bin/tinycloud-mcp",
+    "tinycloud-mcp-http": "./bin/tinycloud-mcp-http"
   },
   exports: {
     ".": {
@@ -321,6 +324,11 @@ var package_default = {
       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: [
@@ -338,12 +346,17 @@ var package_default = {
     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/operations": "0.2.1"
+    "@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",
@@ -479,11 +492,736 @@ if (isDirectInvocation()) {
     process.exitCode = 1;
   });
 }
+
+// src/http.ts
+import {
+  McpServer as McpServer2,
+  createMcpHandler,
+  fromJsonSchema as fromJsonSchema2,
+  getOAuthProtectedResourceMetadataUrl,
+  hostHeaderValidationResponse,
+  oauthMetadataResponse,
+  requireBearerAuth
+} from "@modelcontextprotocol/server";
+
+// src/oauth.ts
+import {
+  OAuthError,
+  OAuthErrorCode
+} from "@modelcontextprotocol/server";
+import { createRemoteJWKSet, errors, jwtVerify } from "jose";
+var OWNER_DIDS_CLAIM = "https://tinycloud.xyz/owner_dids";
+function createOpenKeyTokenVerifier(config) {
+  const jwks = createRemoteJWKSet(new URL(config.jwksUri));
+  return {
+    async verifyAccessToken(token) {
+      try {
+        const { payload } = await jwtVerify(token, jwks, {
+          issuer: config.issuer,
+          audience: config.audience
+        });
+        return authInfo(token, payload, config);
+      } catch (error) {
+        if (error instanceof errors.JOSEError) {
+          throw new OAuthError(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 OAuthError(OAuthErrorCode.InvalidToken, "The OpenKey access token does not identify a subject.");
+  }
+  if (typeof payload.exp !== "number") {
+    throw new OAuthError(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 OAuthError(
+      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 OAuthError(
+      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
+import { createHmac, randomBytes, timingSafeEqual } from "crypto";
+import { chmod, mkdir, readFile, readdir, rename, rm, writeFile } from "fs/promises";
+import { dirname, join as join2 } from "path";
+import {
+  TinyCloudNode,
+  principalDidEquals
+} from "@tinycloud/node-sdk";
+import { TCWSessionManager, importKey, initPanicHook } from "@tinycloud/node-sdk-wasm";
+import { invokeOperation as invokeOperation2 } from "@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 join2(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 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 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 invokeOperation2(
+      "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 TinyCloudNode({ host: this.#config.nodeHost });
+      await node.restoreSession(raw);
+      return samePrincipal(node.sessionDid, tenant.sessionDid) && ownerDids.some((did) => samePrincipal(node.did, did));
+    } catch {
+      await rm(this.#sessionPath(tenant.stateRoot), { force: true });
+      return false;
+    }
+  }
+  async #initializeTenant(tenantId) {
+    const stateRoot = join2(this.#config.stateDir, "tenants", tenantId);
+    const keyPath = this.#keyPath(stateRoot);
+    await secureDirectory(join2(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 = join2(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 = 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 || !timingSafeEqual(supplied, expectedBytes)) {
+      throw new Error("Approval state is invalid.");
+    }
+    const stateRoot = join2(this.#config.stateDir, "tenants", tenantId);
+    const path = this.#pendingPath(stateRoot, nonce);
+    const claimed = `${path}.processing`;
+    if (consume) await 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 rm(consume ? claimed : path, { force: true });
+        throw new Error("Approval state has expired.");
+      }
+      return pending;
+    } catch (error) {
+      if (consume) await rename(claimed, path).catch(() => void 0);
+      throw error;
+    }
+  }
+  async #restorePending(pending) {
+    const stateRoot = join2(this.#config.stateDir, "tenants", pending.tenantId);
+    const path = this.#pendingPath(stateRoot, pending.nonce);
+    await 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 createHmac("sha256", this.#config.stateSecret).update(`tenant:${subject}`).digest("hex");
+  }
+  #signState(tenantId, nonce) {
+    return createHmac("sha256", this.#config.stateSecret).update(`approval:${tenantId}:${nonce}`).digest("base64url");
+  }
+  #profilePath(stateRoot) {
+    return join2(stateRoot, ".tinycloud", "profiles", PROFILE, "profile.json");
+  }
+  #keyPath(stateRoot) {
+    return join2(stateRoot, ".tinycloud", "profiles", PROFILE, "key.json");
+  }
+  #sessionPath(stateRoot) {
+    return join2(stateRoot, ".tinycloud", "profiles", PROFILE, "session.json");
+  }
+  #pendingPath(stateRoot, nonce) {
+    return join2(this.#pendingDirectory(stateRoot), `${nonce}.json`);
+  }
+  #pendingDirectory(stateRoot) {
+    return join2(stateRoot, ".tinycloud", "profiles", PROFILE, "pending");
+  }
+};
+var wasmInitialized = false;
+function generateSessionKey() {
+  ensureWasm();
+  const manager = new 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 TCWSessionManager();
+  const keyId = importKey(manager, JSON.stringify(jwk), "hosted-mcp");
+  return manager.getDID(keyId);
+}
+function ensureWasm() {
+  if (wasmInitialized) return;
+  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 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 mkdir(path, { recursive: true, mode: 448 });
+  await chmod(path, 448);
+}
+async function secureWrite(path, value) {
+  const directory = dirname(path);
+  await secureDirectory(directory);
+  const temporary = `${path}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(value, jsonReplacer, 2)}
+`, { mode: 384 });
+  await rename(temporary, path);
+  await chmod(path, 384);
+}
+function jsonReplacer(_key, value) {
+  return value instanceof Date ? value.toISOString() : value;
+}
+async function readJson(path) {
+  try {
+    return JSON.parse(await 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 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 = join2(directory, name);
+    const pending = await readJson(path).catch(() => null);
+    if (pending === null || new Date(pending.expiresAt).getTime() <= Date.now()) {
+      await 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 rm(join2(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/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 = getOAuthProtectedResourceMetadataUrl(resourceUrl);
+  const authenticate = requireBearerAuth({
+    verifier,
+    requiredScopes: [REQUIRED_SCOPE],
+    resourceMetadataUrl
+  });
+  const store = new RemoteTenantStore({ ...config, publicUrl: resourceUrl });
+  const handler = createMcpHandler(async ({ authInfo: authInfo2 }) => {
+    const identity = oauthIdentity(authInfo2);
+    const { subject, ownerDids } = identity;
+    const stateRoot = store.tenantStateRoot(subject);
+    const validator = createJsonSchemaValidator();
+    const server = new McpServer2(
+      { 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 = 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 = 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 = fromJsonSchema2({ type: "object", properties: {}, additionalProperties: false }, validator);
+  const outputSchema = fromJsonSchema2({
+    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}
+`);
+}
 export {
   MCP_SERVER_NAME,
   MCP_VERSION,
   TOOL_NAMES,
   canonicalMcpAdapterResult,
+  createHostedMcpApp,
   createTinyCloudMcpServer,
   main,
   parseCliOptions,