@sidecar-ai/cli 0.1.0-alpha.0

package/dist/index.js

@@ -0,0 +1,4922 @@
+#!/usr/bin/env node
+
+// packages/cli/src/index.ts
+import { existsSync as existsSync5, realpathSync } from "fs";
+import { mkdir as mkdir9, readFile as readFile8, writeFile as writeFile9 } from "fs/promises";
+import { createServer as createServer2 } from "http";
+import path18 from "path";
+import { createInterface as createInterface2 } from "readline/promises";
+import { fileURLToPath, pathToFileURL } from "url";
+import { cwd, exit, stdin as stdin2, stdout as stdout2 } from "process";
+import { tsImport } from "tsx/esm/api";
+
+// packages/auth/src/core.ts
+var authBrand = /* @__PURE__ */ Symbol.for("sidecar.auth");
+function isSidecarAuth(value) {
+  return Boolean(
+    value && typeof value === "object" && value[authBrand]
+  );
+}
+
+// packages/core/src/index.ts
+var MCP_APP_RESOURCE_MIME_TYPE = "text/html;profile=mcp-app";
+var toolBrand = /* @__PURE__ */ Symbol.for("sidecar.tool");
+var toolResultBrand = /* @__PURE__ */ Symbol.for("sidecar.toolResult");
+var resourceBrand = /* @__PURE__ */ Symbol.for("sidecar.resource");
+var resourceResultBrand = /* @__PURE__ */ Symbol.for("sidecar.resourceResult");
+var promptBrand = /* @__PURE__ */ Symbol.for("sidecar.prompt");
+function isSidecarTool(value) {
+  return Boolean(value && typeof value === "object" && value[toolBrand]);
+}
+function isSidecarResource(value) {
+  return Boolean(value && typeof value === "object" && value[resourceBrand]);
+}
+function isSidecarPrompt(value) {
+  return Boolean(value && typeof value === "object" && value[promptBrand]);
+}
+var toolResult = Object.assign(
+  createToolResult,
+  {
+    text(text) {
+      return { type: "text", text };
+    },
+    error(message, options = {}) {
+      return createToolResult({
+        ...options,
+        structuredContent: options.structuredContent,
+        content: message,
+        isError: true
+      });
+    }
+  }
+);
+var resourceResult = Object.assign(
+  createResourceResult,
+  {
+    many(input) {
+      return createResourceResult(input);
+    }
+  }
+);
+function createToolResult(input) {
+  const resultEnvelope = stripUndefined({
+    structuredContent: input.structuredContent,
+    content: normalizeRequiredContent(input.content),
+    _meta: input.meta,
+    isError: input.isError
+  });
+  Object.defineProperty(resultEnvelope, toolResultBrand, {
+    enumerable: false,
+    value: true
+  });
+  return resultEnvelope;
+}
+function createResourceResult(input) {
+  const contents = Array.isArray(input) ? [...input] : [input];
+  if (!contents.length) {
+    throw new SidecarRuntimeError(
+      "resourceResult(...) must include at least one content item.",
+      "invalid_resource_result"
+    );
+  }
+  const resultEnvelope = {
+    contents
+  };
+  Object.defineProperty(resultEnvelope, resourceResultBrand, {
+    enumerable: false,
+    value: true
+  });
+  return resultEnvelope;
+}
+function isToolResult(value) {
+  return Boolean(
+    value && typeof value === "object" && value[toolResultBrand] === true
+  );
+}
+function isResourceResult(value) {
+  return Boolean(
+    value && typeof value === "object" && value[resourceResultBrand] === true
+  );
+}
+function normalizeToolResult(value) {
+  if (!isToolResult(value)) {
+    throw new SidecarRuntimeError(
+      "Tool execute() must return toolResult({ structuredContent, content, meta }).",
+      "invalid_tool_result"
+    );
+  }
+  return stripUndefined({
+    structuredContent: value.structuredContent,
+    content: value.content ?? [],
+    _meta: value._meta,
+    isError: value.isError
+  });
+}
+function normalizeResourceResult(value, uri, defaultMimeType) {
+  if (!isResourceResult(value)) {
+    throw new SidecarRuntimeError(
+      "Resource read() must return resourceResult(...).",
+      "invalid_resource_result"
+    );
+  }
+  return {
+    contents: value.contents.map(
+      (content) => normalizeResourceContent(content, uri, defaultMimeType)
+    )
+  };
+}
+async function executeTool(sidecarTool, params, ctx) {
+  const parsedParams = validateParams(sidecarTool, params);
+  const value = await sidecarTool.execute(parsedParams, ctx);
+  return normalizeToolResult(value);
+}
+async function executeResource(sidecarResource, ctx, options) {
+  const value = await sidecarResource.read(ctx);
+  return normalizeResourceResult(value, options.uri, sidecarResource.mimeType ?? options.mimeType);
+}
+async function executePrompt(sidecarPrompt, args, ctx) {
+  const parsedArgs = validatePromptArgs(sidecarPrompt, args);
+  const value = await sidecarPrompt.run(parsedArgs, ctx);
+  return normalizePromptResult(value, sidecarPrompt.description);
+}
+function createToolDescriptor(definition) {
+  const machineName = definition.id ?? toMachineName(definition.name);
+  validateToolId(machineName);
+  const target = definition.target ?? "mcp";
+  return stripUndefined({
+    name: machineName,
+    title: definition.name,
+    description: definition.description,
+    inputSchema: definition.inputSchema ?? emptyObjectSchema(),
+    outputSchema: definition.outputSchema,
+    securitySchemes: securitySchemes(definition.auth),
+    annotations: withAnnotationDefaults(definition.annotations),
+    _meta: mergeMeta(
+      securitySchemesMeta(definition.auth),
+      visibilityMeta(definition.visibility),
+      target === "chatgpt" ? chatGptToolMeta(definition.hosts?.chatgpt) : void 0,
+      definition.meta
+    )
+  });
+}
+function createResourceDescriptor(definition) {
+  validateResourceUri(definition.uri);
+  return stripUndefined({
+    uri: definition.uri,
+    name: definition.name,
+    title: definition.title,
+    description: definition.description,
+    mimeType: definition.mimeType,
+    size: definition.size,
+    icons: definition.icons ? [...definition.icons] : void 0,
+    annotations: normalizeAnnotations(definition.annotations),
+    _meta: definition.meta
+  });
+}
+function createPromptDescriptor(definition) {
+  validatePromptName(definition.name);
+  return stripUndefined({
+    name: definition.name,
+    title: definition.title,
+    description: definition.description,
+    arguments: promptArguments(definition.args),
+    icons: definition.icons ? [...definition.icons] : void 0
+  });
+}
+function securitySchemes(policy) {
+  if (!policy || policy.public === true) {
+    return [{ type: "noauth" }];
+  }
+  if ("scopes" in policy && policy.scopes?.length) {
+    return [{ type: "oauth2", scopes: policy.scopes.map((entry) => entry.id) }];
+  }
+  return [{ type: "oauth2", scopes: [] }];
+}
+function securitySchemesMeta(policy) {
+  return {
+    securitySchemes: securitySchemes(policy)
+  };
+}
+function visibilityMeta(visibility) {
+  if (!visibility) {
+    return void 0;
+  }
+  const uiVisibility = [
+    visibility.model !== false ? "model" : void 0,
+    visibility.widgets !== false ? "app" : void 0
+  ].filter(Boolean);
+  return {
+    ui: {
+      visibility: uiVisibility
+    }
+  };
+}
+function chatGptToolMeta(options) {
+  if (!options) {
+    return void 0;
+  }
+  return stripUndefined({
+    "openai/widgetAccessible": options.widgetAccessible,
+    "openai/visibility": options.visibility,
+    "openai/toolInvocation/invoking": options.invoking,
+    "openai/toolInvocation/invoked": options.invoked,
+    "openai/fileParams": options.fileParams ? [...options.fileParams] : void 0
+  });
+}
+function mergeMeta(...entries) {
+  const merged = {};
+  for (const entry of entries) {
+    if (!entry) {
+      continue;
+    }
+    for (const [key, value] of Object.entries(entry)) {
+      if (key === "ui" && isRecord(value) && isRecord(merged.ui)) {
+        merged.ui = { ...merged.ui, ...value };
+      } else {
+        merged[key] = value;
+      }
+    }
+  }
+  return Object.keys(merged).length ? stripUndefined(merged) : void 0;
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function emptyObjectSchema() {
+  return {
+    type: "object",
+    properties: {},
+    required: [],
+    additionalProperties: false
+  };
+}
+function toMachineName(name) {
+  return name.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^A-Za-z0-9._-]+/g, "_").replace(/^_+|_+$/g, "").replace(/_{2,}/g, "_").toLowerCase();
+}
+function validateToolId(id) {
+  if (!/^[A-Za-z0-9._-]{1,128}$/.test(id) || id === "." || id === ".." || id.includes("/..") || id.includes("../")) {
+    throw new SidecarDefinitionError(
+      `Invalid tool id "${id}". Tool ids must be 1-128 ASCII letters, digits, dots, hyphens, or underscores.`
+    );
+  }
+}
+function validateResourceUri(uri) {
+  try {
+    const parsed = new URL(uri);
+    if (!parsed.protocol || parsed.hash) {
+      throw new Error("invalid uri");
+    }
+  } catch {
+    throw new SidecarDefinitionError(
+      `Invalid resource uri "${uri}". Resource URIs must be absolute and must not include fragments.`
+    );
+  }
+}
+function validatePromptName(name) {
+  if (!/^[A-Za-z0-9._-]{1,128}$/.test(name) || name === "." || name === "..") {
+    throw new SidecarDefinitionError(
+      `Invalid prompt name "${name}". Prompt names must be 1-128 ASCII letters, digits, dots, hyphens, or underscores.`
+    );
+  }
+}
+function withAnnotationDefaults(annotations) {
+  const readOnlyHint = annotations?.readOnlyHint ?? false;
+  return {
+    title: annotations?.title,
+    readOnlyHint,
+    destructiveHint: annotations?.destructiveHint ?? !readOnlyHint,
+    idempotentHint: annotations?.idempotentHint ?? false,
+    openWorldHint: annotations?.openWorldHint ?? true
+  };
+}
+var SidecarDefinitionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SidecarDefinitionError";
+  }
+};
+var SidecarRuntimeError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "SidecarRuntimeError";
+  }
+  code;
+};
+function validateParams(sidecarTool, params) {
+  if (!sidecarTool.params) {
+    return params ?? {};
+  }
+  const parsed = sidecarTool.params.safeParse(params ?? {});
+  if (parsed.success) {
+    return parsed.data;
+  }
+  throw new SidecarRuntimeError(`Invalid parameters for tool "${sidecarTool.name}".`, "invalid_tool_params");
+}
+function normalizeRequiredContent(content) {
+  if (typeof content === "string") {
+    return [toolResult.text(content)];
+  }
+  const blocks = Array.isArray(content) ? content : [content];
+  if (blocks.length > 0) {
+    return blocks;
+  }
+  throw new SidecarRuntimeError(
+    "toolResult({ content }) must include at least one MCP content block.",
+    "invalid_tool_result"
+  );
+}
+function normalizeResourceContent(content, uri, defaultMimeType) {
+  const annotations = normalizeAnnotations(content.annotations);
+  const meta = content.meta;
+  if (isBinaryLike(content.content)) {
+    return stripUndefined({
+      uri,
+      mimeType: content.mimeType ?? defaultMimeType ?? "application/octet-stream",
+      blob: bytesToBase64(content.content),
+      annotations,
+      _meta: meta
+    });
+  }
+  if (typeof content.content === "string") {
+    return stripUndefined({
+      uri,
+      mimeType: content.mimeType ?? defaultMimeType ?? "text/plain",
+      text: content.content,
+      annotations,
+      _meta: meta
+    });
+  }
+  return stripUndefined({
+    uri,
+    mimeType: content.mimeType ?? defaultMimeType ?? "application/json",
+    text: JSON.stringify(content.content),
+    annotations,
+    _meta: meta
+  });
+}
+function isBinaryLike(value) {
+  return value instanceof ArrayBuffer || value instanceof Uint8Array;
+}
+function bytesToBase64(value) {
+  const bytes = value instanceof ArrayBuffer ? new Uint8Array(value) : value;
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+}
+function normalizeAnnotations(annotations) {
+  if (!annotations) {
+    return void 0;
+  }
+  return stripUndefined({
+    audience: annotations.audience ? [...annotations.audience] : void 0,
+    priority: annotations.priority,
+    lastModified: annotations.lastModified instanceof Date ? annotations.lastModified.toISOString() : annotations.lastModified
+  });
+}
+function promptArguments(args) {
+  if (!args) {
+    return void 0;
+  }
+  const entries = Object.entries(args).map(([name, value]) => {
+    if (typeof value === "string") {
+      return { name, description: value, required: true };
+    }
+    if (isReadonlyArray(value)) {
+      return {
+        name,
+        description: value.length ? `One of: ${value.map(String).join(", ")}.` : void 0,
+        required: true
+      };
+    }
+    return {
+      name,
+      description: value.description,
+      required: value.required ?? true
+    };
+  });
+  return entries.length ? entries : void 0;
+}
+function isReadonlyArray(value) {
+  return Array.isArray(value);
+}
+function validatePromptArgs(promptDefinition, args) {
+  const input = args && typeof args === "object" && !Array.isArray(args) ? args : {};
+  for (const argument of promptArguments(promptDefinition.args) ?? []) {
+    if (argument.required !== false && !(argument.name in input)) {
+      throw new SidecarRuntimeError(
+        `Prompt "${promptDefinition.name ?? promptDefinition.title}" is missing required argument "${argument.name}".`,
+        "invalid_prompt_args"
+      );
+    }
+  }
+  return input;
+}
+function normalizePromptResult(value, defaultDescription) {
+  if (typeof value === "string") {
+    return {
+      description: defaultDescription,
+      messages: [{
+        role: "user",
+        content: toolResult.text(value)
+      }]
+    };
+  }
+  if (Array.isArray(value)) {
+    return {
+      description: defaultDescription,
+      messages: value
+    };
+  }
+  if ("messages" in value) {
+    return {
+      description: value.description ?? defaultDescription,
+      messages: value.messages
+    };
+  }
+  return {
+    description: defaultDescription,
+    messages: [value]
+  };
+}
+function stripUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
+
+// packages/compiler/src/analyze.ts
+import { readdir } from "fs/promises";
+import path4 from "path";
+import {
+  Node as Node4,
+  SyntaxKind as SyntaxKind2
+} from "ts-morph";
+
+// packages/compiler/src/ast.ts
+import {
+  Node
+} from "ts-morph";
+function resolveDefaultExportCall(sourceFile, helperName) {
+  const exportAssignment = sourceFile.getExportAssignment(
+    (assignment) => !assignment.isExportEquals()
+  );
+  const expression = unwrapExpression(exportAssignment?.getExpression());
+  const direct = asHelperCall(expression, helperName);
+  if (direct) {
+    return direct;
+  }
+  if (!expression || !Node.isIdentifier(expression)) {
+    return void 0;
+  }
+  const declaration = findVariableDeclaration(sourceFile, expression.getText());
+  const initializer = unwrapExpression(declaration?.getInitializer());
+  return asHelperCall(initializer, helperName);
+}
+function unwrapExpression(expression) {
+  if (!expression) {
+    return void 0;
+  }
+  if (Node.isSatisfiesExpression(expression) || Node.isAsExpression(expression)) {
+    return expression.getExpression();
+  }
+  return expression;
+}
+function asHelperCall(expression, helperName) {
+  if (!expression || !Node.isCallExpression(expression)) {
+    return void 0;
+  }
+  const callee = expression.getExpression().getText();
+  return matchesHelperName(callee, helperName) ? expression : void 0;
+}
+function findVariableDeclaration(sourceFile, name) {
+  return sourceFile.getVariableDeclarations().find((declaration) => declaration.getName() === name);
+}
+function matchesHelperName(callee, helperName) {
+  return callee === helperName || callee.endsWith(`.${helperName}`);
+}
+
+// packages/compiler/src/errors.ts
+var CompilerError = class extends Error {
+  constructor(sourceFile, message) {
+    super(`${sourceFile.getFilePath()}: ${message}`);
+    this.name = "CompilerError";
+  }
+};
+
+// packages/compiler/src/project.ts
+import path2 from "path";
+import {
+  ModuleKind,
+  ModuleResolutionKind,
+  Project,
+  ScriptTarget
+} from "ts-morph";
+
+// packages/compiler/src/utils.ts
+import { existsSync } from "fs";
+import path from "path";
+function existsSyncSafe(filePath) {
+  return existsSync(filePath);
+}
+function toImportSpecifier(fromDir, toFile, options = {}) {
+  const relative = path.relative(fromDir, toFile).replaceAll(path.sep, "/");
+  const normalized = relative.startsWith(".") ? relative : `./${relative}`;
+  switch (options.extension ?? "none") {
+    case "js":
+      return normalized.replace(/\.(tsx|ts)$/, ".js");
+    case "preserve":
+      return normalized;
+    case "none":
+      return normalized.replace(/\.(tsx|ts)$/, "");
+  }
+}
+function toIdentifier(value) {
+  const identifier = value.replace(/[^A-Za-z0-9]+(.)/g, (_match, char) => char.toUpperCase()).replace(/^[^A-Za-z_$]+/, "").replace(/[^A-Za-z0-9_$]/g, "");
+  return identifier || "tool";
+}
+function safePathSegment(value) {
+  const segment = value.replace(/[^A-Za-z0-9._-]+/g, "_");
+  if (!segment || segment === "." || segment === "..") {
+    return "_";
+  }
+  return segment;
+}
+function safeFileStem(value) {
+  return safePathSegment(value).replace(/^\.+/, "_").replace(/^_+/, "_");
+}
+function yamlScalar(value) {
+  return JSON.stringify(String(value ?? ""));
+}
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function stripUndefined2(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, entry]) => entry !== void 0)
+  );
+}
+function readObjectString(source, key) {
+  const match = source.match(
+    new RegExp(`${key}\\s*:\\s*(["'\`])([\\s\\S]*?)\\1`)
+  );
+  return match?.[2]?.trim();
+}
+function readObjectStringArray(source, key) {
+  const match = source.match(new RegExp(`${key}\\s*:\\s*\\[([\\s\\S]*?)\\]`));
+  if (!match?.[1]) {
+    return void 0;
+  }
+  return [...match[1].matchAll(/["']([^"']+)["']/g)].map((item) => item[1]).filter(Boolean);
+}
+
+// packages/compiler/src/project.ts
+function createProject(rootDir) {
+  const tsconfig = path2.join(rootDir, "tsconfig.json");
+  return new Project({
+    tsConfigFilePath: existsSyncSafe(tsconfig) ? tsconfig : void 0,
+    compilerOptions: existsSyncSafe(tsconfig) ? void 0 : {
+      allowJs: false,
+      baseUrl: process.cwd(),
+      esModuleInterop: true,
+      module: ModuleKind.NodeNext,
+      moduleResolution: ModuleResolutionKind.NodeNext,
+      paths: devSidecarTypePaths(),
+      strict: true,
+      target: ScriptTarget.ES2022
+    },
+    skipAddingFilesFromTsConfig: true
+  });
+}
+function devSidecarTypePaths() {
+  const repoRoot = process.cwd();
+  const corePath = path2.join(repoRoot, "packages", "core", "src", "index.ts");
+  if (!existsSyncSafe(corePath)) {
+    return void 0;
+  }
+  return {
+    "sidecar-ai": ["packages/sidecar-ai/src/index.ts"],
+    "@sidecar-ai/core": ["packages/core/src/index.ts"],
+    "@sidecar-ai/client": ["packages/client/src/index.ts"],
+    "@sidecar-ai/react": ["packages/react/src/index.ts"],
+    "@sidecar-ai/native": ["packages/native/src/index.ts"],
+    "@sidecar-ai/native/components": ["packages/native/src/components/index.tsx"],
+    "@sidecar-ai/openai": ["packages/openai/src/index.ts"],
+    "@sidecar-ai/openai/components": ["packages/openai/src/components.tsx"],
+    "@sidecar-ai/anthropic": ["packages/anthropic/src/index.ts"],
+    "@sidecar-ai/anthropic/components": ["packages/anthropic/src/components.tsx"],
+    "@sidecar-ai/anthropic/plugin": ["packages/anthropic/src/plugin.ts"],
+    "@sidecar-ai/anthropic/hooks": ["packages/anthropic/src/hooks.ts"]
+  };
+}
+
+// packages/compiler/src/schema.ts
+import {
+  Node as Node2
+} from "ts-morph";
+function getParamsSchema(definition, execute) {
+  const explicitParams = definition.getProperty("params");
+  if (explicitParams && Node2.isPropertyAssignment(explicitParams)) {
+    const inferred = getSchemaFromZodProperty(explicitParams);
+    if (inferred) {
+      return inferred;
+    }
+  }
+  const [params] = execute.getParameters();
+  if (!params) {
+    return emptyObjectSchema();
+  }
+  return typeToJsonSchema(
+    params.getType(),
+    schemaDescription(params.getSymbol())
+  );
+}
+function getOutputSchema(definition, execute) {
+  const explicitOutput = definition.getProperty("output");
+  if (explicitOutput && Node2.isPropertyAssignment(explicitOutput)) {
+    return void 0;
+  }
+  const returnType = unwrapToolResultType(unwrapPromiseType(execute.getReturnType()));
+  if (returnType.isVoid() || returnType.isUndefined()) {
+    return void 0;
+  }
+  return typeToJsonSchema(returnType);
+}
+function getSchemaFromZodProperty(property) {
+  const initializer = property.getInitializer();
+  if (!initializer) {
+    return void 0;
+  }
+  if (Node2.isCallExpression(initializer) && initializer.getExpression().getText().endsWith(".object")) {
+    const [shape] = initializer.getArguments();
+    if (shape && Node2.isObjectLiteralExpression(shape)) {
+      return zodObjectLiteralToSchema(shape);
+    }
+  }
+  return void 0;
+}
+function zodObjectLiteralToSchema(shape) {
+  const properties = {};
+  const required = [];
+  for (const property of shape.getProperties()) {
+    if (!Node2.isPropertyAssignment(property)) {
+      continue;
+    }
+    const name = property.getName().replace(/^["']|["']$/g, "");
+    const initializer = property.getInitializer();
+    if (!initializer) {
+      continue;
+    }
+    const propertySchema = zodExpressionToSchema(initializer);
+    properties[name] = propertySchema.schema;
+    if (!propertySchema.optional) {
+      required.push(name);
+    }
+  }
+  return {
+    type: "object",
+    properties,
+    required,
+    additionalProperties: false
+  };
+}
+function zodExpressionToSchema(expression) {
+  const text = expression.getText();
+  const optional = /\.optional\(\)/.test(text) || /\.default\(/.test(text);
+  const schema = {};
+  if (/z\.string\(\)/.test(text)) {
+    schema.type = "string";
+  } else if (/z\.number\(\)/.test(text)) {
+    schema.type = "number";
+  } else if (/z\.boolean\(\)/.test(text)) {
+    schema.type = "boolean";
+  } else if (/z\.array\(/.test(text)) {
+    schema.type = "array";
+    schema.items = {};
+  } else {
+    schema.type = "object";
+  }
+  const min = text.match(/\.min\((\d+)/);
+  const max = text.match(/\.max\((\d+)/);
+  if (schema.type === "string") {
+    if (min) schema.minLength = Number(min[1]);
+    if (max) schema.maxLength = Number(max[1]);
+  } else {
+    if (min) schema.minimum = Number(min[1]);
+    if (max) schema.maximum = Number(max[1]);
+  }
+  if (/\.int\(\)/.test(text)) {
+    schema.type = "integer";
+  }
+  return { schema, optional };
+}
+function typeToJsonSchema(type, description) {
+  const withoutUndefined = removeUndefined(type);
+  const schema = typeToJsonSchemaInner(withoutUndefined);
+  if (description) {
+    schema.description = description;
+  }
+  return schema;
+}
+function typeToJsonSchemaInner(type) {
+  if (type.isString() || type.isStringLiteral()) {
+    return literalOrPrimitive(type, "string");
+  }
+  if (type.isNumber() || type.isNumberLiteral()) {
+    return literalOrPrimitive(type, "number");
+  }
+  if (type.isBoolean() || type.isBooleanLiteral()) {
+    return literalOrPrimitive(type, "boolean");
+  }
+  if (type.isNull()) {
+    return { type: "null" };
+  }
+  if (type.isArray()) {
+    return {
+      type: "array",
+      items: typeToJsonSchema(type.getArrayElementTypeOrThrow())
+    };
+  }
+  if (type.isTuple()) {
+    const elements = type.getTupleElements();
+    return {
+      type: "array",
+      items: elements.length === 1 ? typeToJsonSchema(elements[0]) : { anyOf: elements.map((item) => typeToJsonSchema(item)) }
+    };
+  }
+  if (type.isUnion()) {
+    const parts = type.getUnionTypes().filter((part) => !part.isUndefined());
+    if (parts.every(isLiteralType)) {
+      return { enum: parts.map((part) => literalValue(part)) };
+    }
+    return { anyOf: parts.map((part) => typeToJsonSchema(part)) };
+  }
+  const properties = type.getProperties();
+  if (properties.length > 0) {
+    return objectTypeToSchema(properties);
+  }
+  return {};
+}
+function objectTypeToSchema(properties) {
+  const schemaProperties = {};
+  const required = [];
+  for (const property of properties) {
+    const declaration = property.getValueDeclaration() ?? property.getDeclarations()[0];
+    if (!declaration) {
+      continue;
+    }
+    const name = property.getName();
+    const rawType = property.getTypeAtLocation(declaration);
+    const propertyType = removeUndefined(rawType);
+    const propertySchema = typeToJsonSchema(
+      propertyType,
+      schemaDescription(property)
+    );
+    schemaProperties[name] = propertySchema;
+    if (!property.isOptional() && !containsUndefined(rawType)) {
+      required.push(name);
+    }
+  }
+  return {
+    type: "object",
+    properties: schemaProperties,
+    required,
+    additionalProperties: false
+  };
+}
+function literalOrPrimitive(type, primitive) {
+  if (isLiteralType(type)) {
+    return { const: literalValue(type) };
+  }
+  return { type: primitive };
+}
+function isLiteralType(type) {
+  return type.isStringLiteral() || type.isNumberLiteral() || type.isBooleanLiteral();
+}
+function literalValue(type) {
+  if (type.isStringLiteral()) return String(type.getLiteralValue());
+  if (type.isNumberLiteral()) return Number(type.getLiteralValue());
+  const text = type.getText();
+  return text === "true";
+}
+function unwrapPromiseType(type) {
+  if (!type.getText().startsWith("Promise<")) {
+    return type;
+  }
+  const args = type.getTypeArguments();
+  return args[0] ?? type;
+}
+function unwrapToolResultType(type) {
+  const aliasName = type.getAliasSymbol()?.getName();
+  if (aliasName === "ToolResult") {
+    const [structured2] = type.getAliasTypeArguments();
+    return structured2 ?? type;
+  }
+  const structured = type.getProperty("structuredContent");
+  const declaration = structured?.getValueDeclaration() ?? structured?.getDeclarations()[0];
+  if (!structured || !declaration) {
+    return type;
+  }
+  return removeUndefined(structured.getTypeAtLocation(declaration));
+}
+function removeUndefined(type) {
+  if (!type.isUnion()) {
+    return type;
+  }
+  const nonUndefined = type.getUnionTypes().filter((part) => !part.isUndefined());
+  return nonUndefined.length === 1 ? nonUndefined[0] : type;
+}
+function containsUndefined(type) {
+  return type.isUnion() && type.getUnionTypes().some((part) => part.isUndefined());
+}
+function schemaDescription(symbol) {
+  if (!symbol) {
+    return void 0;
+  }
+  return symbol.getDeclarations().flatMap((declaration) => {
+    if (Node2.isJSDocable(declaration)) {
+      return declaration.getJsDocs().map((doc) => doc.getCommentText() ?? "");
+    }
+    return [];
+  }).find((comment) => comment.trim().length > 0);
+}
+
+// packages/compiler/src/widgets.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync2 } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path3 from "path";
+import { build as esbuild } from "esbuild";
+import postcss from "postcss";
+import {
+  Node as Node3,
+  SyntaxKind
+} from "ts-morph";
+async function buildWidgets(rootDir, outDir, tools) {
+  const widgets = tools.filter(
+    (entry) => Boolean(entry.widget)
+  );
+  if (!widgets.length) {
+    return;
+  }
+  const cacheDir = path3.join(rootDir, ".sidecar", "cache", "widgets");
+  await mkdir(cacheDir, { recursive: true });
+  const appStyle = await prepareAppStyle(rootDir, cacheDir);
+  for (const entry of widgets) {
+    const sourceFile = path3.join(rootDir, entry.widget.sourceFile);
+    const safeId = safePathSegment(entry.id);
+    const entryFile = path3.join(cacheDir, `${safeId}.entry.tsx`);
+    const importPath = toImportSpecifier(path3.dirname(entryFile), sourceFile);
+    await writeFile(
+      entryFile,
+      `import React from "react";
+import { createRoot } from "react-dom/client";
+import { SidecarWidgetRoot } from "@sidecar-ai/react";
+import "@sidecar-ai/native/styles.css";
+${appStyle ? `import ${JSON.stringify(toImportSpecifier(path3.dirname(entryFile), appStyle))};` : ""}
+import Component from ${JSON.stringify(importPath)};
+
+createRoot(document.getElementById("root")!).render(
+  React.createElement(SidecarWidgetRoot, null, React.createElement(Component))
+);
+`
+    );
+    const bundled = await esbuild({
+      absWorkingDir: rootDir,
+      alias: devSidecarBundleAliases(rootDir),
+      bundle: true,
+      entryPoints: [entryFile],
+      format: "iife",
+      jsx: "automatic",
+      minify: false,
+      nodePaths: [
+        path3.join(rootDir, "node_modules"),
+        path3.join(process.cwd(), "node_modules")
+      ],
+      outfile: "widget.js",
+      platform: "browser",
+      sourcemap: false,
+      write: false
+    });
+    const javascript = bundled.outputFiles.find((file) => file.path.endsWith(".js"))?.text ?? "";
+    const css = bundled.outputFiles.filter((file) => file.path.endsWith(".css")).map((file) => file.text).join("\n");
+    const html = renderWidgetHtml(entry.name, javascript, css);
+    const hash = createHash("sha256").update(html).digest("hex").slice(0, 12);
+    const outputDir = path3.join(outDir, "public", "widgets", safeId);
+    const outputFile = path3.join(outputDir, `widget.${hash}.html`);
+    const resourceUri = `ui://${safeId}/widget.${hash}.html`;
+    await mkdir(outputDir, { recursive: true });
+    await writeFile(outputFile, html);
+    entry.widget.resourceUri = resourceUri;
+    entry.widget.resourceMeta = widgetResourceMeta(entry.widget.options, entry.target);
+    entry.widget.outputFile = path3.relative(outDir, outputFile);
+    entry.descriptor._meta = mergeWidgetMeta(entry.descriptor._meta, widgetMeta(resourceUri, entry.widget.options, entry.target));
+  }
+}
+function devSidecarBundleAliases(rootDir) {
+  const repoRoot = findSidecarRepoRoot(rootDir) ?? findSidecarRepoRoot(process.cwd());
+  if (!repoRoot) {
+    return void 0;
+  }
+  const reactEntry = path3.join(repoRoot, "packages", "react", "src", "index.ts");
+  if (!existsSync2(reactEntry)) {
+    return void 0;
+  }
+  return {
+    "sidecar-ai": path3.join(repoRoot, "packages", "sidecar-ai", "src", "index.ts"),
+    "@sidecar-ai/client": path3.join(repoRoot, "packages", "client", "src", "index.ts"),
+    "@sidecar-ai/core": path3.join(repoRoot, "packages", "core", "src", "index.ts"),
+    "@sidecar-ai/react": reactEntry,
+    "@sidecar-ai/native": path3.join(repoRoot, "packages", "native", "src", "index.ts"),
+    "@sidecar-ai/native/components": path3.join(repoRoot, "packages", "native", "src", "components", "index.tsx"),
+    "@sidecar-ai/native/styles.css": path3.join(repoRoot, "packages", "native", "src", "styles.css")
+  };
+}
+function findSidecarRepoRoot(startDir) {
+  let current = path3.resolve(startDir);
+  while (true) {
+    if (existsSync2(path3.join(current, "packages", "core", "src", "index.ts"))) {
+      return current;
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) {
+      return void 0;
+    }
+    current = parent;
+  }
+}
+async function prepareAppStyle(rootDir, cacheDir) {
+  const sourceFile = path3.join(rootDir, "style.css");
+  if (!existsSync2(sourceFile)) {
+    return void 0;
+  }
+  const source = await readFile(sourceFile, "utf8");
+  const css = await processAppStyle(source, sourceFile);
+  const outputFile = path3.join(cacheDir, "style.css");
+  await writeFile(outputFile, css);
+  return outputFile;
+}
+async function processAppStyle(source, from) {
+  if (!needsPostcss(source)) {
+    return source;
+  }
+  const cssSource = source.replace(/@import\s+["']tailwindcss["'];?/g, "@tailwind utilities;").replace(/@import\s+["']@openai\/apps-sdk-ui\/css["'];?/g, "");
+  const plugins = [];
+  if (cssSource.includes("@tailwind")) {
+    const tailwind = await import("@tailwindcss/postcss");
+    plugins.push(tailwind.default({ base: path3.dirname(from) }));
+  }
+  const autoprefixer = await import("autoprefixer");
+  plugins.push(autoprefixer.default());
+  const result = await postcss(plugins).process(cssSource, {
+    from,
+    map: false
+  });
+  return result.css;
+}
+function needsPostcss(source) {
+  return /@import\s+["']tailwindcss["']|@tailwind|@source|@theme|@plugin/.test(source);
+}
+function findWidget(rootDir, toolFile, id, target = "mcp", toolVariant = "shared") {
+  const selected = selectWidgetFile(path3.dirname(toolFile), target, toolVariant);
+  if (!selected) {
+    return void 0;
+  }
+  const safeId = safePathSegment(id);
+  return {
+    sourceFile: path3.relative(rootDir, selected.filePath),
+    variant: selected.variant,
+    resourceUri: `ui://${safeId}/widget.html`
+  };
+}
+function readWidgetOptions(sourceFile) {
+  const definition = findWidgetDefinition(sourceFile);
+  if (!definition) {
+    return void 0;
+  }
+  const options = {};
+  const description = readStringProperty(definition, "description");
+  const prefersBorder = readBooleanProperty(definition, "prefersBorder");
+  const csp = readWidgetCsp(definition);
+  const permissions = readWidgetPermissions(definition);
+  const chatgpt = readChatGptWidgetOptions(definition);
+  const domain = readStringProperty(definition, "domain");
+  if (description) options.description = description;
+  if (prefersBorder !== void 0) options.prefersBorder = prefersBorder;
+  if (domain) options.domain = domain;
+  if (csp) options.csp = csp;
+  if (permissions) options.permissions = permissions;
+  if (chatgpt) options.hosts = { chatgpt };
+  return Object.keys(options).length ? options : void 0;
+}
+function widgetMeta(resourceUri, options = {}, target = "mcp") {
+  const chatgptCsp = {
+    connect_domains: options.csp?.connectDomains ? [...options.csp.connectDomains] : [],
+    resource_domains: options.csp?.resourceDomains ? [...options.csp.resourceDomains] : [],
+    frame_domains: options.csp?.frameDomains ? [...options.csp.frameDomains] : void 0,
+    redirect_domains: options.hosts?.chatgpt?.redirectDomains ? [...options.hosts.chatgpt.redirectDomains] : void 0
+  };
+  const standard = {
+    ui: {
+      resourceUri
+    }
+  };
+  if (target !== "chatgpt") {
+    return standard;
+  }
+  return {
+    ...standard,
+    "openai/outputTemplate": resourceUri,
+    "openai/widgetDescription": options.description,
+    "openai/widgetDomain": options.hosts?.chatgpt?.domain,
+    "openai/widgetCSP": stripUndefined3(chatgptCsp)
+  };
+}
+function widgetResourceMeta(options = {}, target = "mcp") {
+  const csp = stripUndefined3({
+    connectDomains: options.csp?.connectDomains ? [...options.csp.connectDomains] : [],
+    resourceDomains: options.csp?.resourceDomains ? [...options.csp.resourceDomains] : [],
+    frameDomains: options.csp?.frameDomains ? [...options.csp.frameDomains] : void 0,
+    baseUriDomains: options.csp?.baseUriDomains ? [...options.csp.baseUriDomains] : void 0
+  });
+  const permissions = widgetPermissionsMeta(options);
+  const ui = stripUndefined3({
+    csp,
+    permissions,
+    domain: options.domain ?? (target === "chatgpt" ? options.hosts?.chatgpt?.domain : void 0),
+    prefersBorder: options.prefersBorder
+  });
+  return Object.keys(ui).length ? { ui } : void 0;
+}
+function findWidgetDefinition(sourceFile) {
+  const call = resolveDefaultExportCall(sourceFile, "widget");
+  if (!call) {
+    return void 0;
+  }
+  const definition = unwrapExpression(call.getArguments()[0]);
+  if (!definition || !Node3.isObjectLiteralExpression(definition)) {
+    throw new CompilerError(
+      sourceFile,
+      "widget(...) must receive its metadata object as the first argument."
+    );
+  }
+  return definition;
+}
+function readWidgetCsp(definition) {
+  const initializer = readObjectProperty(definition, "csp");
+  if (!initializer) {
+    return void 0;
+  }
+  const csp = {
+    connectDomains: readStringArrayProperty(initializer, "connectDomains"),
+    resourceDomains: readStringArrayProperty(initializer, "resourceDomains"),
+    frameDomains: readStringArrayProperty(initializer, "frameDomains"),
+    baseUriDomains: readStringArrayProperty(initializer, "baseUriDomains")
+  };
+  return stripUndefined3(csp);
+}
+function readWidgetPermissions(definition) {
+  const initializer = readObjectProperty(definition, "permissions");
+  if (!initializer) {
+    return void 0;
+  }
+  const permissions = {
+    camera: readBooleanProperty(initializer, "camera"),
+    microphone: readBooleanProperty(initializer, "microphone"),
+    geolocation: readBooleanProperty(initializer, "geolocation"),
+    clipboardWrite: readBooleanProperty(initializer, "clipboardWrite")
+  };
+  return stripUndefined3(permissions);
+}
+function widgetPermissionsMeta(options) {
+  const permissions = options.permissions;
+  if (!permissions) {
+    return void 0;
+  }
+  const meta = stripUndefined3({
+    camera: permissions.camera ? {} : void 0,
+    microphone: permissions.microphone ? {} : void 0,
+    geolocation: permissions.geolocation ? {} : void 0,
+    clipboardWrite: permissions.clipboardWrite ? {} : void 0
+  });
+  return Object.keys(meta).length ? meta : void 0;
+}
+function readChatGptWidgetOptions(definition) {
+  const hosts = readObjectProperty(definition, "hosts");
+  const chatgpt = hosts ? readObjectProperty(hosts, "chatgpt") : void 0;
+  if (!chatgpt) {
+    return void 0;
+  }
+  const options = {
+    domain: readStringProperty(chatgpt, "domain"),
+    redirectDomains: readStringArrayProperty(chatgpt, "redirectDomains")
+  };
+  return stripUndefined3(options);
+}
+function readObjectProperty(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
+  if (!property || !Node3.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  return initializer && Node3.isObjectLiteralExpression(initializer) ? initializer : void 0;
+}
+function readStringProperty(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
+  if (!property || !Node3.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  return initializer && Node3.isStringLiteral(initializer) ? initializer.getLiteralText() : void 0;
+}
+function readBooleanProperty(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
+  if (!property || !Node3.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  if (!initializer) {
+    return void 0;
+  }
+  if (initializer.getKind() === SyntaxKind.TrueKeyword) {
+    return true;
+  }
+  if (initializer.getKind() === SyntaxKind.FalseKeyword) {
+    return false;
+  }
+  return void 0;
+}
+function readStringArrayProperty(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
+  if (!property || !Node3.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  if (!initializer || !Node3.isArrayLiteralExpression(initializer)) {
+    return void 0;
+  }
+  return initializer.getElements().filter(Node3.isStringLiteral).map((element) => element.getLiteralText());
+}
+function selectWidgetFile(directory, target, toolVariant) {
+  if (toolVariant === "openai") {
+    const filePath = path3.join(directory, "widget.openai.tsx");
+    return existsSync2(filePath) ? { filePath, variant: "openai" } : void 0;
+  }
+  if (toolVariant === "anthropic") {
+    const filePath = path3.join(directory, "widget.anthropic.tsx");
+    return existsSync2(filePath) ? { filePath, variant: "anthropic" } : void 0;
+  }
+  const candidates = target === "chatgpt" || target === "claude" || target === "mcp" ? [{ name: "widget.tsx", variant: "shared" }] : [];
+  for (const candidate of candidates) {
+    const filePath = path3.join(directory, candidate.name);
+    if (existsSync2(filePath)) {
+      return { filePath, variant: candidate.variant };
+    }
+  }
+  return void 0;
+}
+function mergeWidgetMeta(existing, widget) {
+  const merged = { ...existing ?? {} };
+  for (const [key, value] of Object.entries(widget)) {
+    if (key === "ui" && isRecord2(value) && isRecord2(merged.ui)) {
+      merged.ui = { ...merged.ui, ...value };
+    } else {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+function renderWidgetHtml(title, javascript, css = "") {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${escapeHtml(title)}</title>
+    <style>
+      :root { color-scheme: light dark; font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
+      html, body, #root { min-height: 100%; margin: 0; background: transparent; }
+      body { color: CanvasText; }
+      * { box-sizing: border-box; }
+      ${css}
+    </style>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script>${javascript}</script>
+  </body>
+</html>
+`;
+}
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function stripUndefined3(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, entry]) => entry !== void 0)
+  );
+}
+
+// packages/compiler/src/analyze.ts
+async function analyzeProjectTools(rootDir, options = {}) {
+  const target = options.target ?? "mcp";
+  const toolFiles = await findToolFiles(path4.join(rootDir, "server"), target);
+  if (toolFiles.length === 0) {
+    return [];
+  }
+  const project = createProject(rootDir);
+  const authScopes = readAuthScopeCatalog(project, rootDir);
+  return toolFiles.map(
+    (candidate) => analyzeToolFile(project.addSourceFileAtPath(candidate.filePath), rootDir, {
+      target,
+      variant: candidate.variant,
+      authScopes
+    })
+  );
+}
+function analyzeToolFile(sourceFile, rootDir, options = {}) {
+  const target = options.target ?? "mcp";
+  const variant = options.variant ?? "shared";
+  const definition = findToolDefinition(sourceFile);
+  const absoluteFile = sourceFile.getFilePath();
+  const directory = path4.basename(path4.dirname(absoluteFile));
+  const name = getRequiredStringProperty(definition, "name", sourceFile);
+  const id = getOptionalStringProperty(definition, "id") ?? toMachineName(directory);
+  const description = getRequiredStringProperty(
+    definition,
+    "description",
+    sourceFile
+  );
+  const annotations = readAnnotations(definition);
+  const visibility = readVisibility(definition);
+  const hosts = readHosts(definition);
+  const auth = readAuthPolicy(definition, options.authScopes ?? {});
+  const execute = getExecuteFunction(definition, sourceFile);
+  const inputSchema = getParamsSchema(definition, execute);
+  const outputSchema = getOutputSchema(definition, execute);
+  const descriptor = createToolDescriptor({
+    name,
+    id,
+    description,
+    target,
+    inputSchema,
+    outputSchema,
+    annotations,
+    visibility,
+    hosts,
+    auth,
+    meta: void 0
+  });
+  validateWidgetHierarchy(sourceFile, absoluteFile, target, variant);
+  const widget = findWidget(rootDir, absoluteFile, id, target, variant);
+  if (widget) {
+    const widgetFile = path4.join(rootDir, widget.sourceFile);
+    const project = sourceFile.getProject();
+    const widgetSourceFile = project.getSourceFile(widgetFile) ?? project.addSourceFileAtPath(widgetFile);
+    widget.options = {
+      description,
+      ...readWidgetOptions(widgetSourceFile)
+    };
+    widget.resourceMeta = widgetResourceMeta(widget.options, target);
+    descriptor._meta = mergeWidgetMeta(descriptor._meta, widgetMeta(widget.resourceUri, widget.options, target));
+  }
+  return {
+    sourceFile: path4.relative(rootDir, absoluteFile),
+    variant,
+    target,
+    directory,
+    id,
+    name,
+    description,
+    inputSchema,
+    outputSchema,
+    annotations,
+    visibility,
+    widget,
+    descriptor
+  };
+}
+function readAuthPolicy(definition, authScopes) {
+  const initializer = readObjectProperty2(definition, "auth");
+  if (!initializer) {
+    return void 0;
+  }
+  const publicValue = readBooleanProperty2(initializer, "public");
+  if (publicValue === true) {
+    return { public: true };
+  }
+  const scopesProperty = initializer.getProperty("scopes");
+  if (scopesProperty && Node4.isPropertyAssignment(scopesProperty)) {
+    return { scopes: readScopeReferences(scopesProperty.getInitializer(), authScopes) };
+  }
+  return { authenticated: true };
+}
+function readAuthScopeCatalog(project, rootDir) {
+  const authPath = path4.join(rootDir, "auth.ts");
+  if (!existsSyncSafe(authPath)) {
+    return {};
+  }
+  const sourceFile = project.addSourceFileAtPath(authPath);
+  const catalog = {};
+  for (const call of sourceFile.getDescendantsOfKind(SyntaxKind2.CallExpression)) {
+    if (!isNamedCall(call, "auth")) {
+      continue;
+    }
+    const definition = unwrapExpression(call.getArguments()[0]);
+    if (!definition || !Node4.isObjectLiteralExpression(definition)) {
+      continue;
+    }
+    const scopes = readObjectProperty2(definition, "scopes");
+    if (!scopes) {
+      continue;
+    }
+    for (const property of scopes.getProperties()) {
+      if (!Node4.isPropertyAssignment(property)) {
+        continue;
+      }
+      const scope = readScopeCall(property.getInitializer());
+      if (scope) {
+        catalog[property.getName().replace(/^["']|["']$/g, "")] = scope;
+      }
+    }
+  }
+  return catalog;
+}
+function readScopeReferences(initializer, authScopes) {
+  const expression = unwrapExpression(initializer);
+  if (!expression || !Node4.isArrayLiteralExpression(expression)) {
+    return [];
+  }
+  return expression.getElements().flatMap((element) => {
+    const direct = readScopeCall(element);
+    if (direct) {
+      return [{ kind: "sidecar.scope", ...direct }];
+    }
+    const name = scopeReferenceName(element);
+    const declared = name ? authScopes[name] : void 0;
+    if (declared) {
+      return [{ kind: "sidecar.scope", ...declared }];
+    }
+    const literal = unwrapExpression(element);
+    if (literal && Node4.isStringLiteral(literal)) {
+      return [{
+        kind: "sidecar.scope",
+        id: literal.getLiteralText(),
+        description: ""
+      }];
+    }
+    return [];
+  });
+}
+function readScopeCall(node) {
+  const expression = unwrapExpression(node);
+  if (!expression || !Node4.isCallExpression(expression) || !isNamedCall(expression, "scope")) {
+    return void 0;
+  }
+  const [idArg, descriptionArg] = expression.getArguments();
+  if (!idArg || !Node4.isStringLiteral(idArg)) {
+    return void 0;
+  }
+  return {
+    id: idArg.getLiteralText(),
+    description: Node4.isStringLiteral(descriptionArg) ? descriptionArg.getLiteralText() : ""
+  };
+}
+function scopeReferenceName(node) {
+  const expression = unwrapExpression(node);
+  if (!expression || !Node4.isPropertyAccessExpression(expression)) {
+    return void 0;
+  }
+  return expression.getName();
+}
+function isNamedCall(call, name) {
+  const callee = call.getExpression().getText();
+  return callee === name || callee.endsWith(`.${name}`);
+}
+function validateWidgetHierarchy(sourceFile, toolFile, target, variant) {
+  const directory = path4.dirname(toolFile);
+  const platformWidget = target === "chatgpt" ? "widget.openai.tsx" : target === "claude" ? "widget.anthropic.tsx" : void 0;
+  if (!platformWidget || variant !== "shared") {
+    return;
+  }
+  if (existsSyncSafe(path4.join(directory, platformWidget))) {
+    const expectedTool = target === "chatgpt" ? "tool.openai.ts" : "tool.anthropic.ts";
+    throw new CompilerError(
+      sourceFile,
+      `${platformWidget} requires a sibling ${expectedTool}; platform-specific widgets cannot attach to a shared tool.ts.`
+    );
+  }
+}
+async function findToolFiles(serverDir, target) {
+  if (!existsSyncSafe(serverDir)) {
+    return [];
+  }
+  const entries = await readdir(serverDir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const entryPath = path4.join(serverDir, entry.name);
+    if (entry.isDirectory()) {
+      const candidate = selectToolFile(entryPath, target);
+      if (candidate) {
+        files.push(candidate);
+      }
+    }
+  }
+  return files.sort((left, right) => left.filePath.localeCompare(right.filePath));
+}
+function selectToolFile(directory, target) {
+  const candidates = target === "chatgpt" ? [
+    { name: "tool.openai.ts", variant: "openai" },
+    { name: "tool.ts", variant: "shared" }
+  ] : target === "claude" ? [
+    { name: "tool.anthropic.ts", variant: "anthropic" },
+    { name: "tool.ts", variant: "shared" }
+  ] : [{ name: "tool.ts", variant: "shared" }];
+  for (const candidate of candidates) {
+    const filePath = path4.join(directory, candidate.name);
+    if (existsSyncSafe(filePath)) {
+      return { filePath, variant: candidate.variant };
+    }
+  }
+  return void 0;
+}
+function findToolDefinition(sourceFile) {
+  const call = resolveDefaultExportCall(sourceFile, "tool");
+  if (!call) {
+    throw new CompilerError(
+      sourceFile,
+      "tool.ts must default-export tool({ ... }) or an identifier initialized with tool({ ... })."
+    );
+  }
+  const definition = unwrapExpression(call.getArguments()[0]);
+  if (!definition || !Node4.isObjectLiteralExpression(definition)) {
+    throw new CompilerError(
+      sourceFile,
+      "tool(...) must receive one object literal."
+    );
+  }
+  return definition;
+}
+function getExecuteFunction(definition, sourceFile) {
+  const property = definition.getProperty("execute");
+  if (!property) {
+    throw new CompilerError(
+      sourceFile,
+      "tool({ ... }) must include an execute method."
+    );
+  }
+  if (Node4.isMethodDeclaration(property)) {
+    return property;
+  }
+  if (Node4.isPropertyAssignment(property)) {
+    const initializer = property.getInitializer();
+    if (initializer && (Node4.isArrowFunction(initializer) || Node4.isFunctionExpression(initializer))) {
+      return initializer;
+    }
+  }
+  throw new CompilerError(
+    sourceFile,
+    "execute must be a method, function expression, or arrow function."
+  );
+}
+function getRequiredStringProperty(definition, propertyName, sourceFile) {
+  const value = getOptionalStringProperty(definition, propertyName);
+  if (value === void 0 || !value.trim()) {
+    throw new CompilerError(
+      sourceFile,
+      `tool({ ... }) must include a non-empty ${propertyName} string.`
+    );
+  }
+  return value;
+}
+function getOptionalStringProperty(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
+  if (!property || !Node4.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = property.getInitializer();
+  if (!initializer || !Node4.isStringLiteral(initializer)) {
+    return void 0;
+  }
+  return initializer.getLiteralText();
+}
+function readAnnotations(definition) {
+  const property = definition.getProperty("annotations");
+  if (!property || !Node4.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = property.getInitializer();
+  if (!initializer || !Node4.isObjectLiteralExpression(initializer)) {
+    return void 0;
+  }
+  const annotations = {};
+  for (const key of [
+    "title",
+    "readOnlyHint",
+    "destructiveHint",
+    "idempotentHint",
+    "openWorldHint"
+  ]) {
+    const value = initializer.getProperty(key);
+    if (!value || !Node4.isPropertyAssignment(value)) {
+      continue;
+    }
+    const expression = value.getInitializer();
+    if (!expression) {
+      continue;
+    }
+    if (key === "title" && Node4.isStringLiteral(expression)) {
+      annotations.title = expression.getLiteralText();
+    } else if (key !== "title" && (expression.getKind() === SyntaxKind2.TrueKeyword || expression.getKind() === SyntaxKind2.FalseKeyword)) {
+      annotations[key] = expression.getKind() === SyntaxKind2.TrueKeyword;
+    }
+  }
+  return Object.keys(annotations).length ? annotations : void 0;
+}
+function readVisibility(definition) {
+  const initializer = readObjectProperty2(definition, "visibility");
+  if (!initializer) {
+    return void 0;
+  }
+  const visibility = {};
+  for (const key of ["model", "widgets", "tools"]) {
+    const property = initializer.getProperty(key);
+    if (!property || !Node4.isPropertyAssignment(property)) {
+      continue;
+    }
+    const value = property.getInitializer();
+    if (!value) {
+      continue;
+    }
+    if (value.getKind() === SyntaxKind2.TrueKeyword || value.getKind() === SyntaxKind2.FalseKeyword) {
+      assignVisibility(visibility, key, value.getKind() === SyntaxKind2.TrueKeyword);
+    } else if (Node4.isArrayLiteralExpression(value)) {
+      assignVisibility(visibility, key, value.getElements().filter(Node4.isStringLiteral).map((element) => element.getLiteralText()));
+    }
+  }
+  return Object.keys(visibility).length ? visibility : void 0;
+}
+function assignVisibility(visibility, key, value) {
+  visibility[key] = value;
+}
+function readHosts(definition) {
+  const initializer = readObjectProperty2(definition, "hosts");
+  if (!initializer) {
+    return void 0;
+  }
+  const chatgpt = readObjectProperty2(initializer, "chatgpt");
+  if (!chatgpt) {
+    return void 0;
+  }
+  const options = {};
+  const invoking = readStringProperty2(chatgpt, "invoking");
+  const invoked = readStringProperty2(chatgpt, "invoked");
+  const visibility = readStringProperty2(chatgpt, "visibility");
+  const widgetAccessible = readBooleanProperty2(chatgpt, "widgetAccessible");
+  const fileParams = readStringArrayProperty2(chatgpt, "fileParams");
+  if (invoking) options.invoking = invoking;
+  if (invoked) options.invoked = invoked;
+  if (visibility === "public" || visibility === "private") {
+    options.visibility = visibility;
+  }
+  if (widgetAccessible !== void 0) {
+    options.widgetAccessible = widgetAccessible;
+  }
+  if (fileParams) {
+    options.fileParams = fileParams;
+  }
+  return Object.keys(options).length ? { chatgpt: options } : void 0;
+}
+function readObjectProperty2(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
+  if (!property || !Node4.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  return initializer && Node4.isObjectLiteralExpression(initializer) ? initializer : void 0;
+}
+function readStringProperty2(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
+  if (!property || !Node4.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  return initializer && Node4.isStringLiteral(initializer) ? initializer.getLiteralText() : void 0;
+}
+function readBooleanProperty2(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
+  if (!property || !Node4.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  if (!initializer) {
+    return void 0;
+  }
+  if (initializer.getKind() === SyntaxKind2.TrueKeyword) {
+    return true;
+  }
+  if (initializer.getKind() === SyntaxKind2.FalseKeyword) {
+    return false;
+  }
+  return void 0;
+}
+function readStringArrayProperty2(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
+  if (!property || !Node4.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  if (!initializer || !Node4.isArrayLiteralExpression(initializer)) {
+    return void 0;
+  }
+  return initializer.getElements().filter(Node4.isStringLiteral).map((element) => element.getLiteralText());
+}
+
+// packages/compiler/src/build.ts
+import { mkdir as mkdir8, writeFile as writeFile8 } from "fs/promises";
+import path17 from "path";
+
+// packages/compiler/src/config.ts
+import path5 from "path";
+import {
+  Node as Node5,
+  SyntaxKind as SyntaxKind3
+} from "ts-morph";
+function analyzeProjectConfig(rootDir) {
+  const configPath = path5.join(rootDir, "sidecar.config.ts");
+  if (!existsSyncSafe(configPath)) {
+    return defaultCompilerConfig();
+  }
+  const project = createProject(rootDir);
+  const sourceFile = project.addSourceFileAtPath(configPath);
+  const call = resolveDefaultExportCall(sourceFile, "defineConfig");
+  const definition = unwrapExpression(call?.getArguments()[0]);
+  if (!definition || !Node5.isObjectLiteralExpression(definition)) {
+    return defaultCompilerConfig();
+  }
+  return {
+    resources: {
+      subscribe: readBooleanNested(definition, "resources", "subscribe") ?? false,
+      listChanged: readBooleanNested(definition, "resources", "listChanged") ?? false
+    },
+    prompts: {
+      listChanged: readBooleanNested(definition, "prompts", "listChanged") ?? false
+    },
+    tools: {
+      listChanged: readBooleanNested(definition, "tools", "listChanged") ?? false
+    },
+    pagination: {
+      pageSize: readNumberNested(definition, "pagination", "pageSize") ?? 10,
+      hasOverride: hasProperty(readObjectProperty3(definition, "pagination"), "override")
+    }
+  };
+}
+function defaultCompilerConfig() {
+  return {
+    resources: {
+      subscribe: false,
+      listChanged: false
+    },
+    prompts: {
+      listChanged: false
+    },
+    tools: {
+      listChanged: false
+    },
+    pagination: {
+      pageSize: 10,
+      hasOverride: false
+    }
+  };
+}
+function readBooleanNested(definition, section, propertyName) {
+  const object = readObjectProperty3(definition, section);
+  if (!object) {
+    return void 0;
+  }
+  const property = object.getProperty(propertyName);
+  if (!property || !Node5.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  if (!initializer) {
+    return void 0;
+  }
+  if (initializer.getKind() === SyntaxKind3.TrueKeyword) return true;
+  if (initializer.getKind() === SyntaxKind3.FalseKeyword) return false;
+  return void 0;
+}
+function readNumberNested(definition, section, propertyName) {
+  const object = readObjectProperty3(definition, section);
+  if (!object) {
+    return void 0;
+  }
+  const property = object.getProperty(propertyName);
+  if (!property || !Node5.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  return initializer && Node5.isNumericLiteral(initializer) ? Number(initializer.getLiteralText()) : void 0;
+}
+function readObjectProperty3(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
+  if (!property || !Node5.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  return initializer && Node5.isObjectLiteralExpression(initializer) ? initializer : void 0;
+}
+function hasProperty(definition, propertyName) {
+  return Boolean(definition?.getProperty(propertyName));
+}
+
+// packages/compiler/src/diagnostics.ts
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import { createRequire } from "module";
+import path6 from "path";
+async function collectProjectDiagnostics(rootDir, input) {
+  const diagnostics = [];
+  const tools = Array.isArray(input) ? input : input.tools;
+  const resources = Array.isArray(input) ? [] : input.resources ?? [];
+  const prompts = Array.isArray(input) ? [] : input.prompts ?? [];
+  const config = Array.isArray(input) ? void 0 : input.config;
+  const hasAuthConfig = existsSync3(path6.join(rootDir, "auth.ts"));
+  const hasOpenAiAppsSdkUi = canResolveOpenAiAppsSdkUi(rootDir);
+  for (const entry of tools) {
+    const toolPath = path6.join(rootDir, entry.sourceFile);
+    const toolSource = await readFile2(toolPath, "utf8");
+    diagnostics.push(...diagnoseToolSource(rootDir, entry, toolSource, hasAuthConfig));
+    if (entry.widget) {
+      const widgetPath = path6.join(rootDir, entry.widget.sourceFile);
+      const widgetSource = await readFile2(widgetPath, "utf8");
+      diagnostics.push(...diagnoseWidgetSource(rootDir, entry, widgetSource, hasOpenAiAppsSdkUi));
+    }
+  }
+  for (const entry of resources) {
+    const resourcePath = path6.join(rootDir, entry.sourceFile);
+    const resourceSource = await readFile2(resourcePath, "utf8");
+    diagnostics.push(...diagnoseResourceSource(entry, resourceSource));
+  }
+  for (const entry of prompts) {
+    const promptPath = path6.join(rootDir, entry.sourceFile);
+    const promptSource = await readFile2(promptPath, "utf8");
+    diagnostics.push(...diagnosePromptSource(entry, promptSource));
+  }
+  if (config) {
+    diagnostics.push(...diagnoseCapabilities(config, resources));
+  }
+  return diagnostics;
+}
+function formatDiagnostic(diagnostic) {
+  const location = `${diagnostic.filePath}:${diagnostic.line}:${diagnostic.column}`;
+  const hint = diagnostic.hint ? `
+  hint: ${diagnostic.hint}` : "";
+  return `${location} - ${diagnostic.severity} ${diagnostic.code}: ${diagnostic.message}${hint}`;
+}
+function diagnoseToolSource(rootDir, entry, source, hasAuthConfig) {
+  const diagnostics = [];
+  const toolLocation = locate(source, "tool({");
+  if (!entry.description.trim().startsWith("Use this when")) {
+    diagnostics.push({
+      severity: "warning",
+      code: "SIDECAR_METADATA_DESCRIPTION",
+      message: `Tool "${entry.id}" description should start with "Use this when..." for better model routing.`,
+      filePath: entry.sourceFile,
+      ...toolLocation,
+      hint: "Keep the first sentence specific and include explicit disallowed cases when useful."
+    });
+  }
+  for (const key of ["readOnlyHint", "destructiveHint", "openWorldHint"]) {
+    if (!(key in (entry.annotations ?? {}))) {
+      diagnostics.push({
+        severity: "warning",
+        code: "SIDECAR_TOOL_ANNOTATION",
+        message: `Tool "${entry.id}" should explicitly declare annotations.${key}.`,
+        filePath: entry.sourceFile,
+        ...toolLocation,
+        hint: "Hosts use these hints to frame approval and safety UX; Sidecar applies conservative defaults only as a fallback."
+      });
+    }
+  }
+  if (/auth\s*:/.test(source) && !hasAuthConfig && !isIgnored(source, "SIDECAR_AUTH_MISSING_CONFIG")) {
+    diagnostics.push({
+      severity: "warning",
+      code: "SIDECAR_AUTH_MISSING_CONFIG",
+      message: `Tool "${entry.id}" declares auth but the project has no reserved auth.ts file.`,
+      filePath: entry.sourceFile,
+      ...locate(source, "auth"),
+      hint: "Add auth.ts at the project root or mark the tool auth policy as public."
+    });
+  }
+  if (!returnsToolResult(source) && !isIgnored(source, "SIDECAR_TOOL_RESULT_REQUIRED")) {
+    diagnostics.push({
+      severity: "warning",
+      code: "SIDECAR_TOOL_RESULT_REQUIRED",
+      message: `Tool "${entry.id}" should return toolResult(...) from execute.`,
+      filePath: entry.sourceFile,
+      ...locate(source, "execute"),
+      hint: "The runtime rejects plain objects so content, structuredContent, and meta always map cleanly to MCP result channels."
+    });
+  }
+  if (/["']openai\//.test(source) && !/@sidecar-ai\/openai/.test(source) && !isIgnored(source, "SIDECAR_OPENAI_MAGIC_META")) {
+    diagnostics.push({
+      severity: "warning",
+      code: "SIDECAR_OPENAI_MAGIC_META",
+      message: `Tool "${entry.id}" uses raw ChatGPT metadata strings.`,
+      filePath: entry.sourceFile,
+      ...locate(source, "openai/"),
+      hint: "Use @sidecar-ai/openai helpers or the typed hosts.chatgpt field so platform metadata stays typed."
+    });
+  }
+  for (const parameterName of missingParameterDescriptions(entry.inputSchema)) {
+    diagnostics.push({
+      severity: "warning",
+      code: "SIDECAR_PARAM_DESCRIPTION",
+      message: `Parameter "${parameterName}" on tool "${entry.id}" is missing a JSDoc/schema description.`,
+      filePath: entry.sourceFile,
+      ...locate(source, parameterName),
+      hint: "Add a JSDoc comment to the TypeScript field or provide a schema description."
+    });
+  }
+  if (looksLikeKnowledgeTool(entry) && !hasCompanyKnowledgeShape(entry.inputSchema) && !isIgnored(source, "SIDECAR_COMPANY_KNOWLEDGE_SHAPE")) {
+    diagnostics.push({
+      severity: "warning",
+      code: "SIDECAR_COMPANY_KNOWLEDGE_SHAPE",
+      message: `Tool "${entry.id}" looks like a search/fetch knowledge tool but does not use the expected simple input shape.`,
+      filePath: entry.sourceFile,
+      ...toolLocation,
+      hint: "Use a string query for search tools or a string id/url for fetch tools, or add // sidecar-ignore SIDECAR_COMPANY_KNOWLEDGE_SHAPE."
+    });
+  }
+  return diagnostics.filter((diagnostic) => !isIgnored(source, diagnostic.code));
+}
+function diagnoseWidgetSource(_rootDir, entry, source, hasOpenAiAppsSdkUi) {
+  const diagnostics = [];
+  const widgetFile = entry.widget?.sourceFile;
+  if (!widgetFile) {
+    return diagnostics;
+  }
+  if (/window\s*\.\s*openai|\(\s*window\s+as\s+[^)]*\)\s*\.\s*openai/.test(source) && !isIgnored(source, "SIDECAR_OPENAI_RAW_BRIDGE")) {
+    diagnostics.push({
+      severity: "warning",
+      code: "SIDECAR_OPENAI_RAW_BRIDGE",
+      message: `Widget for "${entry.id}" reads window.openai directly.`,
+      filePath: widgetFile,
+      ...locate(source, "openai"),
+      hint: "Use @sidecar-ai/openai runtime helpers in ChatGPT-only widgets, or @sidecar-ai/native/@sidecar-ai/client for portable behavior."
+    });
+  }
+  if (entry.widget?.variant !== "openai" && /@sidecar-ai\/openai/.test(source) && !/@sidecar-ai\/native/.test(source) && !isIgnored(source, "SIDECAR_OPENAI_FALLBACK")) {
+    diagnostics.push({
+      severity: "warning",
+      code: "SIDECAR_OPENAI_FALLBACK",
+      message: `Widget for "${entry.id}" imports @sidecar-ai/openai without a portable fallback.`,
+      filePath: widgetFile,
+      ...locate(source, "@sidecar-ai/openai"),
+      hint: "Prefer @sidecar-ai/native for user-facing behavior and reserve @sidecar-ai/openai for typed metadata or explicit ChatGPT-only code paths."
+    });
+  }
+  if (entry.widget?.variant !== "openai" && /@sidecar-ai\/openai\/components/.test(source) && !isIgnored(source, "SIDECAR_OPENAI_COMPONENT_CROSS_HOST")) {
+    diagnostics.push({
+      severity: "warning",
+      code: "SIDECAR_OPENAI_COMPONENT_CROSS_HOST",
+      message: `Widget for "${entry.id}" imports ChatGPT-only components.`,
+      filePath: widgetFile,
+      ...locate(source, "@sidecar-ai/openai/components"),
+      hint: "Use @sidecar-ai/native for portable primitives. Keep @sidecar-ai/openai/components for widgets intentionally targeted to ChatGPT."
+    });
+  }
+  if (/@sidecar-ai\/openai\/components/.test(source) && !hasOpenAiAppsSdkUi && !isIgnored(source, "SIDECAR_OPENAI_UI_SDK_MISSING")) {
+    diagnostics.push({
+      severity: "error",
+      code: "SIDECAR_OPENAI_UI_SDK_MISSING",
+      message: `Widget for "${entry.id}" imports @sidecar-ai/openai/components but @openai/apps-sdk-ui is not installed.`,
+      filePath: widgetFile,
+      ...locate(source, "@sidecar-ai/openai/components"),
+      hint: "Install it with: npm install @openai/apps-sdk-ui"
+    });
+  }
+  if (entry.widget?.variant !== "anthropic" && /@sidecar-ai\/anthropic\/components/.test(source) && !isIgnored(source, "SIDECAR_ANTHROPIC_COMPONENT_CROSS_HOST")) {
+    diagnostics.push({
+      severity: "warning",
+      code: "SIDECAR_ANTHROPIC_COMPONENT_CROSS_HOST",
+      message: `Widget for "${entry.id}" imports Claude-only components.`,
+      filePath: widgetFile,
+      ...locate(source, "@sidecar-ai/anthropic/components"),
+      hint: "Use @sidecar-ai/native for portable primitives. Keep @sidecar-ai/anthropic/components for widgets intentionally targeted to Claude."
+    });
+  }
+  if (/\bPopover\b/.test(source) && /@sidecar-ai\/native/.test(source) && !isIgnored(source, "SIDECAR_NATIVE_NON_PORTABLE_COMPONENT")) {
+    diagnostics.push({
+      severity: "warning",
+      code: "SIDECAR_NATIVE_NON_PORTABLE_COMPONENT",
+      message: `Widget for "${entry.id}" appears to expect a native Popover.`,
+      filePath: widgetFile,
+      ...locate(source, "Popover"),
+      hint: "Popover is host-specific because Claude inline apps discourage clipped overlay UI. Use @sidecar-ai/openai/components for ChatGPT-only popovers."
+    });
+  }
+  return diagnostics.filter((diagnostic) => !isIgnored(source, diagnostic.code));
+}
+function diagnoseResourceSource(entry, source) {
+  const diagnostics = [];
+  if (!returnsResourceResult(source) && !isIgnored(source, "SIDECAR_RESOURCE_RESULT_REQUIRED")) {
+    diagnostics.push({
+      severity: "warning",
+      code: "SIDECAR_RESOURCE_RESULT_REQUIRED",
+      message: `Resource "${entry.uri}" should return resourceResult(...) from read.`,
+      filePath: entry.sourceFile,
+      ...locate(source, "read"),
+      hint: "The runtime rejects plain objects so text/blob content maps cleanly to MCP resource contents."
+    });
+  }
+  return diagnostics.filter((diagnostic) => !isIgnored(source, diagnostic.code));
+}
+function diagnosePromptSource(entry, source) {
+  const diagnostics = [];
+  if (!source.includes("run") && !isIgnored(source, "SIDECAR_PROMPT_RUN_REQUIRED")) {
+    diagnostics.push({
+      severity: "warning",
+      code: "SIDECAR_PROMPT_RUN_REQUIRED",
+      message: `Prompt "${entry.name}" should include a run method.`,
+      filePath: entry.sourceFile,
+      ...locate(source, "prompt({"),
+      hint: "Prompt run methods return a string for the common case or MCP prompt messages for advanced cases."
+    });
+  }
+  return diagnostics.filter((diagnostic) => !isIgnored(source, diagnostic.code));
+}
+function diagnoseCapabilities(config, resources) {
+  const diagnostics = [];
+  if (!config.resources.subscribe && resources.some((entry) => entry.subscribe)) {
+    const entry = resources.find((resource) => resource.subscribe);
+    if (entry) {
+      diagnostics.push({
+        severity: "error",
+        code: "SIDECAR_RESOURCE_SUBSCRIBE_DISABLED",
+        message: `Resource "${entry.uri}" sets subscribe: true but sidecar.config.ts does not enable resources.subscribe.`,
+        filePath: entry.sourceFile,
+        line: 1,
+        column: 1,
+        hint: "Add resources: { subscribe: true } to sidecar.config.ts or remove subscribe: true from this resource."
+      });
+    }
+  }
+  return diagnostics;
+}
+function returnsToolResult(source) {
+  return /\breturn\s+toolResult(?:\.\w+)?\s*\(/.test(source);
+}
+function returnsResourceResult(source) {
+  return /\breturn\s+resourceResult(?:\.\w+)?\s*\(/.test(source);
+}
+function missingParameterDescriptions(schema) {
+  const properties = schema.properties ?? {};
+  return Object.entries(properties).filter(([, value]) => !value.description?.trim()).map(([key]) => key);
+}
+function looksLikeKnowledgeTool(entry) {
+  const text = `${entry.id} ${entry.name}`.toLowerCase();
+  return /\b(search|fetch)\b/.test(text) || /(^|[._-])(search|fetch)([._-]|$)/.test(text);
+}
+function hasCompanyKnowledgeShape(schema) {
+  const properties = schema.properties ?? {};
+  const query = properties.query;
+  const url = properties.url;
+  const id = properties.id;
+  return query?.type === "string" || url?.type === "string" || id?.type === "string";
+}
+function canResolveOpenAiAppsSdkUi(rootDir) {
+  try {
+    createRequire(path6.join(rootDir, "package.json")).resolve("@openai/apps-sdk-ui/css");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function locate(source, needle) {
+  const index = Math.max(0, source.indexOf(needle));
+  const prefix = source.slice(0, index);
+  const lines = prefix.split("\n");
+  return {
+    line: lines.length,
+    column: (lines.at(-1)?.length ?? 0) + 1
+  };
+}
+function isIgnored(source, code) {
+  return source.includes(`sidecar-ignore ${code}`) || source.includes(`sidecar-ignore all`);
+}
+
+// packages/compiler/src/generated.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import path7 from "path";
+async function writeGeneratedTypes(rootDir, tools) {
+  const generatedDir = path7.join(rootDir, ".sidecar", "generated");
+  await mkdir2(generatedDir, { recursive: true });
+  const appCallableTools = tools.filter(isAppCallable);
+  const methodNames = uniqueMethodNames(appCallableTools.map((entry) => toIdentifier(entry.id)));
+  const imports = appCallableTools.map(
+    (entry, index) => `import type tool${index} from ${JSON.stringify(toImportSpecifier(generatedDir, path7.join(rootDir, entry.sourceFile), { extension: "js" }))};`
+  ).join("\n");
+  const ids = appCallableTools.map((entry, index) => `  ${methodNames[index]}: ${JSON.stringify(entry.id)}`).join(",\n");
+  const toolTypes = appCallableTools.map(
+    (entry, index) => `  ${methodNames[index]}(params: ToolParams<typeof tool${index}>): Promise<ToolOutput<typeof tool${index}>>;`
+  ).join("\n");
+  await writeFile2(
+    path7.join(generatedDir, "tools.ts"),
+    `/**
+ * Generated Sidecar widget tool client.
+ *
+ * Do not edit this file directly; it is regenerated by sidecar build and
+ * sidecar dev.
+ */
+${imports}
+import { createToolClient } from "@sidecar-ai/client";
+import type { ToolResult } from "@sidecar-ai/core";
+
+type ExecuteOf<T> = T extends { execute: infer Execute } ? Execute : never;
+type ToolParams<T> = ExecuteOf<T> extends (params: infer Params, ...args: any[]) => unknown ? Params : never;
+type RawToolOutput<T> = Awaited<ReturnType<Extract<ExecuteOf<T>, (...args: any[]) => unknown>>>;
+type ToolOutput<T> = RawToolOutput<T> extends ToolResult<infer Structured, any> ? Structured : never;
+
+/** Machine names keyed by widget-friendly method names. */
+export const toolIds = {
+${ids}
+} as const;
+
+/** Typed callable tools available to widgets. */
+export type WidgetTools = {
+${toolTypes}
+};
+
+/** Default widget tool client backed by the host bridge. */
+export const tools = createToolClient<WidgetTools>(toolIds);
+`
+  );
+}
+function isAppCallable(entry) {
+  const ui = entry.descriptor._meta?.ui;
+  if (!ui || typeof ui !== "object" || Array.isArray(ui)) {
+    return true;
+  }
+  const visibility = ui.visibility;
+  return !Array.isArray(visibility) || visibility.includes("app");
+}
+function uniqueMethodNames(names) {
+  const seen = /* @__PURE__ */ new Map();
+  return names.map((name) => {
+    const count = seen.get(name) ?? 0;
+    seen.set(name, count + 1);
+    return count === 0 ? name : `${name}${count + 1}`;
+  });
+}
+
+// packages/compiler/src/plugins.ts
+import { mkdir as mkdir7, writeFile as writeFile7 } from "fs/promises";
+import path14 from "path";
+
+// packages/compiler/src/identity.ts
+import { readFile as readFile3 } from "fs/promises";
+import path8 from "path";
+async function loadProjectIdentity(rootDir) {
+  const packageJson = await readOptionalJson(path8.join(rootDir, "package.json"));
+  const configText = await readOptionalText(
+    path8.join(rootDir, "sidecar.config.ts")
+  );
+  const name = readConfigString(configText, "name") ?? packageJson?.name ?? path8.basename(rootDir);
+  const version = readConfigString(configText, "version") ?? packageJson?.version ?? "0.0.0-dev";
+  const description = readConfigString(configText, "description") ?? packageJson?.description ?? `${name} Sidecar app.`;
+  return {
+    name,
+    slug: toMachineName(name).replaceAll("_", "-"),
+    version,
+    description
+  };
+}
+async function readOptionalJson(filePath) {
+  if (!existsSyncSafe(filePath)) {
+    return void 0;
+  }
+  return JSON.parse(await readFile3(filePath, "utf8"));
+}
+async function readOptionalText(filePath) {
+  if (!existsSyncSafe(filePath)) {
+    return void 0;
+  }
+  return readFile3(filePath, "utf8");
+}
+function readConfigString(configText, key) {
+  if (!configText) {
+    return void 0;
+  }
+  const match = configText.match(
+    new RegExp(`${key}\\s*:\\s*["'\`]([^"'\`]+)["'\`]`)
+  );
+  return match?.[1];
+}
+
+// packages/compiler/src/plugin-components/agents.ts
+import { mkdir as mkdir3, readdir as readdir2, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import path9 from "path";
+async function emitClaudeAgents(rootDir, destination) {
+  const source = path9.join(rootDir, "agents");
+  if (!existsSyncSafe(source)) {
+    return;
+  }
+  const entries = await readdir2(source, { withFileTypes: true });
+  const agentDirs = entries.filter(
+    (entry) => entry.isDirectory() && existsSyncSafe(path9.join(source, entry.name, "agent.ts"))
+  );
+  if (!agentDirs.length) {
+    return;
+  }
+  await mkdir3(destination, { recursive: true });
+  for (const entry of agentDirs) {
+    const sourceText = await readFile4(path9.join(source, entry.name, "agent.ts"), "utf8");
+    const markdown = parseClaudeAgent(
+      sourceText,
+      entry.name
+    );
+    const agentName = readObjectString(sourceText, "name") ?? entry.name;
+    await writeFile3(path9.join(destination, `${safeFileStem(agentName)}.md`), markdown);
+  }
+}
+function parseClaudeAgent(source, fallbackName) {
+  const name = readObjectString(source, "name") ?? fallbackName;
+  const description = readObjectString(source, "description") ?? `${name} agent.`;
+  const prompt = readObjectString(source, "prompt") ?? "";
+  const tools = readObjectStringArray(source, "tools");
+  const disallowedTools = readObjectStringArray(source, "disallowedTools");
+  const model = readObjectString(source, "model");
+  const color = readObjectString(source, "color");
+  const frontmatter = stripUndefined2({
+    name,
+    description,
+    model,
+    color,
+    tools: tools?.join(", "),
+    "disallowed-tools": disallowedTools?.join(", ")
+  });
+  return `---
+${Object.entries(frontmatter).map(([key, value]) => `${key}: ${yamlScalar(value)}`).join("\n")}
+---
+
+${prompt.trim()}
+`;
+}
+
+// packages/compiler/src/plugin-components/commands.ts
+import { cp, lstat, mkdir as mkdir4, readdir as readdir3, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import path10 from "path";
+async function copyCommands(rootDir, destination) {
+  const source = path10.join(rootDir, "commands");
+  if (!existsSyncSafe(source)) {
+    return;
+  }
+  await mkdir4(destination, { recursive: true });
+  const entries = await readdir3(source, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = path10.join(source, entry.name);
+    if (entry.isFile() && entry.name.endsWith(".md")) {
+      if (await safeCommandCopyFilter(sourcePath)) {
+        await cp(sourcePath, path10.join(destination, safeFileStem(entry.name.replace(/\.md$/, "")) + ".md"));
+      }
+      continue;
+    }
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const dynamicCommand = path10.join(sourcePath, "command.ts");
+    if (existsSyncSafe(dynamicCommand)) {
+      const sourceText = await readFile5(dynamicCommand, "utf8");
+      const markdown = parseDynamicCommand(sourceText, entry.name);
+      const commandName = readObjectString(sourceText, "name") ?? entry.name;
+      await writeFile4(path10.join(destination, `${safeFileStem(commandName)}.md`), markdown);
+      continue;
+    }
+    await cp(sourcePath, path10.join(destination, entry.name), {
+      recursive: true,
+      filter: safeCommandCopyFilter
+    });
+  }
+}
+async function safeCommandCopyFilter(sourcePath) {
+  const basename = path10.basename(sourcePath);
+  if (basename === ".env" || basename.startsWith(".env.") || basename === "node_modules" || basename === ".git") {
+    return false;
+  }
+  const stat = await lstat(sourcePath);
+  return !stat.isSymbolicLink();
+}
+function parseDynamicCommand(source, fallbackName) {
+  const name = readObjectString(source, "name") ?? fallbackName;
+  const description = readObjectString(source, "description");
+  const prompt = readObjectString(source, "prompt") ?? "";
+  const argumentHint = readObjectString(source, "argumentHint");
+  const allowedTools = readObjectStringArray(source, "allowedTools");
+  const frontmatter = stripUndefined2({
+    description,
+    "argument-hint": argumentHint,
+    "allowed-tools": allowedTools?.join(", ")
+  });
+  const header = Object.keys(frontmatter).length ? `---
+${Object.entries(frontmatter).map(([key, value]) => `${key}: ${yamlScalar(value)}`).join("\n")}
+---
+
+` : "";
+  return `${header}${prompt.trim() || `# ${name}`}
+`;
+}
+
+// packages/compiler/src/plugin-components/hooks.ts
+import { mkdir as mkdir5, readdir as readdir4, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import path11 from "path";
+import {
+  Node as Node6,
+  Project as Project2,
+  SyntaxKind as SyntaxKind4
+} from "ts-morph";
+async function copyHooks(rootDir, destination) {
+  const source = path11.join(rootDir, "hooks");
+  if (!existsSyncSafe(source)) {
+    return;
+  }
+  const entries = await readdir4(source, { withFileTypes: true });
+  const hookDirs = entries.filter(
+    (entry) => entry.isDirectory() && existsSyncSafe(path11.join(source, entry.name, "hook.ts"))
+  );
+  if (!hookDirs.length) {
+    return;
+  }
+  const config = {};
+  for (const entry of hookDirs) {
+    const filePath = path11.join(source, entry.name, "hook.ts");
+    mergeHooks(config, parseHookFile(await readFile6(filePath, "utf8"), entry.name));
+  }
+  await mkdir5(destination, { recursive: true });
+  await writeFile5(
+    path11.join(destination, "hooks.json"),
+    `${JSON.stringify(config, null, 2)}
+`
+  );
+}
+function parseHookFile(source, fallbackName) {
+  const project = new Project2({ useInMemoryFileSystem: true });
+  const sourceFile = project.createSourceFile(`${fallbackName}.ts`, source);
+  const call = resolveDefaultExportCall(sourceFile, "hook") ?? resolveDefaultExportCall(sourceFile, "hooks");
+  if (!call) {
+    throw new Error(`hooks/${fallbackName}/hook.ts must default-export hook({ ... }) or hooks({ ... }).`);
+  }
+  const definition = unwrapExpression(call.getArguments()[0]);
+  if (!definition || !Node6.isObjectLiteralExpression(definition)) {
+    throw new Error(`hooks/${fallbackName}/hook.ts must default-export hook({ ... }) or hooks({ ... }).`);
+  }
+  const callee = call.getExpression().getText();
+  if (callee === "hook" || callee.endsWith(".hook")) {
+    const entry = parseHookDefinition(definition, fallbackName);
+    return { [entry.event]: [stripUndefined2({ matcher: entry.matcher, hooks: entry.run })] };
+  }
+  if (callee === "hooks" || callee.endsWith(".hooks")) {
+    return parseHooksDefinition(definition, fallbackName);
+  }
+  throw new Error(`hooks/${fallbackName}/hook.ts must default-export hook({ ... }) or hooks({ ... }).`);
+}
+function parseHookDefinition(definition, fallbackName) {
+  const event = readStringProperty3(definition, "event");
+  if (!event) {
+    throw new Error(`hooks/${fallbackName}/hook.ts must declare an event string.`);
+  }
+  const hooks = readHookArray(definition, "run", fallbackName);
+  if (!hooks.length) {
+    throw new Error(`hooks/${fallbackName}/hook.ts must declare at least one run handler.`);
+  }
+  return {
+    event,
+    matcher: readStringProperty3(definition, "matcher"),
+    run: hooks
+  };
+}
+function parseHooksDefinition(definition, fallbackName) {
+  const config = {};
+  for (const property of definition.getProperties()) {
+    if (!Node6.isPropertyAssignment(property)) {
+      continue;
+    }
+    const event = property.getName().replace(/^["']|["']$/g, "");
+    const initializer = property.getInitializer();
+    if (!initializer || !Node6.isArrayLiteralExpression(initializer)) {
+      throw new Error(`hooks/${fallbackName}/hook.ts event "${event}" must be an array.`);
+    }
+    config[event] = initializer.getElements().map((entry) => {
+      if (!Node6.isObjectLiteralExpression(entry)) {
+        throw new Error(`hooks/${fallbackName}/hook.ts event "${event}" entries must be objects.`);
+      }
+      return stripUndefined2({
+        matcher: readStringProperty3(entry, "matcher"),
+        hooks: readHookArray(entry, "run", fallbackName)
+      });
+    });
+  }
+  return config;
+}
+function readHookArray(definition, propertyName, fallbackName) {
+  const property = definition.getProperty(propertyName);
+  if (!property || !Node6.isPropertyAssignment(property)) {
+    return [];
+  }
+  const initializer = property.getInitializer();
+  if (!initializer || !Node6.isArrayLiteralExpression(initializer)) {
+    throw new Error(`hooks/${fallbackName}/hook.ts ${propertyName} must be an array.`);
+  }
+  return parseHookHandlers(initializer, fallbackName);
+}
+function parseHookHandlers(handlers, fallbackName) {
+  return handlers.getElements().map((handler) => parseHookHandler(handler, fallbackName));
+}
+function parseHookHandler(handler, fallbackName) {
+  if (Node6.isObjectLiteralExpression(handler)) {
+    const type = readStringProperty3(handler, "type");
+    if (type !== "command" && type !== "http") {
+      throw new Error(`hooks/${fallbackName}/hook.ts hook handlers need type "command" or "http".`);
+    }
+    return objectLiteralToRecord(handler);
+  }
+  if (Node6.isCallExpression(handler)) {
+    return parseHookHandlerCall(handler, fallbackName);
+  }
+  throw new Error(`hooks/${fallbackName}/hook.ts hook handlers must be objects or helper calls.`);
+}
+function parseHookHandlerCall(handler, fallbackName) {
+  const callee = handler.getExpression().getText();
+  const [firstArg, optionsArg] = handler.getArguments();
+  const first = firstArg ? stringFromExpression(firstArg) : void 0;
+  if (!first) {
+    throw new Error(`hooks/${fallbackName}/hook.ts hook helper calls require a string first argument.`);
+  }
+  const options = optionsArg && Node6.isObjectLiteralExpression(optionsArg) ? objectLiteralToRecord(optionsArg) : {};
+  if (callee.endsWith("commandHook")) {
+    return stripUndefined2({
+      type: "command",
+      command: first,
+      ...options
+    });
+  }
+  if (callee.endsWith("httpHook")) {
+    return stripUndefined2({
+      type: "http",
+      url: first,
+      ...options
+    });
+  }
+  throw new Error(`hooks/${fallbackName}/hook.ts uses an unsupported hook helper "${callee}".`);
+}
+function objectLiteralToRecord(object) {
+  const record = {};
+  for (const property of object.getProperties()) {
+    if (!Node6.isPropertyAssignment(property)) {
+      continue;
+    }
+    const key = property.getName().replace(/^["']|["']$/g, "");
+    const initializer = property.getInitializer();
+    if (!initializer) {
+      continue;
+    }
+    record[key] = valueFromExpression(initializer);
+  }
+  return stripUndefined2(record);
+}
+function readStringProperty3(object, propertyName) {
+  const property = object.getProperty(propertyName);
+  if (!property || !Node6.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = property.getInitializer();
+  return initializer ? stringFromExpression(initializer) : void 0;
+}
+function valueFromExpression(expression) {
+  const string = stringFromExpression(expression);
+  if (string !== void 0) {
+    return string;
+  }
+  if (expression.getKind() === SyntaxKind4.TrueKeyword) {
+    return true;
+  }
+  if (expression.getKind() === SyntaxKind4.FalseKeyword) {
+    return false;
+  }
+  if (Node6.isNumericLiteral(expression)) {
+    return Number(expression.getLiteralText());
+  }
+  if (Node6.isArrayLiteralExpression(expression)) {
+    return expression.getElements().map(valueFromExpression);
+  }
+  if (Node6.isObjectLiteralExpression(expression)) {
+    return objectLiteralToRecord(expression);
+  }
+  return void 0;
+}
+function stringFromExpression(expression) {
+  if (Node6.isStringLiteral(expression) || Node6.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.getLiteralText();
+  }
+  return void 0;
+}
+function mergeHooks(target, source) {
+  for (const [event, matchers] of Object.entries(source)) {
+    target[event] = [...target[event] ?? [], ...matchers];
+  }
+}
+
+// packages/compiler/src/plugin-components/passthrough.ts
+import { cp as cp2, lstat as lstat2 } from "fs/promises";
+import path12 from "path";
+async function copyClaudePassthroughDirectories(rootDir, pluginDir) {
+  for (const directory of [
+    "assets",
+    "bin",
+    "monitors",
+    "output-styles",
+    "themes"
+  ]) {
+    const source = path12.join(rootDir, directory);
+    if (!existsSyncSafe(source)) {
+      continue;
+    }
+    await cp2(source, path12.join(pluginDir, directory), {
+      recursive: true,
+      filter: safePluginCopyFilter
+    });
+  }
+}
+async function safePluginCopyFilter(sourcePath) {
+  const basename = path12.basename(sourcePath);
+  if (basename === "node_modules" || basename === ".git" || basename === ".env" || basename.startsWith(".env.")) {
+    return false;
+  }
+  const stat = await lstat2(sourcePath);
+  return !stat.isSymbolicLink();
+}
+
+// packages/compiler/src/plugin-components/skills.ts
+import { existsSync as existsSync4 } from "fs";
+import { cp as cp3, lstat as lstat3, mkdir as mkdir6, readdir as readdir5, readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
+import path13 from "path";
+async function copySkills(rootDir, destination) {
+  const source = path13.join(rootDir, "skills");
+  if (!existsSyncSafe(source)) {
+    return;
+  }
+  await mkdir6(destination, { recursive: true });
+  const entries = await readdir5(source, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const sourceDir = path13.join(source, entry.name);
+    const destinationDir = path13.join(destination, entry.name);
+    const staticSkill = path13.join(sourceDir, "SKILL.md");
+    const dynamicSkill = path13.join(sourceDir, "skill.ts");
+    await mkdir6(destinationDir, { recursive: true });
+    if (existsSync4(staticSkill)) {
+      await cp3(sourceDir, destinationDir, {
+        recursive: true,
+        filter: async (sourcePath) => !sourcePath.endsWith(`${path13.sep}skill.ts`) && await safeSkillCopyFilter(sourcePath)
+      });
+    } else if (existsSync4(dynamicSkill)) {
+      const generated = parseDynamicSkill(
+        await readFile7(dynamicSkill, "utf8"),
+        entry.name
+      );
+      await writeFile6(path13.join(destinationDir, "SKILL.md"), generated);
+    }
+  }
+}
+async function safeSkillCopyFilter(sourcePath) {
+  const basename = path13.basename(sourcePath);
+  if (basename === ".env" || basename.startsWith(".env.") || basename === "node_modules" || basename === ".git") {
+    return false;
+  }
+  const stat = await lstat3(sourcePath);
+  return !stat.isSymbolicLink();
+}
+function parseDynamicSkill(source, fallbackName) {
+  const name = readObjectString(source, "name") ?? fallbackName;
+  const description = readObjectString(source, "description") ?? `${name} skill.`;
+  const body = readObjectString(source, "body") ?? "";
+  return `---
+name: ${yamlScalar(name)}
+description: ${yamlScalar(description)}
+---
+
+${body.trim()}
+`;
+}
+
+// packages/compiler/src/plugins.ts
+async function buildPluginPackages(rootDir, outRoot, manifest) {
+  const identity = await loadProjectIdentity(rootDir);
+  await buildClaudePlugin(rootDir, outRoot, identity, manifest);
+}
+async function buildClaudePlugin(rootDir, outRoot, identity, manifest) {
+  const pluginDir = path14.join(outRoot, "claude-plugin");
+  await mkdir7(path14.join(pluginDir, ".claude-plugin"), { recursive: true });
+  await copySkills(rootDir, path14.join(pluginDir, "skills"));
+  await copyCommands(rootDir, path14.join(pluginDir, "commands"));
+  await copyHooks(rootDir, path14.join(pluginDir, "hooks"));
+  await emitClaudeAgents(rootDir, path14.join(pluginDir, "agents"));
+  await copyClaudePassthroughDirectories(rootDir, pluginDir);
+  await writeJson(path14.join(pluginDir, ".claude-plugin", "plugin.json"), {
+    name: identity.slug,
+    version: identity.version,
+    description: identity.description,
+    displayName: identity.name,
+    installationPreference: "available"
+  });
+  await writeJson(path14.join(pluginDir, "version.json"), {
+    version: identity.version,
+    generatedBy: "sidecar"
+  });
+  await writeJson(path14.join(pluginDir, ".mcp.json"), {
+    mcpServers: {
+      [identity.slug]: {
+        type: "http",
+        url: "${SIDECAR_MCP_URL}"
+      }
+    }
+  });
+  await writeJson(path14.join(pluginDir, "settings.json"), {
+    sidecar: {
+      tools: manifest.tools.map((entry) => entry.id),
+      resources: manifest.resources.map((entry) => entry.uri),
+      prompts: manifest.prompts.map((entry) => entry.name)
+    }
+  });
+  await writeFile7(
+    path14.join(pluginDir, "README.md"),
+    `# ${identity.name} Claude Plugin
+
+This package was generated by Sidecar.
+
+Set \`SIDECAR_MCP_URL\` to the hosted MCP endpoint for this app.
+
+For local testing, run \`sidecar dev --tunnel\` and use the printed HTTPS MCP URL.
+
+Claude/Cowork plugin-specific components such as skills, slash commands, agents, hooks, output styles, themes, monitors, assets, and bin scripts will be emitted here when the source project defines them.
+`
+  );
+}
+async function writeJson(filePath, value) {
+  await mkdir7(path14.dirname(filePath), { recursive: true });
+  await writeFile7(
+    filePath,
+    `${JSON.stringify(stripUndefined2(value), null, 2)}
+`
+  );
+}
+
+// packages/compiler/src/prompts.ts
+import { readdir as readdir6 } from "fs/promises";
+import path15 from "path";
+import {
+  Node as Node7,
+  SyntaxKind as SyntaxKind5
+} from "ts-morph";
+async function analyzeProjectPrompts(rootDir) {
+  const promptFiles = await findPromptFiles(path15.join(rootDir, "prompts"));
+  if (promptFiles.length === 0) {
+    return [];
+  }
+  const project = createProject(rootDir);
+  return promptFiles.map(
+    (filePath) => analyzePromptFile(project.addSourceFileAtPath(filePath), rootDir)
+  );
+}
+function analyzePromptFile(sourceFile, rootDir) {
+  const definition = findPromptDefinition(sourceFile);
+  const absoluteFile = sourceFile.getFilePath();
+  const directory = path15.basename(path15.dirname(absoluteFile));
+  const name = getOptionalStringProperty2(definition, "name") ?? safePathSegment(directory);
+  const title = getRequiredStringProperty2(definition, "title", sourceFile);
+  const description = getOptionalStringProperty2(definition, "description");
+  const args = readArgs(definition);
+  const descriptor = createPromptDescriptor({
+    name,
+    title,
+    description,
+    args,
+    icons: readIcons(definition)
+  });
+  if (!getMethodOrFunctionProperty(definition, "run")) {
+    throw new CompilerError(sourceFile, "prompt({ ... }) must include a run method.");
+  }
+  return {
+    sourceFile: path15.relative(rootDir, absoluteFile),
+    directory,
+    name,
+    title,
+    description,
+    args,
+    descriptor
+  };
+}
+async function findPromptFiles(promptsDir) {
+  if (!existsSyncSafe(promptsDir)) {
+    return [];
+  }
+  const entries = await readdir6(promptsDir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const filePath = path15.join(promptsDir, entry.name, "prompt.ts");
+    if (existsSyncSafe(filePath)) {
+      files.push(filePath);
+    }
+  }
+  return files.sort((left, right) => left.localeCompare(right));
+}
+function findPromptDefinition(sourceFile) {
+  const call = resolveDefaultExportCall(sourceFile, "prompt");
+  if (!call) {
+    throw new CompilerError(
+      sourceFile,
+      "prompt.ts must default-export prompt({ ... }) or an identifier initialized with prompt({ ... })."
+    );
+  }
+  const definition = unwrapExpression(call.getArguments()[0]);
+  if (!definition || !Node7.isObjectLiteralExpression(definition)) {
+    throw new CompilerError(sourceFile, "prompt(...) must receive one object literal.");
+  }
+  return definition;
+}
+function getRequiredStringProperty2(definition, propertyName, sourceFile) {
+  const value = getOptionalStringProperty2(definition, propertyName);
+  if (value === void 0 || !value.trim()) {
+    throw new CompilerError(
+      sourceFile,
+      `prompt({ ... }) must include a non-empty ${propertyName} string.`
+    );
+  }
+  return value;
+}
+function getOptionalStringProperty2(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
+  if (!property || !Node7.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  return initializer && Node7.isStringLiteral(initializer) ? initializer.getLiteralText() : void 0;
+}
+function readArgs(definition) {
+  const initializer = readObjectProperty4(definition, "args");
+  if (!initializer) {
+    return void 0;
+  }
+  const args = {};
+  for (const property of initializer.getProperties()) {
+    if (!Node7.isPropertyAssignment(property)) {
+      continue;
+    }
+    const value = readArgInput(property.getInitializer());
+    if (value !== void 0) {
+      args[property.getName().replace(/^["']|["']$/g, "")] = value;
+    }
+  }
+  return Object.keys(args).length ? args : void 0;
+}
+function readArgInput(node) {
+  const initializer = unwrapExpression(node);
+  if (!initializer) {
+    return void 0;
+  }
+  if (Node7.isStringLiteral(initializer)) {
+    return initializer.getLiteralText();
+  }
+  if (Node7.isArrayLiteralExpression(initializer)) {
+    return initializer.getElements().filter(Node7.isLiteralExpression).map((element) => element.getLiteralText());
+  }
+  if (Node7.isObjectLiteralExpression(initializer)) {
+    return {
+      description: getOptionalStringProperty2(initializer, "description"),
+      required: readBooleanProperty3(initializer, "required")
+    };
+  }
+  return void 0;
+}
+function readBooleanProperty3(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
+  if (!property || !Node7.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  if (!initializer) {
+    return void 0;
+  }
+  if (initializer.getKind() === SyntaxKind5.TrueKeyword) return true;
+  if (initializer.getKind() === SyntaxKind5.FalseKeyword) return false;
+  return void 0;
+}
+function getMethodOrFunctionProperty(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
+  if (Node7.isMethodDeclaration(property)) {
+    return property;
+  }
+  if (property && Node7.isPropertyAssignment(property)) {
+    const initializer = property.getInitializer();
+    if (initializer && (Node7.isArrowFunction(initializer) || Node7.isFunctionExpression(initializer))) {
+      return initializer;
+    }
+  }
+  return void 0;
+}
+function readIcons(definition) {
+  const property = definition.getProperty("icons");
+  if (!property || !Node7.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  if (!initializer || !Node7.isArrayLiteralExpression(initializer)) {
+    return void 0;
+  }
+  const icons = initializer.getElements().flatMap((element) => {
+    const object = unwrapExpression(element);
+    if (!object || !Node7.isObjectLiteralExpression(object)) {
+      return [];
+    }
+    const src = getOptionalStringProperty2(object, "src");
+    if (!src) {
+      return [];
+    }
+    return [{
+      src,
+      mimeType: getOptionalStringProperty2(object, "mimeType"),
+      sizes: readStringArrayProperty3(object, "sizes")
+    }];
+  });
+  return icons.length ? icons : void 0;
+}
+function readObjectProperty4(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
+  if (!property || !Node7.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  return initializer && Node7.isObjectLiteralExpression(initializer) ? initializer : void 0;
+}
+function readStringArrayProperty3(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
+  if (!property || !Node7.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  if (!initializer || !Node7.isArrayLiteralExpression(initializer)) {
+    return void 0;
+  }
+  return initializer.getElements().filter(Node7.isStringLiteral).map((element) => element.getLiteralText());
+}
+
+// packages/compiler/src/resources.ts
+import { readdir as readdir7 } from "fs/promises";
+import path16 from "path";
+import {
+  Node as Node8,
+  SyntaxKind as SyntaxKind6
+} from "ts-morph";
+async function analyzeProjectResources(rootDir) {
+  const resourceFiles = await findResourceFiles(path16.join(rootDir, "resources"));
+  if (resourceFiles.length === 0) {
+    return [];
+  }
+  const project = createProject(rootDir);
+  return resourceFiles.map(
+    (filePath) => analyzeResourceFile(project.addSourceFileAtPath(filePath), rootDir)
+  );
+}
+function analyzeResourceFile(sourceFile, rootDir) {
+  const definition = findResourceDefinition(sourceFile);
+  const absoluteFile = sourceFile.getFilePath();
+  const directory = path16.basename(path16.dirname(absoluteFile));
+  const defaultUri = `sidecar://resources/${safePathSegment(directory)}`;
+  const name = getRequiredStringProperty3(definition, "name", sourceFile);
+  const uri = getOptionalStringProperty3(definition, "uri") ?? defaultUri;
+  const descriptor = createResourceDescriptor({
+    uri,
+    name,
+    title: getOptionalStringProperty3(definition, "title"),
+    description: getOptionalStringProperty3(definition, "description"),
+    mimeType: getOptionalStringProperty3(definition, "mimeType"),
+    size: getOptionalNumberProperty(definition, "size"),
+    icons: readIcons2(definition),
+    annotations: readAnnotations2(definition)
+  });
+  if (!getMethodOrFunctionProperty2(definition, "read")) {
+    throw new CompilerError(sourceFile, "resource({ ... }) must include a read method.");
+  }
+  return {
+    sourceFile: path16.relative(rootDir, absoluteFile),
+    directory,
+    uri,
+    name,
+    title: descriptor.title,
+    description: descriptor.description,
+    mimeType: descriptor.mimeType,
+    size: descriptor.size,
+    annotations: descriptor.annotations,
+    subscribe: readBooleanProperty4(definition, "subscribe"),
+    descriptor
+  };
+}
+async function findResourceFiles(resourcesDir) {
+  if (!existsSyncSafe(resourcesDir)) {
+    return [];
+  }
+  const entries = await readdir7(resourcesDir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const filePath = path16.join(resourcesDir, entry.name, "resource.ts");
+    if (existsSyncSafe(filePath)) {
+      files.push(filePath);
+    }
+  }
+  return files.sort((left, right) => left.localeCompare(right));
+}
+function findResourceDefinition(sourceFile) {
+  const call = resolveDefaultExportCall(sourceFile, "resource");
+  if (!call) {
+    throw new CompilerError(
+      sourceFile,
+      "resource.ts must default-export resource({ ... }) or an identifier initialized with resource({ ... })."
+    );
+  }
+  const definition = unwrapExpression(call.getArguments()[0]);
+  if (!definition || !Node8.isObjectLiteralExpression(definition)) {
+    throw new CompilerError(sourceFile, "resource(...) must receive one object literal.");
+  }
+  return definition;
+}
+function getRequiredStringProperty3(definition, propertyName, sourceFile) {
+  const value = getOptionalStringProperty3(definition, propertyName);
+  if (value === void 0 || !value.trim()) {
+    throw new CompilerError(
+      sourceFile,
+      `resource({ ... }) must include a non-empty ${propertyName} string.`
+    );
+  }
+  return value;
+}
+function getOptionalStringProperty3(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
+  if (!property || !Node8.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  return initializer && Node8.isStringLiteral(initializer) ? initializer.getLiteralText() : void 0;
+}
+function getOptionalNumberProperty(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
+  if (!property || !Node8.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  return initializer && Node8.isNumericLiteral(initializer) ? Number(initializer.getLiteralText()) : void 0;
+}
+function readBooleanProperty4(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
+  if (!property || !Node8.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  if (!initializer) {
+    return void 0;
+  }
+  if (initializer.getKind() === SyntaxKind6.TrueKeyword) return true;
+  if (initializer.getKind() === SyntaxKind6.FalseKeyword) return false;
+  return void 0;
+}
+function getMethodOrFunctionProperty2(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
+  if (Node8.isMethodDeclaration(property)) {
+    return property;
+  }
+  if (property && Node8.isPropertyAssignment(property)) {
+    const initializer = property.getInitializer();
+    if (initializer && (Node8.isArrowFunction(initializer) || Node8.isFunctionExpression(initializer))) {
+      return initializer;
+    }
+  }
+  return void 0;
+}
+function readAnnotations2(definition) {
+  const initializer = readObjectProperty5(definition, "annotations");
+  if (!initializer) {
+    return void 0;
+  }
+  const annotations = {};
+  const audience = readStringArrayProperty4(initializer, "audience")?.filter((value) => value === "user" || value === "assistant");
+  const priority = getOptionalNumberProperty(initializer, "priority");
+  const lastModified = getOptionalStringProperty3(initializer, "lastModified");
+  if (audience?.length) annotations.audience = audience;
+  if (priority !== void 0) annotations.priority = priority;
+  if (lastModified) annotations.lastModified = lastModified;
+  return Object.keys(annotations).length ? annotations : void 0;
+}
+function readIcons2(definition) {
+  const property = definition.getProperty("icons");
+  if (!property || !Node8.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  if (!initializer || !Node8.isArrayLiteralExpression(initializer)) {
+    return void 0;
+  }
+  const icons = initializer.getElements().flatMap((element) => {
+    const object = unwrapExpression(element);
+    if (!object || !Node8.isObjectLiteralExpression(object)) {
+      return [];
+    }
+    const src = getOptionalStringProperty3(object, "src");
+    if (!src) {
+      return [];
+    }
+    return [{
+      src,
+      mimeType: getOptionalStringProperty3(object, "mimeType"),
+      sizes: readStringArrayProperty4(object, "sizes")
+    }];
+  });
+  return icons.length ? icons : void 0;
+}
+function readObjectProperty5(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
+  if (!property || !Node8.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  return initializer && Node8.isObjectLiteralExpression(initializer) ? initializer : void 0;
+}
+function readStringArrayProperty4(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
+  if (!property || !Node8.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  if (!initializer || !Node8.isArrayLiteralExpression(initializer)) {
+    return void 0;
+  }
+  return initializer.getElements().filter(Node8.isStringLiteral).map((element) => element.getLiteralText());
+}
+
+// packages/compiler/src/build.ts
+async function buildProject(options) {
+  const rootDir = path17.resolve(options.rootDir);
+  const target = options.target ?? "mcp";
+  const config = analyzeProjectConfig(rootDir);
+  const tools = await analyzeProjectTools(rootDir, { target });
+  const resources = await analyzeProjectResources(rootDir);
+  const resourceTemplates = [];
+  const prompts = await analyzeProjectPrompts(rootDir);
+  const diagnostics = await collectProjectDiagnostics(rootDir, {
+    tools,
+    resources,
+    prompts,
+    config
+  });
+  const errors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+  if (errors.length) {
+    throw new Error(errors.map(formatDiagnostic).join("\n"));
+  }
+  const outDir = resolveInsideRoot(rootDir, options.outDir ?? "out/mcp");
+  await buildWidgets(rootDir, outDir, tools);
+  const manifest = {
+    version: 1,
+    target,
+    rootDir: ".",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    config,
+    tools,
+    resources,
+    resourceTemplates,
+    prompts,
+    diagnostics
+  };
+  await mkdir8(outDir, { recursive: true });
+  await writeFile8(
+    path17.join(outDir, "manifest.sidecar.json"),
+    `${JSON.stringify(manifest, null, 2)}
+`
+  );
+  await writeFile8(path17.join(outDir, "README.md"), renderMcpReadme(manifest));
+  await writeGeneratedTypes(rootDir, tools);
+  if (options.plugins) {
+    await buildPluginPackages(rootDir, path17.dirname(outDir), manifest);
+  }
+  return manifest;
+}
+function resolveInsideRoot(rootDir, output) {
+  const resolved = path17.resolve(rootDir, output);
+  const relative = path17.relative(rootDir, resolved);
+  if (relative.startsWith("..") || path17.isAbsolute(relative)) {
+    throw new Error(`Build output must stay inside the project root: ${output}`);
+  }
+  return resolved;
+}
+function renderMcpReadme(manifest) {
+  const tools = manifest.tools.map((toolEntry) => `- \`${toolEntry.id}\`: ${toolEntry.description}`).join("\n");
+  const resources = manifest.resources.map((resourceEntry) => `- \`${resourceEntry.uri}\`: ${resourceEntry.description ?? resourceEntry.name}`).join("\n");
+  const prompts = manifest.prompts.map((promptEntry) => `- \`${promptEntry.name}\`: ${promptEntry.description ?? promptEntry.title}`).join("\n");
+  return `# Sidecar MCP Build
+
+Generated by Sidecar.
+
+## Tools
+
+${tools || "No tools detected."}
+
+## Resources
+
+${resources || "No resources detected."}
+
+## Prompts
+
+${prompts || "No prompts detected."}
+
+## Local HTTPS Testing
+
+Run \`sidecar dev --tunnel\` from the project root to start the local MCP server on Streamable HTTP and print an HTTPS MCP URL that can be added to ChatGPT, Claude, or a Claude plugin install.
+`;
+}
+
+// packages/server/src/index.ts
+import { createServer } from "http";
+import { randomUUID as randomUUID2 } from "crypto";
+
+// packages/server/src/proxy.ts
+import { randomUUID } from "crypto";
+var proxyBrand = /* @__PURE__ */ Symbol.for("sidecar.proxy");
+function isSidecarProxy(value) {
+  return Boolean(
+    value && typeof value === "object" && value[proxyBrand] === true
+  );
+}
+async function runProxy(proxyConfig, request) {
+  for (const middleware of proxyConfig?.before ?? []) {
+    const result = await middleware(request);
+    if (result) {
+      return result;
+    }
+  }
+  return void 0;
+}
+
+// packages/server/src/index.ts
+import { JSONRPC_VERSION } from "@modelcontextprotocol/sdk/types.js";
+var SIDECAR_MCP_PROTOCOL_VERSION = "2025-11-25";
+var SidecarMcpServer = class {
+  constructor(options) {
+    this.options = options;
+    for (const loaded of options.tools) {
+      const descriptorProvided = Boolean(loaded.descriptor);
+      const descriptor = loaded.descriptor ?? createToolDescriptor(loaded.tool);
+      if (this.tools.has(descriptor.name)) {
+        throw new Error(`Duplicate Sidecar tool id "${descriptor.name}".`);
+      }
+      this.tools.set(descriptor.name, { ...loaded, descriptor, descriptorProvided });
+    }
+    for (const resource of options.resources ?? []) {
+      if (this.resources.has(resource.uri)) {
+        throw new Error(`Duplicate Sidecar resource uri "${resource.uri}".`);
+      }
+      const descriptor = resource.descriptor ?? {
+        uri: resource.uri,
+        name: resource.name ?? resource.uri,
+        description: resource.description,
+        mimeType: resource.mimeType,
+        _meta: resource._meta
+      };
+      this.resources.set(resource.uri, { ...resource, descriptor });
+    }
+    for (const loaded of options.prompts ?? []) {
+      const descriptor = loaded.descriptor ?? {
+        name: loaded.prompt.name ?? loaded.prompt.title,
+        title: loaded.prompt.title,
+        description: loaded.prompt.description
+      };
+      if (this.prompts.has(descriptor.name)) {
+        throw new Error(`Duplicate Sidecar prompt name "${descriptor.name}".`);
+      }
+      this.prompts.set(descriptor.name, { ...loaded, descriptor });
+    }
+    this.resourceTemplates = options.resourceTemplates ?? [];
+  }
+  options;
+  tools = /* @__PURE__ */ new Map();
+  resources = /* @__PURE__ */ new Map();
+  prompts = /* @__PURE__ */ new Map();
+  resourceTemplates;
+  /** Returns all tool descriptors exposed through `tools/list`. */
+  descriptors() {
+    return [...this.tools.values()].map((loaded) => loaded.descriptor);
+  }
+  /** Returns all resource descriptors exposed through `resources/list`. */
+  resourceDescriptors() {
+    return [...this.resources.values()].map((loaded) => loaded.descriptor);
+  }
+  /** Returns all prompt descriptors exposed through `prompts/list`. */
+  promptDescriptors() {
+    return [...this.prompts.values()].map((loaded) => loaded.descriptor);
+  }
+  /** Handles a JSON-RPC request or notification. */
+  async handle(request, context = {}) {
+    if (request.id === void 0) {
+      await this.authorizeEndpoint(context);
+      await this.handleNotification(request);
+      return void 0;
+    }
+    try {
+      const authSession = await this.authorizeEndpoint(context);
+      const authorizedContext = { ...context, authSession };
+      const result = await this.dispatch(request, authorizedContext);
+      return {
+        jsonrpc: JSONRPC_VERSION,
+        id: request.id,
+        result
+      };
+    } catch (error) {
+      return {
+        jsonrpc: JSONRPC_VERSION,
+        id: request.id,
+        error: normalizeError(error)
+      };
+    }
+  }
+  /** Routes an MCP method to its implementation. */
+  async dispatch(request, context) {
+    switch (request.method) {
+      case "initialize":
+        return {
+          protocolVersion: SIDECAR_MCP_PROTOCOL_VERSION,
+          capabilities: this.capabilities(),
+          serverInfo: {
+            name: this.options.name ?? "sidecar",
+            version: this.options.version ?? "0.0.0-dev"
+          }
+        };
+      case "tools/list":
+        return this.listTools(request, context);
+      case "tools/call":
+        return this.callTool(request, context);
+      case "resources/list":
+        return this.listResources(request, context);
+      case "resources/read":
+        return this.readResource(request, context);
+      case "resources/templates/list":
+        return this.listResourceTemplates(request, context);
+      case "resources/subscribe":
+        return this.subscribeResource(request);
+      case "resources/unsubscribe":
+        return this.unsubscribeResource(request);
+      case "prompts/list":
+        return this.listPrompts(request, context);
+      case "prompts/get":
+        return this.getPrompt(request, context);
+      default:
+        throw new JsonRpcError(-32601, `Unsupported method "${request.method}".`);
+    }
+  }
+  /** Builds the MCP server capability object from implemented runtime features. */
+  capabilities() {
+    const configured = this.options.capabilities ?? {};
+    return stripUndefined4({
+      tools: stripUndefined4({
+        listChanged: configured.tools?.listChanged || void 0
+      }),
+      resources: stripUndefined4({
+        subscribe: configured.resources?.subscribe || void 0,
+        listChanged: configured.resources?.listChanged || void 0
+      }),
+      prompts: this.prompts.size || configured.prompts?.listChanged ? stripUndefined4({
+        listChanged: configured.prompts?.listChanged || void 0
+      }) : void 0
+    });
+  }
+  /** Lists tools with MCP cursor pagination. */
+  async listTools(request, context) {
+    const page = await this.paginate("tools/list", this.descriptors(), request, context);
+    return stripUndefined4({
+      tools: [...page.items],
+      nextCursor: page.nextCursor
+    });
+  }
+  /** Lists resources with MCP cursor pagination. */
+  async listResources(request, context) {
+    const page = await this.paginate("resources/list", this.resourceDescriptors(), request, context);
+    return stripUndefined4({
+      resources: [...page.items],
+      nextCursor: page.nextCursor
+    });
+  }
+  /** Lists resource templates with MCP cursor pagination. */
+  async listResourceTemplates(request, context) {
+    const page = await this.paginate(
+      "resources/templates/list",
+      this.resourceTemplates.map((entry) => entry.descriptor),
+      request,
+      context
+    );
+    return stripUndefined4({
+      resourceTemplates: [...page.items],
+      nextCursor: page.nextCursor
+    });
+  }
+  /** Lists prompts with MCP cursor pagination. */
+  async listPrompts(request, context) {
+    const page = await this.paginate("prompts/list", this.promptDescriptors(), request, context);
+    return stripUndefined4({
+      prompts: [...page.items],
+      nextCursor: page.nextCursor
+    });
+  }
+  /** Applies configured or default cursor pagination to one supported list operation. */
+  async paginate(operation, items, request, context) {
+    const cursor = readCursorParam(request);
+    const pageSize = this.pageSize();
+    const override = selectPaginationOverride(this.options.pagination?.override, operation);
+    if (override) {
+      return override({
+        operation,
+        items,
+        cursor,
+        pageSize,
+        auth: context.authSession
+      });
+    }
+    return defaultPagination(items, cursor, pageSize);
+  }
+  /** Returns the server-chosen page size for all built-in list pagination. */
+  pageSize() {
+    const configured = this.options.pagination?.pageSize;
+    return configured && configured > 0 ? Math.floor(configured) : 10;
+  }
+  /** Executes a tool after request-level and tool-level auth checks. */
+  async callTool(request, context) {
+    const params = request.params;
+    const name = typeof params?.name === "string" ? params.name : void 0;
+    if (!name) {
+      throw new JsonRpcError(-32602, "tools/call requires params.name.");
+    }
+    const loaded = this.tools.get(name);
+    if (!loaded) {
+      throw new JsonRpcError(-32602, `Unknown tool "${name}".`);
+    }
+    const authSession = await this.authorizeTool(loaded, context);
+    const ctx = this.options.createContext ? await this.options.createContext(request) : createDefaultContext(request);
+    if (authSession !== void 0) {
+      ctx.auth = authSession;
+    }
+    const controller = new AbortController();
+    ctx.request = {
+      ...ctx.request,
+      signal: controller.signal
+    };
+    const args = loaded.descriptorProvided ? validateAgainstSchema(
+      loaded.descriptor.inputSchema,
+      params?.arguments ?? {},
+      `Invalid parameters for tool "${name}".`
+    ) : params?.arguments ?? {};
+    const result = await withTimeout(
+      executeTool(loaded.tool, args, ctx),
+      this.options.toolTimeoutMs,
+      controller
+    );
+    if (loaded.descriptorProvided) {
+      validateAgainstSchema(
+        loaded.descriptor.outputSchema,
+        result.structuredContent,
+        `Invalid structuredContent returned by tool "${name}".`
+      );
+    }
+    return result;
+  }
+  /** Authenticates the whole HTTP MCP request when auth.ts is configured. */
+  async authorizeEndpoint(context) {
+    if (context.authSession !== void 0) {
+      return context.authSession;
+    }
+    if (!this.options.auth) {
+      return void 0;
+    }
+    const request = context.request ?? new Request(this.options.auth.resource);
+    const requestAuth = await this.options.auth.authorizeRequest(request);
+    if (!requestAuth.ok) {
+      throw authJsonRpcError(requestAuth);
+    }
+    return requestAuth.auth;
+  }
+  /** Applies Sidecar auth policy for a tool call. */
+  async authorizeTool(loaded, context) {
+    const policy = loaded.tool.auth;
+    if (!this.options.auth) {
+      if (policy && policy.public !== true) {
+        throw new JsonRpcError(
+          -32001,
+          `Tool "${loaded.descriptor?.name ?? loaded.tool.name}" requires auth, but no auth.ts configuration is loaded.`
+        );
+      }
+      return void 0;
+    }
+    const authSession = context.authSession ?? await this.authorizeEndpoint(context);
+    const toolAuth = this.options.auth.authorizeTool(policy, authSession);
+    if (!toolAuth.ok) {
+      throw authJsonRpcError(toolAuth);
+    }
+    return toolAuth.auth;
+  }
+  /** Reads a generated widget or authored resource by URI. */
+  async readResource(request, context) {
+    const params = request.params;
+    const uri = typeof params?.uri === "string" ? params.uri : void 0;
+    if (!uri) {
+      throw new JsonRpcError(-32602, "resources/read requires params.uri.");
+    }
+    const resource = this.resources.get(uri);
+    if (!resource) {
+      throw new JsonRpcError(-32002, `Resource not found: "${uri}".`, { uri });
+    }
+    if (resource.resource) {
+      const toolContext = this.options.createContext ? await this.options.createContext(request) : createDefaultContext(request);
+      if (context.authSession !== void 0) {
+        toolContext.auth = context.authSession;
+      }
+      return executeResource(resource.resource, toResourceContext(toolContext), {
+        uri,
+        mimeType: resource.descriptor.mimeType
+      });
+    }
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: resource.mimeType ?? "text/plain",
+          text: resource.text ?? "",
+          _meta: resource._meta
+        }
+      ]
+    };
+  }
+  /** Accepts a resource subscription when server-level support is enabled. */
+  subscribeResource(request) {
+    if (!this.options.capabilities?.resources?.subscribe) {
+      throw new JsonRpcError(-32601, "Resource subscriptions are not enabled.");
+    }
+    const uri = readUriParam(request, "resources/subscribe");
+    if (!this.resources.has(uri)) {
+      throw new JsonRpcError(-32002, `Resource not found: "${uri}".`, { uri });
+    }
+    return {};
+  }
+  /** Accepts a resource unsubscription when server-level support is enabled. */
+  unsubscribeResource(request) {
+    if (!this.options.capabilities?.resources?.subscribe) {
+      throw new JsonRpcError(-32601, "Resource subscriptions are not enabled.");
+    }
+    const uri = readUriParam(request, "resources/unsubscribe");
+    if (!this.resources.has(uri)) {
+      throw new JsonRpcError(-32002, `Resource not found: "${uri}".`, { uri });
+    }
+    return {};
+  }
+  /** Renders one named prompt with validated arguments. */
+  async getPrompt(request, context) {
+    const params = request.params;
+    const name = typeof params?.name === "string" ? params.name : void 0;
+    if (!name) {
+      throw new JsonRpcError(-32602, "prompts/get requires params.name.");
+    }
+    const loaded = this.prompts.get(name);
+    if (!loaded) {
+      throw new JsonRpcError(-32602, `Unknown prompt "${name}".`);
+    }
+    const toolContext = this.options.createContext ? await this.options.createContext(request) : createDefaultContext(request);
+    if (context.authSession !== void 0) {
+      toolContext.auth = context.authSession;
+    }
+    return executePrompt(loaded.prompt, params?.arguments ?? {}, toPromptContext(toolContext));
+  }
+  /** Accepts notifications without side effects for client compatibility. */
+  async handleNotification(_request) {
+  }
+};
+function createSidecarMcpServer(options) {
+  return new SidecarMcpServer(options);
+}
+function createSidecarHttpServer(options) {
+  const mcp = createSidecarMcpServer(options);
+  const endpoint = options.path ?? "/mcp";
+  const maxBodyBytes = options.maxBodyBytes ?? 1e6;
+  return createServer(async (request, response) => {
+    if (isRejectedOrigin(request, options.allowedOrigins)) {
+      response.writeHead(403, { "content-type": "application/json" });
+      response.end(JSON.stringify({ error: "forbidden_origin" }));
+      return;
+    }
+    const proxyResult = await runProxy(options.proxy, request);
+    if (proxyResult) {
+      response.writeHead(proxyResult.status, proxyResult.headers);
+      response.end(proxyResult.body ?? "");
+      return;
+    }
+    const pathname = request.url?.split("?")[0];
+    if (options.auth && request.method === "GET" && isProtectedResourceMetadataPath(pathname, endpoint)) {
+      response.writeHead(200, { "content-type": "application/json" });
+      response.end(JSON.stringify(options.auth.metadata()));
+      return;
+    }
+    if (request.method === "GET" && pathname === endpoint) {
+      response.writeHead(405, { "content-type": "application/json" });
+      response.end(JSON.stringify({ error: "sse_not_supported" }));
+      return;
+    }
+    if (request.method !== "POST" || pathname !== endpoint) {
+      response.writeHead(404, { "content-type": "application/json" });
+      response.end(JSON.stringify({ error: "not_found" }));
+      return;
+    }
+    try {
+      validateProtocolVersion(request);
+      validatePostHeaders(request);
+      const body = await readJson(request, maxBodyBytes);
+      if (Array.isArray(body)) {
+        throw new JsonRpcHttpError(400, -32600, "JSON-RPC batches are not supported by MCP Streamable HTTP.");
+      }
+      if (isJsonRpcResponseMessage(body)) {
+        response.writeHead(202);
+        response.end();
+        return;
+      }
+      const rpcRequest = assertJsonRpcRequest(body);
+      const fetchRequest = toFetchRequest(request, options.publicUrl ?? options.auth?.resource);
+      const authSession = options.auth ? await authorizeHttpRequest(options.auth, fetchRequest, response) : void 0;
+      if (options.auth && authSession === AUTH_RESPONSE_SENT) {
+        return;
+      }
+      const payload = await mcp.handle(rpcRequest, {
+        request: fetchRequest,
+        authSession
+      }) ?? null;
+      const responses = payload === null ? [] : [payload];
+      if (!responses.length) {
+        response.writeHead(202);
+        response.end();
+        return;
+      }
+      const authError = httpAuthError(payload);
+      response.writeHead(authError?.status ?? 200, {
+        "content-type": "application/json",
+        ...authError?.headers ?? {}
+      });
+      response.end(JSON.stringify(payload));
+    } catch (error) {
+      const status = error instanceof JsonRpcHttpError ? error.status : 400;
+      response.writeHead(status, { "content-type": "application/json" });
+      response.end(
+        JSON.stringify({
+          jsonrpc: JSONRPC_VERSION,
+          id: null,
+          error: normalizeHttpError(error)
+        })
+      );
+    }
+  });
+}
+var DEFAULT_ALLOWED_ORIGINS = [
+  "https://chatgpt.com",
+  "https://chat.openai.com",
+  "https://claude.ai",
+  "https://*.claude.ai"
+];
+function isRejectedOrigin(request, allowedOrigins = []) {
+  const origin = request.headers.origin;
+  if (!origin) {
+    return false;
+  }
+  const host = request.headers.host ?? "";
+  let originUrl;
+  try {
+    originUrl = new URL(origin);
+  } catch {
+    return true;
+  }
+  if (isLocalHost(host)) {
+    return !isLocalHost(originUrl.host);
+  }
+  const requestOrigin = `https://${host}`;
+  const allowed = [requestOrigin, ...DEFAULT_ALLOWED_ORIGINS, ...allowedOrigins];
+  return !allowed.some((pattern) => matchesOrigin(pattern, originUrl.origin));
+}
+function isLocalHost(host) {
+  if (host.startsWith("[::1]")) {
+    return true;
+  }
+  const hostname = host.split(":")[0]?.toLowerCase();
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
+}
+function matchesOrigin(pattern, origin) {
+  if (pattern === origin) {
+    return true;
+  }
+  if (!pattern.includes("*")) {
+    return false;
+  }
+  const escaped = pattern.split("*").map(escapeRegExp).join("[^.]+");
+  return new RegExp(`^${escaped}$`).test(origin);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isProtectedResourceMetadataPath(pathname, endpoint) {
+  return pathname === "/.well-known/oauth-protected-resource" || pathname === `/.well-known/oauth-protected-resource${endpoint}`;
+}
+var JsonRpcError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "JsonRpcError";
+  }
+  code;
+  data;
+};
+var JsonRpcHttpError = class extends JsonRpcError {
+  constructor(status, code, message, data) {
+    super(code, message, data);
+    this.status = status;
+    this.name = "JsonRpcHttpError";
+  }
+  status;
+};
+var AUTH_RESPONSE_SENT = /* @__PURE__ */ Symbol("sidecar.auth.response-sent");
+async function authorizeHttpRequest(auth, request, response) {
+  const result = await auth.authorizeRequest(request);
+  if (result.ok) {
+    return result.auth;
+  }
+  response.writeHead(result.status, {
+    "content-type": "application/json",
+    ...headersToRecord(result.headers)
+  });
+  response.end(
+    JSON.stringify({
+      jsonrpc: JSONRPC_VERSION,
+      id: null,
+      error: {
+        code: result.status === 401 ? -32001 : -32003,
+        message: result.body.error_description ?? result.body.error,
+        data: {
+          status: result.status,
+          body: result.body
+        }
+      }
+    })
+  );
+  return AUTH_RESPONSE_SENT;
+}
+function createDefaultContext(request) {
+  const memory = /* @__PURE__ */ new Map();
+  return {
+    auth: void 0,
+    request: {
+      id: String(request.id ?? randomUUID2()),
+      signal: new AbortController().signal,
+      host: "unknown",
+      transport: "streamable-http"
+    },
+    services: {},
+    tools: {},
+    log: consoleLogger,
+    trace: {
+      async span(_name, run) {
+        return run();
+      }
+    },
+    storage: {
+      async get(key) {
+        return memory.get(key);
+      },
+      async set(key, value) {
+        memory.set(key, value);
+      },
+      async delete(key) {
+        memory.delete(key);
+      }
+    },
+    env: process.env
+  };
+}
+function toResourceContext(ctx) {
+  return {
+    auth: ctx.auth,
+    request: ctx.request,
+    services: ctx.services,
+    log: ctx.log,
+    storage: ctx.storage,
+    env: ctx.env
+  };
+}
+function toPromptContext(ctx) {
+  return {
+    auth: ctx.auth,
+    request: ctx.request,
+    services: ctx.services,
+    log: ctx.log,
+    storage: ctx.storage,
+    env: ctx.env
+  };
+}
+function readCursorParam(request) {
+  const params = request.params;
+  if (params?.cursor === void 0) {
+    return void 0;
+  }
+  if (typeof params.cursor !== "string" || !params.cursor) {
+    throw new JsonRpcError(-32602, "Pagination cursor must be a non-empty string.");
+  }
+  return params.cursor;
+}
+function readUriParam(request, method) {
+  const params = request.params;
+  const uri = typeof params?.uri === "string" ? params.uri : void 0;
+  if (!uri) {
+    throw new JsonRpcError(-32602, `${method} requires params.uri.`);
+  }
+  return uri;
+}
+function selectPaginationOverride(override, operation) {
+  if (!override) {
+    return void 0;
+  }
+  if (typeof override === "function") {
+    return override;
+  }
+  const key = operationToPaginationKey(operation);
+  return override[key] ?? override.default;
+}
+function operationToPaginationKey(operation) {
+  switch (operation) {
+    case "tools/list":
+      return "toolsList";
+    case "resources/list":
+      return "resourcesList";
+    case "resources/templates/list":
+      return "resourceTemplatesList";
+    case "prompts/list":
+      return "promptsList";
+  }
+}
+function defaultPagination(items, cursor, pageSize) {
+  const offset = cursor ? decodeCursor(cursor) : 0;
+  const page = items.slice(offset, offset + pageSize);
+  const nextOffset = offset + page.length;
+  return {
+    items: page,
+    nextCursor: nextOffset < items.length ? encodeCursor(nextOffset) : void 0
+  };
+}
+function encodeCursor(offset) {
+  return Buffer.from(JSON.stringify({ offset }), "utf8").toString("base64url");
+}
+function decodeCursor(cursor) {
+  try {
+    const decoded = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+    const offset = decoded.offset;
+    if (!Number.isInteger(offset) || typeof offset !== "number" || offset < 0) {
+      throw new Error("invalid offset");
+    }
+    return offset;
+  } catch {
+    throw new JsonRpcError(-32602, "Invalid pagination cursor.");
+  }
+}
+function authJsonRpcError(result) {
+  return new JsonRpcError(
+    result.status === 401 ? -32001 : -32003,
+    result.body.error_description ?? result.body.error,
+    {
+      status: result.status,
+      headers: headersToRecord(result.headers),
+      body: result.body
+    }
+  );
+}
+function validateProtocolVersion(request) {
+  const value = request.headers["mcp-protocol-version"];
+  const version = Array.isArray(value) ? value[0] : value;
+  if (!version) {
+    return;
+  }
+  const supported = /* @__PURE__ */ new Set([SIDECAR_MCP_PROTOCOL_VERSION]);
+  if (!supported.has(version)) {
+    throw new JsonRpcHttpError(
+      400,
+      -32600,
+      `Unsupported MCP-Protocol-Version "${version}".`
+    );
+  }
+}
+function validatePostHeaders(request) {
+  const contentType = request.headers["content-type"];
+  const contentTypeValue = Array.isArray(contentType) ? contentType[0] : contentType;
+  if (!contentTypeValue?.toLowerCase().includes("application/json")) {
+    throw new JsonRpcHttpError(415, -32600, "POST Content-Type must be application/json.");
+  }
+  const accept = request.headers.accept;
+  const acceptValue = Array.isArray(accept) ? accept.join(",") : accept;
+  if (!acceptValue || !acceptValue.toLowerCase().includes("application/json") || !acceptValue.toLowerCase().includes("text/event-stream")) {
+    throw new JsonRpcHttpError(
+      406,
+      -32600,
+      "POST Accept must include application/json and text/event-stream."
+    );
+  }
+}
+async function withTimeout(promise, timeoutMs, controller) {
+  if (!timeoutMs || timeoutMs <= 0) {
+    return promise;
+  }
+  let timeout;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_resolve, reject) => {
+        timeout = setTimeout(() => {
+          controller.abort();
+          reject(new JsonRpcError(-32e3, "Tool execution timed out."));
+        }, timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+}
+function validateAgainstSchema(schema, value, message, options = {}) {
+  if (!schema || value === void 0 && options.optional) {
+    return value;
+  }
+  const failure = schemaFailure(schema, value, "$");
+  if (failure) {
+    throw new JsonRpcError(-32602, message, { validation: failure });
+  }
+  return value;
+}
+function schemaFailure(schema, value, path19) {
+  if (schema.anyOf?.length && !schema.anyOf.some((entry) => !schemaFailure(entry, value, path19))) {
+    return `${path19} must match one anyOf schema.`;
+  }
+  if (schema.oneOf?.length && schema.oneOf.filter((entry) => !schemaFailure(entry, value, path19)).length !== 1) {
+    return `${path19} must match exactly one oneOf schema.`;
+  }
+  if (schema.allOf?.length) {
+    for (const entry of schema.allOf) {
+      const failure = schemaFailure(entry, value, path19);
+      if (failure) return failure;
+    }
+  }
+  if (schema.const !== void 0 && value !== schema.const) {
+    return `${path19} must equal ${JSON.stringify(schema.const)}.`;
+  }
+  if (schema.enum && !schema.enum.some((entry) => JSON.stringify(entry) === JSON.stringify(value))) {
+    return `${path19} must be one of the declared enum values.`;
+  }
+  if (schema.type) {
+    const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+    if (!types.some((type) => matchesJsonSchemaType(type, value))) {
+      return `${path19} must be ${types.join(" or ")}.`;
+    }
+  }
+  if (schema.type === "object" || schema.properties || schema.required) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return `${path19} must be an object.`;
+    }
+    const record = value;
+    for (const required of schema.required ?? []) {
+      if (!(required in record)) {
+        return `${path19}.${required} is required.`;
+      }
+    }
+    for (const [key, propertySchema] of Object.entries(schema.properties ?? {})) {
+      if (key in record) {
+        const failure = schemaFailure(propertySchema, record[key], `${path19}.${key}`);
+        if (failure) return failure;
+      }
+    }
+    if (schema.additionalProperties === false) {
+      const allowed = new Set(Object.keys(schema.properties ?? {}));
+      const extra = Object.keys(record).find((key) => !allowed.has(key));
+      if (extra) {
+        return `${path19}.${extra} is not allowed.`;
+      }
+    }
+  }
+  if (schema.type === "array" || schema.items) {
+    if (!Array.isArray(value)) {
+      return `${path19} must be an array.`;
+    }
+    if (schema.items) {
+      for (const [index, entry] of value.entries()) {
+        const failure = schemaFailure(schema.items, entry, `${path19}[${index}]`);
+        if (failure) return failure;
+      }
+    }
+  }
+  if (typeof value === "string") {
+    if (schema.minLength !== void 0 && value.length < schema.minLength) {
+      return `${path19} is shorter than ${schema.minLength}.`;
+    }
+    if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
+      return `${path19} is longer than ${schema.maxLength}.`;
+    }
+  }
+  if (typeof value === "number") {
+    if (schema.minimum !== void 0 && value < schema.minimum) {
+      return `${path19} is less than ${schema.minimum}.`;
+    }
+    if (schema.maximum !== void 0 && value > schema.maximum) {
+      return `${path19} is greater than ${schema.maximum}.`;
+    }
+  }
+  return void 0;
+}
+function matchesJsonSchemaType(type, value) {
+  switch (type) {
+    case "object":
+      return Boolean(value && typeof value === "object" && !Array.isArray(value));
+    case "array":
+      return Array.isArray(value);
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "integer":
+      return Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "null":
+      return value === null;
+    default:
+      return true;
+  }
+}
+function headersToRecord(headers) {
+  const record = {};
+  headers.forEach((value, key) => {
+    record[key] = value;
+  });
+  return record;
+}
+function stripUndefined4(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, entry]) => entry !== void 0)
+  );
+}
+function httpAuthError(value) {
+  if (!value || typeof value !== "object" || !("error" in value)) {
+    return void 0;
+  }
+  const error = value.error;
+  const data = error?.data;
+  if (!data || typeof data !== "object") {
+    return void 0;
+  }
+  const status = data.status;
+  const headers = data.headers;
+  if (status !== 401 && status !== 403 || !headers || typeof headers !== "object") {
+    return void 0;
+  }
+  return {
+    status,
+    headers
+  };
+}
+var consoleLogger = {
+  debug(message, data) {
+    console.debug(message, data ?? "");
+  },
+  info(message, data) {
+    console.info(message, data ?? "");
+  },
+  warn(message, data) {
+    console.warn(message, data ?? "");
+  },
+  error(message, data) {
+    console.error(message, data ?? "");
+  }
+};
+async function readJson(request, maxBodyBytes) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of request) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += buffer.byteLength;
+    if (size > maxBodyBytes) {
+      throw new JsonRpcHttpError(413, -32600, "Request body is too large.");
+    }
+    chunks.push(buffer);
+  }
+  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+function toFetchRequest(request, baseUrl) {
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(request.headers)) {
+    if (Array.isArray(value)) {
+      for (const entry of value) {
+        headers.append(key, entry);
+      }
+    } else if (value !== void 0) {
+      headers.set(key, value);
+    }
+  }
+  const url = baseUrl ? new URL(request.url ?? "/", baseUrl) : new URL(
+    request.url ?? "/",
+    `${headers.get("x-forwarded-proto") ?? "http"}://${headers.get("host") ?? "127.0.0.1"}`
+  );
+  return new Request(url, {
+    headers,
+    method: request.method
+  });
+}
+function assertJsonRpcRequest(value) {
+  if (!value || typeof value !== "object") {
+    throw new JsonRpcError(-32600, "Request must be a JSON object.");
+  }
+  const record = value;
+  if (record.jsonrpc !== JSONRPC_VERSION || typeof record.method !== "string") {
+    throw new JsonRpcError(-32600, "Invalid JSON-RPC request.");
+  }
+  if ("id" in record && record.id !== void 0 && record.id !== null && typeof record.id !== "string" && typeof record.id !== "number") {
+    throw new JsonRpcError(-32600, "JSON-RPC id must be a string, number, or null.");
+  }
+  return {
+    jsonrpc: JSONRPC_VERSION,
+    id: typeof record.id === "string" || typeof record.id === "number" || record.id === null ? record.id : void 0,
+    method: record.method,
+    params: record.params
+  };
+}
+function isJsonRpcResponseMessage(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  if (record.jsonrpc !== JSONRPC_VERSION || !("id" in record) || !("result" in record || "error" in record)) {
+    return false;
+  }
+  return record.id === null || typeof record.id === "string" || typeof record.id === "number";
+}
+function normalizeError(error) {
+  if (error instanceof JsonRpcError) {
+    return {
+      code: error.code,
+      message: error.message,
+      data: error.data
+    };
+  }
+  if (error instanceof SidecarRuntimeError && error.code === "invalid_pagination_cursor") {
+    return {
+      code: -32602,
+      message: error.message
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      code: -32e3,
+      message: "Internal server error."
+    };
+  }
+  return {
+    code: -32e3,
+    message: "Unknown server error.",
+    data: error
+  };
+}
+function normalizeHttpError(error) {
+  if (error instanceof JsonRpcError) {
+    return {
+      code: error.code,
+      message: error.message,
+      data: error.data
+    };
+  }
+  return {
+    code: -32700,
+    message: "Invalid JSON request body."
+  };
+}
+
+// packages/cli/src/tunnel.ts
+import { spawn, spawnSync } from "child_process";
+import { createInterface } from "readline/promises";
+import { stdin, stdout } from "process";
+async function startTunnel(options) {
+  const provider = await resolveProvider(options.provider);
+  const localUrl = `http://127.0.0.1:${options.port}`;
+  const path19 = options.path ?? "/mcp";
+  if (provider === "cloudflared") {
+    return startCloudflared(localUrl, path19, options.timeoutMs);
+  }
+  return startWrangler(localUrl, path19, options.timeoutMs);
+}
+function tunnelInstallMessage(provider = "auto") {
+  if (provider === "wrangler") {
+    return [
+      "npx was not found on PATH, so Sidecar cannot run Wrangler quick-start.",
+      "Install Node.js/npm, or install cloudflared directly:",
+      "  brew install cloudflared"
+    ].join("\n");
+  }
+  return [
+    "cloudflared was not found on PATH.",
+    "Install cloudflared for the fastest Sidecar tunnel path:",
+    "  brew install cloudflared",
+    "Or run with Wrangler explicitly:",
+    "  sidecar dev --tunnel wrangler"
+  ].join("\n");
+}
+async function resolveProvider(provider) {
+  if (provider === "cloudflared") {
+    if (hasCommand("cloudflared")) {
+      return "cloudflared";
+    }
+    if (await promptForCloudflaredInstall()) {
+      await installCloudflared();
+      return "cloudflared";
+    }
+    assertNpxAvailable();
+    return "wrangler";
+  }
+  if (provider === "wrangler") {
+    assertNpxAvailable();
+    return "wrangler";
+  }
+  if (hasCommand("cloudflared")) {
+    return "cloudflared";
+  }
+  const choice = await promptForMissingCloudflared();
+  if (choice === "install") {
+    await installCloudflared();
+    return "cloudflared";
+  }
+  if (choice === "wrangler") {
+    assertNpxAvailable();
+    return "wrangler";
+  }
+  throw new Error("Cancelled HTTPS tunnel startup.");
+}
+async function promptForCloudflaredInstall() {
+  if (!stdin.isTTY || !stdout.isTTY) {
+    throw new Error(tunnelInstallMessage("cloudflared"));
+  }
+  const answer = await question([
+    "cloudflared is not installed.",
+    "Install cloudflared with Homebrew now? Answer no to continue with npx wrangler. [y/N] "
+  ].join("\n"));
+  return answer.trim().toLowerCase().startsWith("y");
+}
+async function promptForMissingCloudflared() {
+  if (!stdin.isTTY || !stdout.isTTY) {
+    throw new Error(tunnelInstallMessage("auto"));
+  }
+  const answer = await question([
+    "cloudflared is not installed.",
+    "Choose how Sidecar should create an HTTPS MCP URL:",
+    "  [i] install cloudflared with Homebrew",
+    "  [w] continue with npx wrangler tunnel quick-start",
+    "  [c] cancel",
+    "Selection [i/w/c]: "
+  ].join("\n"));
+  const normalized = answer.trim().toLowerCase();
+  if (normalized === "i" || normalized === "install") {
+    return "install";
+  }
+  if (normalized === "w" || normalized === "wrangler") {
+    return "wrangler";
+  }
+  return "cancel";
+}
+async function question(prompt) {
+  const input = createInterface({ input: stdin, output: stdout });
+  try {
+    return await input.question(prompt);
+  } finally {
+    input.close();
+  }
+}
+async function installCloudflared() {
+  if (!hasCommand("brew")) {
+    throw new Error([
+      "Sidecar can only install cloudflared automatically when Homebrew is available.",
+      "Install cloudflared manually, then rerun:",
+      "  sidecar dev --tunnel",
+      "Or continue without installing it:",
+      "  sidecar dev --tunnel wrangler"
+    ].join("\n"));
+  }
+  await runInherited("brew", ["install", "cloudflared"]);
+}
+function assertNpxAvailable() {
+  if (!hasCommand("npx")) {
+    throw new Error(tunnelInstallMessage("wrangler"));
+  }
+}
+async function startCloudflared(localUrl, path19, timeoutMs = 2e4) {
+  const child = spawn("cloudflared", ["tunnel", "--url", localUrl, "--no-autoupdate"], {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const publicUrl = await waitForTunnelUrl(child, /https:\/\/[a-zA-Z0-9.-]+\.trycloudflare\.com/, timeoutMs);
+  return {
+    provider: "cloudflared",
+    publicUrl,
+    mcpUrl: appendPath(publicUrl, path19),
+    close() {
+      child.kill("SIGTERM");
+    }
+  };
+}
+async function startWrangler(localUrl, path19, timeoutMs = 2e4) {
+  const child = spawn("npx", ["--yes", "wrangler", "tunnel", "quick-start", localUrl], {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const publicUrl = await waitForTunnelUrl(child, /https:\/\/[a-zA-Z0-9.-]+\.trycloudflare\.com/, timeoutMs);
+  return {
+    provider: "wrangler",
+    publicUrl,
+    mcpUrl: appendPath(publicUrl, path19),
+    close() {
+      child.kill("SIGTERM");
+    }
+  };
+}
+function waitForTunnelUrl(child, pattern, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const timeout = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        child.kill("SIGTERM");
+        reject(new Error("Timed out waiting for HTTPS tunnel URL."));
+      }
+    }, timeoutMs);
+    const inspect = (chunk) => {
+      const match = chunk.toString("utf8").match(pattern);
+      if (match?.[0] && !settled) {
+        settled = true;
+        clearTimeout(timeout);
+        resolve(match[0]);
+      }
+    };
+    child.stdout?.on("data", inspect);
+    child.stderr?.on("data", inspect);
+    child.once("error", (error) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timeout);
+        reject(error);
+      }
+    });
+    child.once("exit", (code) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timeout);
+        reject(new Error(`Tunnel process exited before producing a URL${code === null ? "" : ` with code ${code}`}.`));
+      }
+    });
+  });
+}
+function hasCommand(command) {
+  return spawnSync("which", [command], { stdio: "ignore" }).status === 0;
+}
+function runInherited(command, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { stdio: "inherit" });
+    child.once("error", reject);
+    child.once("exit", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`${command} ${args.join(" ")} exited with code ${code}.`));
+      }
+    });
+  });
+}
+function appendPath(origin, path19) {
+  return `${origin.replace(/\/+$/, "")}/${path19.replace(/^\/+/, "")}`;
+}
+
+// packages/cli/src/index.ts
+async function main(argv) {
+  const command = argv[2] ?? "help";
+  const rootDir = readOption(argv, "--cwd") ?? cwd();
+  switch (command) {
+    case "build": {
+      const target = readTarget(argv);
+      const outDir = readOption(argv, "--out") ?? `out/${target}`;
+      const plugins = argv.includes("--plugins");
+      const strict = argv.includes("--strict");
+      const manifest = await buildProject({ rootDir, outDir, plugins, strict, target });
+      printDiagnostics(manifest.diagnostics ?? []);
+      if (strict && manifest.diagnostics?.length) {
+        exit(1);
+      }
+      console.log(
+        `Built ${manifest.tools.length} ${target} tool${manifest.tools.length === 1 ? "" : "s"}, ${manifest.resources.length} resource${manifest.resources.length === 1 ? "" : "s"}, and ${manifest.prompts.length} prompt${manifest.prompts.length === 1 ? "" : "s"} to ${outDir}.`
+      );
+      if (plugins) {
+        console.log("Built claude-plugin package.");
+      }
+      return;
+    }
+    case "check": {
+      const target = readTarget(argv);
+      const config = analyzeProjectConfig(rootDir);
+      const tools = await analyzeProjectTools(rootDir, { target });
+      const resources = await analyzeProjectResources(rootDir);
+      const prompts = await analyzeProjectPrompts(rootDir);
+      const diagnostics = await collectProjectDiagnostics(rootDir, {
+        tools,
+        resources,
+        prompts,
+        config
+      });
+      printDiagnostics(diagnostics);
+      if (diagnostics.some((diagnostic) => diagnostic.severity === "error") || argv.includes("--strict") && diagnostics.length > 0) {
+        exit(1);
+      }
+      if (!diagnostics.length) {
+        console.log("No Sidecar diagnostics.");
+      }
+      return;
+    }
+    case "dev": {
+      const port = Number(readOption(argv, "--port") ?? "3001");
+      const target = readTarget(argv);
+      const tunnelProvider = readTunnelProvider(argv);
+      const outDir = `.sidecar/dev/${target}`;
+      const manifest = await buildProject({ rootDir, outDir, target });
+      printDiagnostics(manifest.diagnostics ?? []);
+      const tools = await loadRuntimeTools(rootDir, manifest);
+      let tunnel;
+      if (tunnelProvider) {
+        tunnel = await startTunnel({ provider: tunnelProvider, port, path: "/mcp" });
+        process.env.SIDECAR_MCP_URL = tunnel.mcpUrl;
+      }
+      const loadedAuth = await loadRuntimeAuth(rootDir);
+      const runtimeConfig = await loadRuntimeConfig(rootDir);
+      const auth = loadedAuth && tunnel ? loadedAuth.withResource(tunnel.mcpUrl) : loadedAuth;
+      const proxy = await loadRuntimeProxy(rootDir);
+      const resources = await loadResources(rootDir, outDir, manifest);
+      const prompts = await loadRuntimePrompts(rootDir, manifest);
+      const server = createSidecarHttpServer({
+        name: "sidecar-dev",
+        version: "0.0.0-dev",
+        path: "/mcp",
+        auth,
+        proxy,
+        tools,
+        resources,
+        prompts,
+        capabilities: {
+          tools: runtimeConfig?.tools ?? manifest.config.tools,
+          resources: runtimeConfig?.resources ?? manifest.config.resources,
+          prompts: runtimeConfig?.prompts ?? manifest.config.prompts
+        },
+        pagination: runtimeConfig?.pagination ?? {
+          pageSize: manifest.config.pagination.pageSize
+        }
+      });
+      server.listen(port, "127.0.0.1", () => {
+        console.log(`MCP running on Streamable HTTP (${target}) at http://127.0.0.1:${port}/mcp`);
+        console.log(`Loaded ${tools.length} tool${tools.length === 1 ? "" : "s"}, ${resources.length} resource${resources.length === 1 ? "" : "s"}, and ${prompts.length} prompt${prompts.length === 1 ? "" : "s"}.`);
+        if (tunnel) {
+          console.log(`HTTPS tunnel (${tunnel.provider}) ready: ${tunnel.mcpUrl}`);
+          console.log("Use this HTTPS MCP URL in ChatGPT, Claude, or a Claude plugin install.");
+        }
+      });
+      const shutdown = () => {
+        tunnel?.close();
+        server.close(() => exit(0));
+      };
+      process.once("SIGINT", shutdown);
+      process.once("SIGTERM", shutdown);
+      return;
+    }
+    case "inspect": {
+      const target = readTarget(argv);
+      const tools = await analyzeProjectTools(rootDir, { target });
+      if (!tools.length) {
+        console.log("No Sidecar tools found.");
+        return;
+      }
+      for (const tool of tools) {
+        console.log(`${tool.id} \u2014 ${tool.name} (${tool.variant}, ${tool.target})`);
+        console.log(`  ${tool.description}`);
+        console.log(`  source: ${tool.sourceFile}`);
+      }
+      return;
+    }
+    case "preview": {
+      if (argv[3] !== "components") {
+        throw new Error("Only `sidecar preview components` is supported right now.");
+      }
+      await previewComponents({
+        rootDir,
+        host: readOption(argv, "--host") ?? "chatgpt",
+        port: Number(readOption(argv, "--port") ?? "3102"),
+        compare: readOption(argv, "--compare") ?? "native,openai",
+        componentSet: readPreviewComponentSet(readOption(argv, "--components")),
+        themes: readPreviewThemes(readOption(argv, "--theme")),
+        approve: !argv.includes("--no-approve")
+      });
+      return;
+    }
+    case "help":
+    default:
+      console.log(`Sidecar
+
+Usage:
+  sidecar build [--cwd <dir>] [--target mcp|chatgpt|claude] [--out <dir>] [--plugins] [--strict]
+  sidecar check [--cwd <dir>] [--target mcp|chatgpt|claude] [--strict]
+  sidecar dev [--cwd <dir>] [--target mcp|chatgpt|claude] [--port <port>] [--tunnel [cloudflared|wrangler]]
+  sidecar inspect [--cwd <dir>] [--target mcp|chatgpt|claude]
+  sidecar preview components [--cwd <dir>] [--host chatgpt|claude|generic] [--compare native,openai] [--components representative|all] [--theme light|dark|both] [--port <port>] [--no-approve]
+`);
+  }
+}
+function readTarget(argv) {
+  const target = readOption(argv, "--target") ?? "mcp";
+  if (target === "mcp" || target === "chatgpt" || target === "claude") {
+    return target;
+  }
+  throw new Error(`Unsupported Sidecar target "${target}". Expected mcp, chatgpt, or claude.`);
+}
+async function previewComponents(options) {
+  const cliDir = path18.dirname(fileURLToPath(import.meta.url));
+  const css = await readFile8(path18.join(cliDir, "../../native/src/styles.css"), "utf8").catch(() => readFile8(path18.join(process.cwd(), "packages/native/src/styles.css"), "utf8")).catch(() => "");
+  const html = renderComponentPreviewHtml(
+    options.host,
+    options.compare,
+    css,
+    options.themes,
+    options.componentSet
+  );
+  const server = createServer2((_request, response) => {
+    response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+    response.end(html);
+  });
+  await new Promise((resolve) => {
+    server.listen(options.port, "127.0.0.1", resolve);
+  });
+  const url = `http://127.0.0.1:${options.port}`;
+  console.log(`Sidecar component preview running at ${url}`);
+  console.log(`Compare set: ${options.compare}`);
+  console.log(`Component set: ${options.componentSet}`);
+  console.log(`Themes: ${options.themes.join(", ")}`);
+  if (!options.approve || !stdin2.isTTY) {
+    return;
+  }
+  const answer = await askYesNo(
+    `Do the shared primitives look equivalent for ${options.host}? [y/N] `
+  );
+  if (answer) {
+    await writeComponentApproval(options.rootDir, {
+      host: options.host,
+      compare: options.compare.split(",").map((entry) => entry.trim()).filter(Boolean),
+      approvedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      components: previewComponentNames(options.componentSet)
+    });
+    console.log("Recorded component parity approval.");
+  } else {
+    console.log("No approval recorded.");
+  }
+  server.close();
+}
+async function writeComponentApproval(rootDir, approval) {
+  const dir = path18.join(rootDir, ".sidecar", "approvals");
+  await mkdir9(dir, { recursive: true });
+  await writeFile9(
+    path18.join(dir, `components.${approval.host}.json`),
+    `${JSON.stringify(approval, null, 2)}
+`
+  );
+}
+async function askYesNo(question2) {
+  const readline = createInterface2({ input: stdin2, output: stdout2 });
+  try {
+    const answer = await readline.question(question2);
+    return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+  } finally {
+    readline.close();
+  }
+}
+function renderComponentPreviewHtml(host, compare, css, themes, componentSet) {
+  const themeFrames = themes.map(
+    (theme) => `<section class="theme-panel">
+        <div class="theme-label">${escapeHtml2(theme)}</div>
+        <iframe title="${escapeHtml2(theme)} component preview" srcdoc="${escapeHtml2(renderComponentPreviewFrame(host, compare, css, theme, componentSet))}"></iframe>
+      </section>`
+  ).join("");
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Sidecar component preview</title>
+    <style>
+      body { background: #f4f4f5; color: #18181b; font: 14px/1.4 ui-sans-serif, -apple-system, system-ui, "Segoe UI", sans-serif; margin: 0; padding: 18px; }
+      .preview-shell { display: grid; gap: 18px; }
+      .theme-panel { display: grid; gap: 8px; }
+      .theme-label { font-size: 12px; font-weight: 700; letter-spacing: .04em; text-transform: uppercase; }
+      iframe { background: transparent; border: 1px solid rgb(0 0 0 / 12%); border-radius: 10px; height: 82vh; min-height: 680px; width: 100%; }
+    </style>
+  </head>
+  <body>
+    <main class="preview-shell">${themeFrames}</main>
+  </body>
+</html>`;
+}
+function renderComponentPreviewFrame(host, compare, css, theme, componentSet) {
+  const columns = compare.split(",").map((entry) => entry.trim()).filter(Boolean);
+  const cells = columns.map((column) => renderPreviewColumn(column, host, componentSet)).join("");
+  return `<!doctype html>
+<html lang="en" data-sidecar-host="${escapeHtml2(host)}" data-sidecar-theme="${theme}">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Sidecar component preview</title>
+    <style>
+      ${css}
+      html, body { background: var(--sc-surface); }
+      body { padding: 24px; }
+      .preview-grid { display: grid; gap: 20px; grid-template-columns: repeat(${Math.max(columns.length, 1)}, minmax(240px, 1fr)); }
+      .preview-column { display: flex; flex-direction: column; gap: 14px; }
+      .preview-group { border-bottom: 1px solid var(--sc-border); display: grid; gap: 10px; padding-bottom: 14px; }
+      .preview-group:last-child { border-bottom: 0; }
+      .component-label { color: var(--sc-text-muted); font: 600 11px/1.2 var(--sc-font-sans); text-transform: uppercase; }
+      .preview-row { align-items: start; display: grid; gap: 8px; }
+      .preview-label { color: var(--sc-text-muted); font: 600 12px/1.2 var(--sc-font-sans); text-transform: uppercase; }
+    </style>
+  </head>
+  <body>
+    <main class="preview-grid">${cells}</main>
+  </body>
+</html>`;
+}
+function renderPreviewColumn(column, host, componentSet) {
+  const recipe = previewRecipe(column, host);
+  const groups = componentSet === "all" ? renderAllPreviewGroups(recipe) : renderRepresentativePreviewGroups(recipe);
+  return `<section class="preview-column">
+    <div class="preview-label">${escapeHtml2(column)}</div>
+    ${groups}
+  </section>`;
+}
+function previewRecipe(column, host) {
+  switch (column) {
+    case "native":
+      return "auto";
+    case "native-chatgpt":
+    case "openai":
+      return "chatgpt";
+    case "native-claude":
+    case "anthropic":
+      return "claude";
+    default:
+      return host;
+  }
+}
+function renderRepresentativePreviewGroups(recipe) {
+  return [
+    previewGroup("Buttons", buttonsPreview(recipe)),
+    previewGroup("Fields", fieldsPreview(recipe)),
+    previewGroup("Choices", choicesPreview(recipe)),
+    previewGroup("Feedback", feedbackPreview(recipe)),
+    previewGroup("Loading", loadingPreview(recipe))
+  ].join("");
+}
+function renderAllPreviewGroups(recipe) {
+  return [
+    previewGroup("Text", textPreview(recipe)),
+    previewGroup("Buttons", buttonsPreview(recipe)),
+    previewGroup("Links", linksPreview(recipe)),
+    previewGroup("Fields", fieldsPreview(recipe)),
+    previewGroup("Choice Controls", choicesPreview(recipe)),
+    previewGroup("Select", selectPreview(recipe)),
+    previewGroup("Feedback", feedbackPreview(recipe)),
+    previewGroup("Identity", identityPreview(recipe)),
+    previewGroup("Empty State", emptyPreview(recipe)),
+    previewGroup("Loading", loadingPreview(recipe)),
+    previewGroup("Layout", layoutPreview(recipe)),
+    previewGroup("Data", dataPreview(recipe)),
+    previewGroup("Media", mediaPreview(recipe))
+  ].join("");
+}
+function previewGroup(label, body) {
+  return `<div class="preview-group"><div class="component-label">${escapeHtml2(label)}</div>${body}</div>`;
+}
+function textPreview(recipe) {
+  return `<div class="preview-row">
+    <h2 data-sc-component="heading" data-sc-level="2" data-sc-recipe="${recipe}">Heading</h2>
+    <p data-sc-component="text" data-sc-recipe="${recipe}">Body text follows the active host typography.</p>
+    <p data-sc-component="text" data-sc-tone="muted" data-sc-recipe="${recipe}">Muted supporting text</p>
+    <code data-sc-component="code" data-sc-recipe="${recipe}">tool_result.id</code>
+    <span data-sc-component="shimmer-text" data-sc-recipe="${recipe}">Shimmer text</span>
+  </div>`;
+}
+function buttonsPreview(recipe) {
+  return `<div class="preview-row">
+    <button data-sc-component="button" data-sc-color="primary" data-sc-variant="solid" data-sc-size="md" data-sc-pill data-sc-recipe="${recipe}" type="button"><span data-sc-component="button-label">Primary</span></button>
+    <button data-sc-component="button" data-sc-color="secondary" data-sc-variant="soft" data-sc-size="md" data-sc-pill data-sc-recipe="${recipe}" type="button"><span data-sc-component="button-label">Secondary</span></button>
+    <button data-sc-component="button" data-sc-color="danger" data-sc-variant="outline" data-sc-size="md" data-sc-pill data-sc-recipe="${recipe}" type="button"><span data-sc-component="button-label">Danger</span></button>
+    <button data-sc-component="button" data-sc-color="secondary" data-sc-variant="ghost" data-sc-size="md" data-sc-pill data-sc-recipe="${recipe}" type="button"><span data-sc-component="button-label">Ghost</span></button>
+    <button data-sc-component="button" data-sc-color="primary" data-sc-variant="solid" data-sc-size="md" data-sc-pill data-sc-loading data-sc-recipe="${recipe}" type="button"><span data-sc-component="loading-indicator" data-sc-recipe="${recipe}" style="--sc-indicator-size: 1em;"></span><span data-sc-component="button-label">Loading</span></button>
+  </div>`;
+}
+function linksPreview(recipe) {
+  return `<div class="preview-row">
+    <a data-sc-component="button" data-sc-color="primary" data-sc-variant="solid" data-sc-size="md" data-sc-pill data-sc-recipe="${recipe}" href="#"><span data-sc-component="button-label">ButtonLink</span></a>
+    <a data-sc-component="text-link" data-sc-primary data-sc-underline data-sc-recipe="${recipe}" href="#">TextLink</a>
+  </div>`;
+}
+function fieldsPreview(recipe) {
+  return `<div class="preview-row">
+    <div data-sc-component="form-field" data-sc-recipe="${recipe}">
+      <label data-sc-component="field-label" data-sc-recipe="${recipe}">FormField label</label>
+      <span data-sc-component="input-shell" data-sc-variant="outline" data-sc-size="md" data-sc-recipe="${recipe}"><input data-sc-component="input" value="Input" /></span>
+      <p data-sc-component="field-description" data-sc-recipe="${recipe}">Field description</p>
+    </div>
+    <span data-sc-component="input-shell" data-sc-variant="soft" data-sc-size="md" data-sc-recipe="${recipe}"><span data-sc-component="input-adornment">$</span><input data-sc-component="input" value="Soft input" /></span>
+    <textarea data-sc-component="textarea" data-sc-variant="outline" data-sc-size="md" data-sc-recipe="${recipe}">Textarea</textarea>
+    <div data-sc-component="form-field" data-sc-invalid data-sc-recipe="${recipe}">
+      <span data-sc-component="input-shell" data-sc-invalid data-sc-variant="outline" data-sc-size="md" data-sc-recipe="${recipe}"><input data-sc-component="input" value="Invalid" aria-invalid="true" /></span>
+      <p data-sc-component="field-error" data-sc-recipe="${recipe}">Field error</p>
+    </div>
+  </div>`;
+}
+function choicesPreview(recipe) {
+  return `<div class="preview-row">
+    <label data-sc-component="checkbox-label" data-sc-recipe="${recipe}"><button data-sc-component="checkbox" data-sc-checked data-sc-recipe="${recipe}" role="checkbox" aria-checked="true" type="button"></button><span>Checkbox</span></label>
+    <label data-sc-component="switch-label" data-sc-recipe="${recipe}"><button data-sc-component="switch" data-sc-checked data-sc-recipe="${recipe}" role="switch" aria-checked="true" type="button"><span data-sc-component="switch-thumb"></span></button><span>Switch</span></label>
+    <div data-sc-component="radio-group" data-sc-direction="row" data-sc-recipe="${recipe}" role="radiogroup">
+      <button data-sc-component="radio-item" data-sc-checked data-sc-recipe="${recipe}" role="radio" aria-checked="true" type="button"><span data-sc-component="radio-indicator"></span><span data-sc-component="radio-label">List</span></button>
+      <button data-sc-component="radio-item" data-sc-recipe="${recipe}" role="radio" aria-checked="false" type="button"><span data-sc-component="radio-indicator"></span><span data-sc-component="radio-label">Grid</span></button>
+    </div>
+    <div data-sc-component="segmented-control" data-sc-size="md" data-sc-recipe="${recipe}"><button data-sc-component="segmented-option" data-sc-selected type="button">List</button><button data-sc-component="segmented-option" type="button">Grid</button></div>
+    <input data-sc-component="slider" data-sc-recipe="${recipe}" type="range" value="60" />
+  </div>`;
+}
+function selectPreview(recipe) {
+  return `<div class="preview-row">
+    <span data-sc-component="select-control" data-sc-variant="outline" data-sc-size="md" data-sc-selected data-sc-recipe="${recipe}"><span data-sc-component="select-control-value">Selected option</span><span data-sc-component="select-dropdown-icon">\u25BE</span></span>
+    <div data-sc-component="select" data-sc-open data-sc-recipe="${recipe}">
+      <span data-sc-component="select-control" data-sc-variant="outline" data-sc-size="md" data-sc-selected data-sc-recipe="${recipe}"><span data-sc-component="select-control-value">CSV</span><span data-sc-component="select-dropdown-icon">\u25BE</span></span>
+      <div data-sc-component="select-list" data-sc-recipe="${recipe}" role="listbox">
+        <button data-sc-component="select-option" data-sc-selected role="option" aria-selected="true" type="button"><span data-sc-component="select-option-label">CSV</span><span data-sc-component="select-option-description">Comma-separated values</span></button>
+        <button data-sc-component="select-option" role="option" aria-selected="false" type="button"><span data-sc-component="select-option-label">PDF</span><span data-sc-component="select-option-description">Portable document</span></button>
+      </div>
+    </div>
+  </div>`;
+}
+function feedbackPreview(recipe) {
+  return `<div class="preview-row">
+    <div data-sc-component="alert" data-sc-color="info" data-sc-variant="soft" data-sc-recipe="${recipe}"><span data-sc-component="alert-indicator">\u2022</span><div data-sc-component="alert-content"><div data-sc-component="alert-title">Alert</div><div data-sc-component="alert-description">Native recipe check</div></div></div>
+    <span data-sc-component="badge" data-sc-color="success" data-sc-variant="soft" data-sc-size="sm" data-sc-recipe="${recipe}">Badge</span>
+    <span data-sc-component="badge" data-sc-color="danger" data-sc-variant="outline" data-sc-size="md" data-sc-pill data-sc-recipe="${recipe}">Pill badge</span>
+  </div>`;
+}
+function identityPreview(recipe) {
+  return `<div data-sc-component="avatar-group" data-sc-recipe="${recipe}">
+    <span data-sc-component="avatar" data-sc-color="primary" data-sc-variant="solid" data-sc-recipe="${recipe}" style="--sc-avatar-size: 32px;">SD</span>
+    <span data-sc-component="avatar" data-sc-color="secondary" data-sc-variant="soft" data-sc-recipe="${recipe}" style="--sc-avatar-size: 32px;">+3</span>
+  </div>`;
+}
+function emptyPreview(recipe) {
+  return `<div data-sc-component="empty-message" data-sc-fill="static" data-sc-recipe="${recipe}">
+    <div data-sc-component="empty-message-icon" data-sc-color="secondary" data-sc-size="md" data-sc-recipe="${recipe}">\u25A1</div>
+    <div data-sc-component="empty-message-title" data-sc-color="secondary" data-sc-recipe="${recipe}">No results</div>
+    <div data-sc-component="empty-message-description">Try another filter.</div>
+    <div data-sc-component="empty-message-actions"><button data-sc-component="button" data-sc-color="secondary" data-sc-variant="soft" data-sc-size="sm" data-sc-pill data-sc-recipe="${recipe}" type="button"><span data-sc-component="button-label">Reset</span></button></div>
+  </div>`;
+}
+function loadingPreview(recipe) {
+  return `<div class="preview-row">
+    <div data-sc-component="loading-dots" data-sc-recipe="${recipe}"><span></span><span></span><span></span></div>
+    <span data-sc-component="loading-indicator" data-sc-recipe="${recipe}" style="--sc-indicator-size: 24px;"></span>
+    <span data-sc-component="circular-progress" data-sc-recipe="${recipe}" style="--sc-progress-size: 28px;"><svg viewBox="0 0 24 24" aria-hidden="true"><circle cx="12" cy="12" r="10" fill="none" stroke="color-mix(in srgb, currentColor 18%, transparent)" stroke-width="2"></circle><circle cx="12" cy="12" r="10" fill="none" stroke="currentColor" stroke-width="2" stroke-dasharray="62.8" stroke-dashoffset="18" stroke-linecap="round" transform="rotate(-90 12 12)"></circle></svg></span>
+    <div data-sc-component="skeleton" data-sc-recipe="${recipe}" style="width: 100%; height: 24px;"></div>
+  </div>`;
+}
+function layoutPreview(recipe) {
+  return `<div data-sc-component="stack" data-sc-gap="sm" data-sc-recipe="${recipe}">
+    <div data-sc-component="surface" data-sc-variant="card" data-sc-recipe="${recipe}"><p data-sc-component="text" data-sc-recipe="${recipe}">Card surface</p></div>
+    <div data-sc-component="surface" data-sc-variant="inset" data-sc-recipe="${recipe}"><p data-sc-component="text" data-sc-recipe="${recipe}">Inset surface</p></div>
+    <div data-sc-component="inline" data-sc-gap="sm" data-sc-recipe="${recipe}"><span data-sc-component="badge" data-sc-recipe="${recipe}">Inline</span><span data-sc-component="badge" data-sc-recipe="${recipe}">Row</span></div>
+    <hr data-sc-component="divider" data-sc-recipe="${recipe}" />
+    <div data-sc-component="tabs" data-sc-recipe="${recipe}"><div data-sc-component="segmented-control" data-sc-size="sm" data-sc-recipe="${recipe}"><button data-sc-component="segmented-option" data-sc-selected type="button">One</button><button data-sc-component="segmented-option" type="button">Two</button></div></div>
+  </div>`;
+}
+function dataPreview(recipe) {
+  return `<div class="preview-row">
+    <dl data-sc-component="key-value" data-sc-recipe="${recipe}">
+      <div data-sc-component="key-value-row"><dt>Status</dt><dd>Ready</dd></div>
+      <div data-sc-component="key-value-row"><dt>Target</dt><dd>ChatGPT</dd></div>
+    </dl>
+    <table data-sc-component="table" data-sc-recipe="${recipe}"><tbody><tr><th>Name</th><td>Sidecar</td></tr><tr><th>Version</th><td>alpha</td></tr></tbody></table>
+    <progress data-sc-component="progress" data-sc-recipe="${recipe}" value="70" max="100"></progress>
+  </div>`;
+}
+function mediaPreview(recipe) {
+  return `<svg data-sc-component="image" data-sc-recipe="${recipe}" viewBox="0 0 320 120" role="img" aria-label="Preview image">
+    <rect width="320" height="120" rx="12" fill="currentColor" opacity="0.08"></rect>
+    <circle cx="64" cy="60" r="28" fill="currentColor" opacity="0.18"></circle>
+    <rect x="112" y="42" width="150" height="12" rx="6" fill="currentColor" opacity="0.2"></rect>
+    <rect x="112" y="66" width="104" height="10" rx="5" fill="currentColor" opacity="0.14"></rect>
+  </svg>`;
+}
+function previewComponentNames(componentSet) {
+  if (componentSet === "representative") {
+    return [
+      "Button",
+      "Input",
+      "SelectControl",
+      "Checkbox",
+      "Switch",
+      "RadioGroup",
+      "SegmentedControl",
+      "Alert",
+      "Badge",
+      "Skeleton"
+    ];
+  }
+  return [
+    "Alert",
+    "Avatar",
+    "AvatarGroup",
+    "Badge",
+    "Button",
+    "ButtonLink",
+    "Checkbox",
+    "CircularProgress",
+    "Code",
+    "CopyButton",
+    "Divider",
+    "EmptyMessage",
+    "FieldDescription",
+    "FieldError",
+    "FieldLabel",
+    "FormField",
+    "Heading",
+    "Image",
+    "Inline",
+    "Input",
+    "KeyValue",
+    "LoadingDots",
+    "LoadingIndicator",
+    "Progress",
+    "RadioGroup",
+    "SegmentedControl",
+    "Select",
+    "SelectControl",
+    "ShimmerText",
+    "Skeleton",
+    "Slider",
+    "Stack",
+    "Surface",
+    "Switch",
+    "Table",
+    "Tabs",
+    "Text",
+    "Textarea",
+    "TextLink"
+  ];
+}
+function readPreviewComponentSet(value) {
+  if (!value || value === "representative") {
+    return "representative";
+  }
+  if (value === "all") {
+    return value;
+  }
+  throw new Error(`Unsupported component preview set "${value}". Expected representative or all.`);
+}
+function readPreviewThemes(value) {
+  if (!value || value === "light") {
+    return ["light"];
+  }
+  if (value === "dark") {
+    return ["dark"];
+  }
+  if (value === "both") {
+    return ["light", "dark"];
+  }
+  const themes = value.split(",").map((entry) => entry.trim()).filter(Boolean);
+  if (themes.every((theme) => theme === "light" || theme === "dark")) {
+    return themes;
+  }
+  throw new Error(`Unsupported component preview theme "${value}". Expected light, dark, both, or a comma-separated light,dark list.`);
+}
+function escapeHtml2(value) {
+  return value.replace(/[&<>"']/g, (character) => {
+    switch (character) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case '"':
+        return "&quot;";
+      default:
+        return "&#39;";
+    }
+  });
+}
+function readTunnelProvider(argv) {
+  const index = argv.indexOf("--tunnel");
+  if (index === -1) {
+    return void 0;
+  }
+  const value = argv[index + 1];
+  if (value === "cloudflared" || value === "wrangler") {
+    return value;
+  }
+  return "auto";
+}
+function printDiagnostics(diagnostics) {
+  for (const diagnostic of diagnostics) {
+    console.warn(formatDiagnostic(diagnostic));
+  }
+}
+async function loadRuntimeAuth(rootDir) {
+  const authPath = path18.join(rootDir, "auth.ts");
+  if (!existsSync5(authPath)) {
+    return void 0;
+  }
+  const parentURL = pathToFileURL(path18.join(rootDir, "sidecar.config.ts")).href;
+  const tsconfigPath = path18.join(rootDir, "tsconfig.json");
+  const tsconfig = existsSync5(tsconfigPath) ? tsconfigPath : false;
+  const module = await tsImport(pathToFileURL(authPath).href, {
+    parentURL,
+    tsconfig
+  });
+  if (!isSidecarAuth(module.default)) {
+    throw new Error("auth.ts must default-export auth({ ... }) from sidecar-ai.");
+  }
+  return module.default;
+}
+async function loadRuntimeProxy(rootDir) {
+  const proxyPath = path18.join(rootDir, "proxy.ts");
+  if (!existsSync5(proxyPath)) {
+    return void 0;
+  }
+  const parentURL = pathToFileURL(path18.join(rootDir, "sidecar.config.ts")).href;
+  const tsconfigPath = path18.join(rootDir, "tsconfig.json");
+  const tsconfig = existsSync5(tsconfigPath) ? tsconfigPath : false;
+  const module = await tsImport(pathToFileURL(proxyPath).href, {
+    parentURL,
+    tsconfig
+  });
+  if (!isSidecarProxy(module.default)) {
+    throw new Error("proxy.ts must default-export proxy({ ... }) from @sidecar-ai/server/proxy.");
+  }
+  return module.default;
+}
+async function loadRuntimeConfig(rootDir) {
+  const configPath = path18.join(rootDir, "sidecar.config.ts");
+  if (!existsSync5(configPath)) {
+    return void 0;
+  }
+  const parentURL = pathToFileURL(configPath).href;
+  const tsconfigPath = path18.join(rootDir, "tsconfig.json");
+  const tsconfig = existsSync5(tsconfigPath) ? tsconfigPath : false;
+  const module = await tsImport(pathToFileURL(configPath).href, {
+    parentURL,
+    tsconfig
+  });
+  if (!module.default || typeof module.default !== "object") {
+    throw new Error("sidecar.config.ts must default-export defineConfig({ ... }) from sidecar-ai.");
+  }
+  return module.default;
+}
+async function loadRuntimeTools(rootDir, manifest) {
+  const parentURL = pathToFileURL(path18.join(rootDir, "sidecar.config.ts")).href;
+  const tsconfigPath = path18.join(rootDir, "tsconfig.json");
+  const tsconfig = existsSync5(tsconfigPath) ? tsconfigPath : false;
+  const loaded = [];
+  for (const entry of manifest.tools) {
+    const sourcePath = path18.join(rootDir, entry.sourceFile);
+    const module = await tsImport(pathToFileURL(sourcePath).href, {
+      parentURL,
+      tsconfig
+    });
+    if (!isSidecarTool(module.default)) {
+      throw new Error(`${entry.sourceFile} did not default-export a Sidecar tool.`);
+    }
+    loaded.push({
+      tool: module.default,
+      descriptor: entry.descriptor
+    });
+  }
+  return loaded;
+}
+async function loadResources(rootDir, outDir, manifest) {
+  const resources = [];
+  for (const entry of manifest.tools) {
+    if (!entry.widget?.outputFile) {
+      continue;
+    }
+    const text = await readFile8(path18.join(rootDir, outDir, entry.widget.outputFile), "utf8");
+    resources.push({
+      uri: entry.widget.resourceUri,
+      name: entry.name,
+      description: entry.widget.options?.description,
+      mimeType: MCP_APP_RESOURCE_MIME_TYPE,
+      text,
+      _meta: entry.widget.resourceMeta
+    });
+  }
+  const parentURL = pathToFileURL(path18.join(rootDir, "sidecar.config.ts")).href;
+  const tsconfigPath = path18.join(rootDir, "tsconfig.json");
+  const tsconfig = existsSync5(tsconfigPath) ? tsconfigPath : false;
+  for (const entry of manifest.resources) {
+    const sourcePath = path18.join(rootDir, entry.sourceFile);
+    const module = await tsImport(pathToFileURL(sourcePath).href, {
+      parentURL,
+      tsconfig
+    });
+    if (!isSidecarResource(module.default)) {
+      throw new Error(`${entry.sourceFile} did not default-export a Sidecar resource.`);
+    }
+    resources.push({
+      uri: entry.uri,
+      descriptor: entry.descriptor,
+      resource: module.default
+    });
+  }
+  return resources;
+}
+async function loadRuntimePrompts(rootDir, manifest) {
+  const parentURL = pathToFileURL(path18.join(rootDir, "sidecar.config.ts")).href;
+  const tsconfigPath = path18.join(rootDir, "tsconfig.json");
+  const tsconfig = existsSync5(tsconfigPath) ? tsconfigPath : false;
+  const loaded = [];
+  for (const entry of manifest.prompts) {
+    const sourcePath = path18.join(rootDir, entry.sourceFile);
+    const module = await tsImport(pathToFileURL(sourcePath).href, {
+      parentURL,
+      tsconfig
+    });
+    if (!isSidecarPrompt(module.default)) {
+      throw new Error(`${entry.sourceFile} did not default-export a Sidecar prompt.`);
+    }
+    loaded.push({
+      prompt: module.default,
+      descriptor: entry.descriptor
+    });
+  }
+  return loaded;
+}
+function readOption(argv, name) {
+  const index = argv.indexOf(name);
+  if (index === -1) {
+    return void 0;
+  }
+  return argv[index + 1];
+}
+function isDirectRun() {
+  const entry = process.argv[1];
+  if (!entry) {
+    return false;
+  }
+  const entryPath = realpathSync.native(entry);
+  return import.meta.url === pathToFileURL(entryPath).href;
+}
+if (isDirectRun()) {
+  main(process.argv).catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    exit(1);
+  });
+}
+export {
+  main,
+  previewComponentNames,
+  readPreviewComponentSet,
+  readPreviewThemes,
+  renderComponentPreviewFrame,
+  renderComponentPreviewHtml
+};
+//# sourceMappingURL=index.js.map