@cloudhal/mcp-server 0.0.0-stage → 0.1.0

package/dist/src/entry-terms.d.ts

@@ -0,0 +1,14 @@
+/** Term assignment input and audit deltas for entry writes (RFC-0002 §6.4). */
+import type { ContentEntry, Site } from "@cloudhal/core-contracts";
+import type { ToolContext } from "./common.js";
+/**
+ * The `terms` (and deprecated `tags`) input of create_entry / update_entry → the entry's new
+ * assignments and `tags`. `tags` is an alias for `terms.tag.add` on sites with a `tag` taxonomy; a
+ * site that has not been migrated (no `tag` taxonomy) keeps plain tags.
+ */
+export declare function entryTerms(ctx: ToolContext, site: Site, entry: ContentEntry | undefined, a: Record<string, unknown>): Promise<{
+    terms: ContentEntry["terms"];
+    tags: string[];
+}>;
+/** Assignment deltas of an entry write into the audit row (`input.effect.terms`). */
+export declare function reportDeltas(ctx: ToolContext, before: ContentEntry | undefined, after: ContentEntry): Promise<void>;

package/dist/src/entry-terms.js

@@ -0,0 +1,51 @@
+/** Term assignment input and audit deltas for entry writes (RFC-0002 §6.4). */
+
+                                                                   
+                                               
+import {
+  applyTermsInput,
+  assignmentDeltas,
+  auditDeltas,
+                  
+  termLookup,
+} from "./terms.js";
+
+/**
+ * The `terms` (and deprecated `tags`) input of create_entry / update_entry → the entry's new
+ * assignments and `tags`. `tags` is an alias for `terms.tag.add` on sites with a `tag` taxonomy; a
+ * site that has not been migrated (no `tag` taxonomy) keeps plain tags.
+ */
+export async function entryTerms(
+  ctx             ,
+  site      ,
+  entry                          ,
+  a                         ,
+)                                                            {
+  const input             = { ...((a.terms                          ) ?? {}) };
+  const aliased = a.tags                        ;
+  let tags = entry?.tags ?? [];
+  if (aliased !== undefined) {
+    if (await ctx.store.getTaxonomyByKey(site.id, "tag")) {
+      if (aliased.length > 0) {
+        const ops = input.tag ?? {};
+        input.tag = { ...ops, add: [...(ops.add ?? []), ...aliased] };
+      }
+    } else tags = aliased;
+  }
+  const terms =
+    Object.keys(input).length > 0
+      ? await applyTermsInput(ctx, site, entry?.terms, input)
+      : entry?.terms;
+  return { terms, tags };
+}
+
+/** Assignment deltas of an entry write into the audit row (`input.effect.terms`). */
+export async function reportDeltas(
+  ctx             ,
+  before                          ,
+  after              ,
+)                {
+  const deltas = assignmentDeltas(before?.terms, after.terms);
+  if (deltas.length > 0 && ctx.report)
+    ctx.report({ terms: await auditDeltas(deltas, termLookup(ctx)) });
+}

package/dist/src/entry-tools.d.ts

@@ -0,0 +1,4 @@
+/** Article (content entry) tools: list, read, create, update, correct and delete. */
+import { type ToolDefinition } from "./common.js";
+/** list_entries … delete_entry, in `tools/list` order. */
+export declare function entryTools(): ToolDefinition[];

package/dist/src/entry-tools.js

@@ -0,0 +1,442 @@
+/** Article (content entry) tools: list, read, create, update, correct and delete. */
+
+                                                                   
+                                                                    
+import {
+  autoSnapshot,
+  entryLimitCheck,
+  id,
+  mapError,
+  obj,
+  quote,
+  requireSite,
+  SLUG_PATTERN,
+  str,
+                      
+  ToolError,
+} from "./common.js";
+import {
+  COVER_INPUT,
+  coverImage,
+  ENTRY,
+  entryMarkdown,
+  mcpWriter,
+  SNAPSHOT,
+  unknownBlocks,
+  unknownBlocksOf,
+} from "./content-shared.js";
+import { entryTerms, reportDeltas } from "./entry-terms.js";
+import { menuHint, menuItemsHiddenBy } from "./menu-tools.js";
+import { assignmentDeltas, describeDeltas, TAGS_INPUT, TERMS_INPUT, termLookup } from "./terms.js";
+
+const listEntriesTool                 = {
+  name: "list_entries",
+  title: "List articles",
+  description:
+    'Content entries, newest first. `collection` defaults to posts (unless the filter names one). `filter` selects by terms (RFC-0002 grammar): clauses joined by "+" (AND), "[a,b]" = either, "-" = none of, "primary:category:x" = primary term, "category:x>*" = x or a sub-category, "collection:posts"; values are term slugs (old slugs work) or ids. Example: "category:news+tag:[ai,llm]+-tag:sponsored".',
+  inputSchema: obj(
+    {
+      siteId: id,
+      collection: str("Collection slug", { default: "posts", pattern: SLUG_PATTERN }),
+      filter: str("Filter over term assignments, e.g. category:news+tag:ai", {
+        minLength: 1,
+        maxLength: 512,
+      }),
+      locale: str("Only entries in this BCP 47 locale"),
+      status: {
+        type: "array",
+        description: "Only entries in these statuses",
+        items: { type: "string", enum: ["draft", "review", "published", "archived"] },
+        minItems: 1,
+        uniqueItems: true,
+      },
+    },
+    ["siteId"],
+  ),
+  outputSchema: obj({ entries: { type: "array", items: ENTRY } }, ["entries"]),
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+  },
+  scopes: ["content:read"],
+  handler: async (a, ctx) => {
+    await requireSite(ctx, a.siteId          );
+    const filter = a.filter                      ;
+    const collection =
+      (a.collection                      ) ??
+      (filter && /(^|\+)-?collection:/.test(filter) ? undefined : "posts");
+    const query             = {
+      ...(collection !== undefined ? { collection } : {}),
+      ...(filter !== undefined ? { filter } : {}),
+      ...(a.locale !== undefined ? { locale: a.locale           } : {}),
+      ...(a.status !== undefined ? { status: a.status                             } : {}),
+    };
+    try {
+      const entries = (await ctx.store.listContentEntries(a.siteId          , query)).sort((x, y) =>
+        y.updatedAt.localeCompare(x.updatedAt),
+      );
+      return { entries };
+    } catch (e) {
+      mapError(e);
+    }
+  },
+};
+
+const getEntryTool                 = {
+  name: "get_entry",
+  title: "Get article",
+  description: "One content entry with its body and current revision.",
+  inputSchema: obj({ siteId: id, entryId: id }, ["siteId", "entryId"]),
+  outputSchema: obj({ entry: ENTRY }, ["entry"]),
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+  },
+  scopes: ["content:read"],
+  handler: async (a, ctx) => {
+    const entry = await ctx.store.getContentEntry(a.entryId          );
+    if (!entry || entry.siteId !== a.siteId)
+      throw new ToolError("not_found", `entry ${a.entryId} not found`);
+    return { entry };
+  },
+};
+
+const createEntryTool                 = {
+  name: "create_entry",
+  title: "Create article",
+  description:
+    "Create a draft content entry (markdown body), optionally filed under existing terms (`terms`; see list_taxonomies and list_terms). Snapshots afterwards.",
+  inputSchema: obj(
+    {
+      siteId: id,
+      collection: str("Collection slug", { default: "posts", pattern: SLUG_PATTERN }),
+      slug: str("Lower-case hyphenated slug", { pattern: SLUG_PATTERN, maxLength: 128 }),
+      locale: str("BCP 47 locale; defaults to the site's default locale"),
+      title: str("Title"),
+      summary: str("One or two sentences"),
+      body: str(
+        "Markdown body. Media from the library: ![alt](asset:<assetId>) for images, [label](asset:<assetId>) for downloads.",
+      ),
+      terms: TERMS_INPUT,
+      tags: TAGS_INPUT,
+      coverImage: COVER_INPUT,
+      fields: { type: "object", description: "Collection-specific fields" },
+    },
+    ["siteId", "slug", "title", "body"],
+  ),
+  outputSchema: obj({ entry: ENTRY, snapshot: SNAPSHOT, hint: { type: "string" }, unknownBlocks }, [
+    "entry",
+    "snapshot",
+  ]),
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false,
+  },
+  scopes: ["content:write"],
+  own: "entry",
+  handler: async (a, ctx) => {
+    const site = await requireSite(ctx, a.siteId          );
+    await entryLimitCheck(ctx, "create", undefined, {
+      author: ctx.principal.actor,
+      status: "draft",
+    });
+    const { terms, tags } = await entryTerms(ctx, site, undefined, a);
+    try {
+      const entry = await ctx.store.createContentEntry(
+        {
+          siteId: site.id,
+          collection: (a.collection                      ) ?? "posts",
+          slug: a.slug          ,
+          locale: (a.locale                      ) ?? site.defaultLocale,
+          status: "draft",
+          title: a.title          ,
+          ...(a.summary ? { summary: a.summary           } : {}),
+          body: { format: "markdown", value: a.body           },
+          fields: (a.fields                                       ) ?? {},
+          tags,
+          ...(terms ? { terms } : {}),
+          ...(a.coverImage ? { coverImage: coverImage(a.coverImage) } : {}),
+          author: ctx.principal.actor,
+        },
+        { writer: mcpWriter(ctx) },
+      );
+      await reportDeltas(ctx, undefined, entry);
+      const snapshot = await autoSnapshot(ctx, site.id, "create_entry");
+      const hint = await menuHint(ctx, site.id, { kind: "contentEntry", id: entry.id });
+      return {
+        entry,
+        snapshot,
+        ...(hint ? { hint } : {}),
+        ...unknownBlocksOf(ctx, { markdown: entryMarkdown(entry) }),
+      };
+    } catch (e) {
+      mapError(e);
+    }
+  },
+};
+
+const updateEntryTool                 = {
+  name: "update_entry",
+  title: "Update article",
+  description:
+    "Update title, summary, body, slug, status (draft → review → published) or terms (`terms`: add, remove or set categories and tags by id, slug or name) of an entry. Review and published articles need a primary term in every required taxonomy. Requires the current `rev`. Changing a published article's slug leaves a redirect. Snapshots afterwards.",
+  inputSchema: obj(
+    {
+      siteId: id,
+      entryId: id,
+      rev: { type: "integer", minimum: 0 },
+      title: str("Title"),
+      summary: str("Summary"),
+      body: str("Markdown body"),
+      slug: str("Slug", { pattern: SLUG_PATTERN, maxLength: 128 }),
+      terms: TERMS_INPUT,
+      tags: TAGS_INPUT,
+      coverImage: {
+        ...COVER_INPUT,
+        type: ["object", "null"],
+        description: "Cover image; null removes it",
+      },
+      status: { type: "string", enum: ["draft", "review", "published", "archived"] },
+    },
+    ["siteId", "entryId", "rev"],
+  ),
+  outputSchema: obj({ entry: ENTRY, snapshot: SNAPSHOT, unknownBlocks }, ["entry", "snapshot"]),
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false,
+  },
+  scopes: ["content:write"],
+  own: "entry",
+  // Own-limited callers (Authors, Contributors and their agents) only touch their own articles.
+  precheck: async (a, ctx) => {
+    if (!ctx.limit) return;
+    const entry = await ctx.store.getContentEntry(a.entryId          );
+    if (!entry || entry.siteId !== a.siteId) return;
+    await entryLimitCheck(ctx, "update", entry, {
+      author: entry.author,
+      status: (a.status                                      ) ?? entry.status,
+    });
+  },
+  approvalPrompt: async (a, ctx) => {
+    const entry = await ctx.store.getContentEntry(a.entryId          );
+    if (!entry || entry.siteId !== a.siteId) return `Update article ${a.entryId}?`;
+    const site = await ctx.store.getSite(entry.siteId);
+    const changes = [
+      a.title ? `title → "${quote(a.title          )}"` : "",
+      a.summary !== undefined ? "summary" : "",
+      a.body !== undefined ? "body" : "",
+      a.slug && a.slug !== entry.slug
+        ? `slug ${entry.slug} → ${a.slug          }${entry.status === "published" || entry.publishedAt ? " (leaves a redirect)" : ""}`
+        : "",
+      a.status && a.status !== entry.status ? `status → ${a.status          }` : "",
+      a.coverImage !== undefined
+        ? a.coverImage === null
+          ? "remove cover image"
+          : "cover image"
+        : "",
+    ].filter(Boolean);
+    if (a.terms || a.tags) {
+      try {
+        const { terms } = await entryTerms(ctx, site        , entry, a);
+        const d = await describeDeltas(
+          assignmentDeltas(entry.terms, terms),
+          termLookup(ctx),
+          site?.defaultLocale,
+        );
+        if (d) changes.push(d);
+      } catch {
+        changes.push("terms");
+      }
+    }
+    return `Update article "${quote(entry.title)}"${changes.length ? ` (${changes.join(", ")})` : ""}?`;
+  },
+  handler: async (a, ctx) => {
+    const entry = await ctx.store.getContentEntry(a.entryId          );
+    if (!entry || entry.siteId !== a.siteId)
+      throw new ToolError("not_found", `entry ${a.entryId} not found`);
+    if (a.body !== undefined && entry.body.format !== "markdown")
+      throw new ToolError(
+        "invalid",
+        `entry ${entry.id} has an HTML body, which only a person can change in Studio; agents write markdown`,
+      );
+    if (entry.rev !== a.rev)
+      throw new ToolError(
+        "conflict",
+        `entry ${entry.id} is at rev ${entry.rev}, you sent ${a.rev}; reload and retry`,
+      );
+    const site = await requireSite(ctx, entry.siteId);
+    await entryLimitCheck(ctx, "update", entry, {
+      author: entry.author,
+      status: (a.status                                      ) ?? entry.status,
+    });
+    const { terms, tags } = await entryTerms(ctx, site, entry, a);
+    const { terms: _old, coverImage: oldCover, ...rest } = entry;
+    const cover =
+      a.coverImage === undefined
+        ? oldCover
+        : a.coverImage === null
+          ? undefined
+          : coverImage(a.coverImage);
+    const next               = {
+      ...rest,
+      ...(cover ? { coverImage: cover } : {}),
+      ...(a.title ? { title: a.title           } : {}),
+      ...(a.summary !== undefined ? { summary: a.summary           } : {}),
+      ...(a.body !== undefined ? { body: { ...entry.body, value: a.body           } } : {}),
+      ...(a.slug ? { slug: a.slug           } : {}),
+      tags,
+      ...(terms ? { terms } : {}),
+      ...(a.status ? { status: a.status                           } : {}),
+      ...(a.status === "published" && !entry.publishedAt
+        ? { publishedAt: new Date().toISOString() }
+        : {}),
+    };
+    try {
+      const saved = await ctx.store.updateContentEntry(next, { writer: mcpWriter(ctx) });
+      await reportDeltas(ctx, entry, saved);
+      const snapshot = await autoSnapshot(ctx, entry.siteId, "update_entry");
+      return {
+        entry: saved,
+        snapshot,
+        ...unknownBlocksOf(ctx, { markdown: entryMarkdown(saved) }),
+      };
+    } catch (e) {
+      mapError(e);
+    }
+  },
+};
+
+const addCorrectionTool                 = {
+  name: "add_correction",
+  title: "Add correction",
+  description:
+    "Append a correction, clarification or update notice to an article (RFC-0019 §2) when a published story changed in substance. Cloudhal sets its time. It goes live with the next publish, which then waits for a person in every mode. Once live, a notice cannot be removed or reworded by an agent. Snapshots afterwards.",
+  inputSchema: obj(
+    {
+      siteId: id,
+      entryId: id,
+      rev: { type: "integer", minimum: 0 },
+      kind: {
+        type: "string",
+        enum: ["correction", "clarification", "update"],
+        description:
+          "correction: something was wrong; clarification: something was unclear; update: new facts since publication",
+      },
+      note: str("What changed, in one or two sentences of markdown", {
+        minLength: 1,
+        maxLength: 2000,
+      }),
+    },
+    ["siteId", "entryId", "rev", "kind", "note"],
+  ),
+  outputSchema: obj({ entry: ENTRY, snapshot: SNAPSHOT }, ["entry", "snapshot"]),
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false,
+  },
+  scopes: ["content:write"],
+  own: "entry",
+  precheck: async (a, ctx) => {
+    if (!ctx.limit) return;
+    const entry = await ctx.store.getContentEntry(a.entryId          );
+    if (entry && entry.siteId === a.siteId)
+      await entryLimitCheck(ctx, "update", entry, {
+        author: entry.author,
+        status: entry.status,
+      });
+  },
+  approvalPrompt: async (a, ctx) => {
+    const entry = await ctx.store.getContentEntry(a.entryId          );
+    return `Add a ${a.kind          } to "${quote(entry?.title ?? (a.entryId          ))}": "${quote(a.note          )}"?`;
+  },
+  handler: async (a, ctx) => {
+    const entry = await ctx.store.getContentEntry(a.entryId          );
+    if (!entry || entry.siteId !== a.siteId)
+      throw new ToolError("not_found", `entry ${a.entryId} not found`);
+    if (entry.rev !== a.rev)
+      throw new ToolError(
+        "conflict",
+        `entry ${entry.id} is at rev ${entry.rev}, you sent ${a.rev}; reload and retry`,
+      );
+    await entryLimitCheck(ctx, "update", entry, { author: entry.author, status: entry.status });
+    try {
+      const saved = await ctx.store.addCorrection(
+        entry,
+        { kind: a.kind                  , note: a.note           },
+        { writer: mcpWriter(ctx) },
+      );
+      return {
+        entry: saved,
+        snapshot: await autoSnapshot(ctx, entry.siteId, "add_correction"),
+      };
+    } catch (e) {
+      mapError(e);
+    }
+  },
+};
+
+const deleteEntryTool                 = {
+  name: "delete_entry",
+  title: "Delete article",
+  description: "Delete a content entry. Destructive: requires approval. Snapshots afterwards.",
+  inputSchema: obj({ siteId: id, entryId: id, rev: { type: "integer", minimum: 0 } }, [
+    "siteId",
+    "entryId",
+    "rev",
+  ]),
+  outputSchema: obj({ snapshot: SNAPSHOT }, ["snapshot"]),
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false,
+  },
+  scopes: ["content:write"],
+  own: "entry",
+  precheck: async (a, ctx) => {
+    if (!ctx.limit) return;
+    const entry = await ctx.store.getContentEntry(a.entryId          );
+    if (entry && entry.siteId === a.siteId) await entryLimitCheck(ctx, "delete", entry);
+  },
+  approvalPrompt: async (a, ctx) => {
+    const entry = await ctx.store.getContentEntry(a.entryId          );
+    const menus = entry
+      ? await menuItemsHiddenBy(ctx, entry.siteId, { kind: "contentEntry", id: entry.id })
+      : "";
+    return `Delete article "${entry?.title ?? a.entryId}"? Earlier snapshots keep a copy.${menus}`;
+  },
+  handler: async (a, ctx) => {
+    const entry = await ctx.store.getContentEntry(a.entryId          );
+    if (!entry || entry.siteId !== a.siteId)
+      throw new ToolError("not_found", `entry ${a.entryId} not found`);
+    await entryLimitCheck(ctx, "delete", entry);
+    try {
+      await ctx.store.deleteContentEntry({ ...entry, rev: a.rev           });
+      return { snapshot: await autoSnapshot(ctx, entry.siteId, "delete_entry") };
+    } catch (e) {
+      mapError(e);
+    }
+  },
+};
+
+/** list_entries … delete_entry, in `tools/list` order. */
+export function entryTools()                   {
+  return [
+    listEntriesTool,
+    getEntryTool,
+    createEntryTool,
+    updateEntryTool,
+    addCorrectionTool,
+    deleteEntryTool,
+  ];
+}

package/dist/src/http.d.ts

@@ -0,0 +1,48 @@
+/**
+ * HTTP transport (web-standard `fetch`): stateless, one server instance per request, so it runs
+ * unchanged on Node (behind the Hono API) and on Cloudflare Workers. The caller authenticates the
+ * request and hands over the resolved `Principal`; this module never reads credentials itself.
+ */
+import type { ApprovalStore, AuditLog, LoadedSkill, OwnershipResolver, Principal } from "@cloudhal/agent-runtime";
+import type { AnalyticsService } from "@cloudhal/analytics/service";
+import type { SiteGraphStore } from "@cloudhal/core-ts";
+import type { CommentsDeps } from "./comments.js";
+import type { BuildObserver, MediaToolOptions, RenderDeps } from "./common.js";
+import type { SchedulesDeps } from "./schedules.js";
+export interface HttpOptions {
+    store: SiteGraphStore;
+    /** Clock for time-based answers (`get_mode`); tests inject one. */
+    now?: (() => Date) | undefined;
+    audit?: AuditLog | undefined;
+    skills?: LoadedSkill[] | undefined;
+    previewBaseUrl?: string | undefined;
+    previewSecret?: string | undefined;
+    /** Media settings for the asset tools (RFC-0004). */
+    media?: MediaToolOptions | undefined;
+    /** Site analytics for the read-only analytics tools (RFC-0006 §9.3). */
+    analytics?: AnalyticsService | undefined;
+    /** Reader comments for the comment tools (RFC-0007 §11). */
+    comments?: CommentsDeps | undefined;
+    /** Schedules for the schedule tools and automation runs (RFC-0008 §12). */
+    schedules?: SchedulesDeps | undefined;
+    /** A browser for `render_page` (RFC-0021 §4). */
+    render?: RenderDeps | undefined;
+    /** Shared secret (≥ 32 bytes) so approval state survives across instances/requests. */
+    stateKey: Uint8Array | string;
+    /** Told about page writes and refused builds (RFC-0020 §6, Studio's Build view). */
+    build?: BuildObserver | undefined;
+    confirmTokenFallback?: boolean | undefined;
+    /** Out-of-band approvals: agents' gated calls wait for a person in Studio (ADR-0014). */
+    approvals?: ApprovalStore | undefined;
+    /** Who owns what: the person behind an agent's key (RFC-0005 §4). */
+    ownership?: OwnershipResolver | undefined;
+    /** `"reject"` refuses 2025-era clients (strict, ADR-0004); default serves them statelessly. */
+    legacy?: "stateless" | "reject" | undefined;
+    onerror?: ((error: Error) => void) | undefined;
+}
+export interface CloudhalMcpHttp {
+    /** Serves one MCP request for an already-authenticated principal. */
+    fetch(request: Request, principal: Principal): Promise<Response>;
+    close(): Promise<void>;
+}
+export declare function createCloudhalMcpHandler(options: HttpOptions): CloudhalMcpHttp;

package/dist/src/http.js

@@ -0,0 +1,101 @@
+/**
+ * HTTP transport (web-standard `fetch`): stateless, one server instance per request, so it runs
+ * unchanged on Node (behind the Hono API) and on Cloudflare Workers. The caller authenticates the
+ * request and hands over the resolved `Principal`; this module never reads credentials itself.
+ */
+             
+                
+           
+              
+                    
+            
+                                 
+                                                                    
+                                                        
+import { createMcpHandler,                     } from "@modelcontextprotocol/server";
+                                                  
+                                                                               
+                                                    
+import { createCloudhalMcpServer } from "./server.js";
+
+                              
+                        
+                                                                     
+                                 
+                               
+                                     
+                                      
+                                     
+                                                       
+                                       
+                                                                          
+                                           
+                                                              
+                                      
+                                                                             
+                                        
+                                                   
+                                  
+                                                                                         
+                                
+                                                                                      
+                                    
+                                             
+                                                                                           
+                                        
+                                                                       
+                                            
+                                                                                                 
+                                              
+                                                 
+ 
+
+                                  
+                                                                       
+                                                                   
+                         
+ 
+
+export function createCloudhalMcpHandler(options             )                  {
+  const handler                 = createMcpHandler(
+    (ctx) => {
+      const principal = ctx.authInfo?.extra?.principal                         ;
+      if (!principal) throw new Error("mcp handler called without a principal");
+      return createCloudhalMcpServer({
+        store: options.store,
+        principal,
+        audit: options.audit,
+        skills: options.skills,
+        previewBaseUrl: options.previewBaseUrl,
+        previewSecret: options.previewSecret,
+        build: options.build,
+        media: options.media,
+        analytics: options.analytics,
+        comments: options.comments,
+        schedules: options.schedules,
+        render: options.render,
+        now: options.now,
+        stateKey: options.stateKey,
+        confirmTokenFallback: options.confirmTokenFallback,
+        approvals: options.approvals,
+        ownership: options.ownership,
+      });
+    },
+    {
+      ...(options.legacy ? { legacy: options.legacy } : {}),
+      ...(options.onerror ? { onerror: options.onerror } : {}),
+    },
+  );
+  return {
+    fetch: (request, principal) =>
+      handler.fetch(request, {
+        authInfo: {
+          token: "",
+          clientId: principal.actor.id,
+          scopes: principal.scopes,
+          extra: { principal },
+        },
+      }),
+    close: () => handler.close(),
+  };
+}

package/dist/src/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @cloudhal/mcp-server — the semantic tool surface agents use (ADR-0004, ADR-0011).
+ * `tools.ts` is SDK-independent; `server.ts` wraps it in `@modelcontextprotocol/server`;
+ * `stdio.ts` / `http.ts` are the transports.
+ */
+export * from "./http.js";
+export * from "./preview-view.js";
+export * from "./server.js";
+export * from "./stdio.js";
+export * from "./tools.js";

package/dist/src/index.js

@@ -0,0 +1,10 @@
+/**
+ * @cloudhal/mcp-server — the semantic tool surface agents use (ADR-0004, ADR-0011).
+ * `tools.ts` is SDK-independent; `server.ts` wraps it in `@modelcontextprotocol/server`;
+ * `stdio.ts` / `http.ts` are the transports.
+ */
+export * from "./http.js";
+export * from "./preview-view.js";
+export * from "./server.js";
+export * from "./stdio.js";
+export * from "./tools.js";