@sidecar-ai/compiler 0.1.0-alpha.0

package/dist/index.js

@@ -0,0 +1,2892 @@
+// packages/core/src/index.ts
+var toolResultBrand = /* @__PURE__ */ Symbol.for("sidecar.toolResult");
+var resourceResultBrand = /* @__PURE__ */ Symbol.for("sidecar.resourceResult");
+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 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 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 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 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.
+`;
+}
+export {
+  CompilerError,
+  analyzeProjectConfig,
+  analyzeProjectPrompts,
+  analyzeProjectResources,
+  analyzeProjectTools,
+  analyzePromptFile,
+  analyzeResourceFile,
+  analyzeToolFile,
+  buildProject,
+  collectProjectDiagnostics,
+  formatDiagnostic
+};
+//# sourceMappingURL=index.js.map