@sidecar-ai/compiler 0.1.0-alpha.10 → 0.1.0-alpha.12

package/dist/index.d.ts

@@ -1,149 +1,7 @@
-import { BuildHost, BuildTarget, WidgetBuildConfig, JsonSchema, ToolAnnotations, ToolVisibility, ToolWidgetOptions, McpToolDescriptor, ResourceAnnotations, McpResourceDescriptor, McpResourceTemplateDescriptor, PromptArgsDefinition, McpPromptDescriptor } from '@sidecar-ai/core';
+import { JsonSchema } from '@sidecar-ai/core';
 import { SourceFile } from 'ts-morph';
-
-/** Diagnostic severity surfaced by the CLI and future editor integrations. */
-type DiagnosticSeverity = "warning" | "error";
-/** Stable diagnostic emitted for a concrete project source location. */
-type SidecarDiagnostic = {
-    severity: DiagnosticSeverity;
-    code: string;
-    message: string;
-    filePath: string;
-    line: number;
-    column: number;
-    hint?: string;
-};
-/** Collects project-level warnings that do not block compilation by default. */
-declare function collectProjectDiagnostics(rootDir: string, input: SidecarToolManifestEntry[] | {
-    tools: SidecarToolManifestEntry[];
-    resources?: SidecarResourceManifestEntry[];
-    prompts?: SidecarPromptManifestEntry[];
-    config?: SidecarCompilerConfig;
-}): Promise<SidecarDiagnostic[]>;
-/** Formats diagnostics in a TypeScript-style shape understood by many editors. */
-declare function formatDiagnostic(diagnostic: SidecarDiagnostic): string;
-
-/** Manifest and option types shared across the Sidecar compiler modules. */
-
-/** Build target profile selected by reserved platform file suffixes. */
-type SidecarTarget = BuildTarget;
-/** Host runtime artifact emitted for a build output. */
-type SidecarHost = BuildHost;
-/** Platform suffix chosen for a reserved tool or widget file. */
-type SidecarSourceVariant = "shared" | "openai" | "anthropic";
-/** Tool entry emitted into `manifest.sidecar.json`. */
-type SidecarToolManifestEntry = {
-    sourceFile: string;
-    variant: SidecarSourceVariant;
-    target: SidecarTarget;
-    directory: string;
-    id: string;
-    name: string;
-    description: string;
-    inputSchema: JsonSchema;
-    outputSchema?: JsonSchema;
-    annotations?: ToolAnnotations;
-    visibility?: ToolVisibility;
-    widget?: SidecarWidgetManifestEntry;
-    descriptor: McpToolDescriptor;
-};
-/** Widget resource linked to a tool entry. */
-type SidecarWidgetManifestEntry = {
-    sourceFile: string;
-    variant: SidecarSourceVariant;
-    resourceUri: string;
-    resourceMeta?: Record<string, unknown>;
-    outputFile?: string;
-    options?: ToolWidgetOptions;
-};
-/** Static resource entry emitted into `manifest.sidecar.json`. */
-type SidecarResourceManifestEntry = {
-    sourceFile: string;
-    directory: string;
-    uri: string;
-    name: string;
-    title?: string;
-    description?: string;
-    mimeType?: string;
-    size?: number;
-    annotations?: ResourceAnnotations;
-    subscribe?: boolean;
-    descriptor: McpResourceDescriptor;
-};
-/** Static resource template entry emitted into `manifest.sidecar.json`. */
-type SidecarResourceTemplateManifestEntry = {
-    uriTemplate: string;
-    name: string;
-    title?: string;
-    description?: string;
-    mimeType?: string;
-    annotations?: ResourceAnnotations;
-    descriptor: McpResourceTemplateDescriptor;
-};
-/** Static prompt entry emitted into `manifest.sidecar.json`. */
-type SidecarPromptManifestEntry = {
-    sourceFile: string;
-    directory: string;
-    name: string;
-    title: string;
-    description?: string;
-    args?: PromptArgsDefinition;
-    descriptor: McpPromptDescriptor;
-};
-/** Serializable project config subset recorded in build manifests. */
-type SidecarCompilerConfig = {
-    build: {
-        target?: SidecarTarget;
-        host?: SidecarHost;
-        outDir?: string;
-        plugins?: boolean;
-        widgets?: WidgetBuildConfig;
-    };
-    resources: {
-        subscribe: boolean;
-        listChanged: boolean;
-    };
-    prompts: {
-        listChanged: boolean;
-    };
-    tools: {
-        listChanged: boolean;
-    };
-    pagination: {
-        pageSize: number;
-        hasOverride: boolean;
-    };
-};
-/** Build manifest produced for a Sidecar MCP output. */
-type SidecarManifest = {
-    version: 1;
-    target: SidecarTarget;
-    host: SidecarHost;
-    rootDir: string;
-    generatedAt: string;
-    config: SidecarCompilerConfig;
-    tools: SidecarToolManifestEntry[];
-    resources: SidecarResourceManifestEntry[];
-    resourceTemplates: SidecarResourceTemplateManifestEntry[];
-    prompts: SidecarPromptManifestEntry[];
-    diagnostics?: SidecarDiagnostic[];
-};
-/** Options accepted by `buildProject()`. */
-type BuildProjectOptions = {
-    rootDir: string;
-    host?: SidecarHost;
-    outDir?: string;
-    plugins?: boolean;
-    strict?: boolean;
-    target?: SidecarTarget;
-};
-/** Project identity used by generated plugin packages. */
-type ProjectIdentity = {
-    name: string;
-    slug: string;
-    version: string;
-    description: string;
-};
+import { h as SidecarTarget, i as SidecarToolManifestEntry, g as SidecarSourceVariant, B as BuildProjectOptions, c as SidecarManifest, S as SidecarCompilerConfig, d as SidecarPromptManifestEntry, e as SidecarResourceManifestEntry } from '../types-CWHwikML.js';
+export { P as ProjectIdentity, a as SidecarDiagnostic, b as SidecarHost, f as SidecarResourceTemplateManifestEntry, j as SidecarWidgetManifestEntry, k as collectProjectDiagnostics, l as formatDiagnostic } from '../types-CWHwikML.js';
 
 /** Static analysis for reserved server tool files. */
 
@@ -191,4 +49,4 @@ declare const SERVER_ENTRYPOINT = "server/index.js";
 /** Relative location of the Vercel Build Output API function entrypoint. */
 declare const VERCEL_ENTRYPOINT = "functions/api/sidecar.func/index.js";
 
-export { type BuildProjectOptions, CompilerError, type ProjectIdentity, SERVER_ENTRYPOINT, type SidecarCompilerConfig, type SidecarDiagnostic, type SidecarHost, type SidecarManifest, type SidecarPromptManifestEntry, type SidecarResourceManifestEntry, type SidecarResourceTemplateManifestEntry, type SidecarSourceVariant, type SidecarTarget, type SidecarToolManifestEntry, type SidecarWidgetManifestEntry, VERCEL_ENTRYPOINT, analyzeProjectConfig, analyzeProjectPrompts, analyzeProjectResources, analyzeProjectTools, analyzePromptFile, analyzeResourceFile, analyzeToolFile, buildProject, collectProjectDiagnostics, formatDiagnostic };
+export { BuildProjectOptions, CompilerError, SERVER_ENTRYPOINT, SidecarCompilerConfig, SidecarManifest, SidecarPromptManifestEntry, SidecarResourceManifestEntry, SidecarSourceVariant, SidecarTarget, SidecarToolManifestEntry, VERCEL_ENTRYPOINT, analyzeProjectConfig, analyzeProjectPrompts, analyzeProjectResources, analyzeProjectTools, analyzePromptFile, analyzeResourceFile, analyzeToolFile, buildProject };

package/dist/index.js

@@ -815,6 +815,83 @@ createRoot(document.getElementById("root")!).render(
     entry.descriptor._meta = mergeWidgetMeta(entry.descriptor._meta, widgetMeta(resourceUri, entry.widget.options, entry.target));
   }
 }
+async function buildCodeModeWidget(rootDir, outDir, tools, target, config = void 0) {
+  const renderable = tools.filter(
+    (entry) => Boolean(entry.widget)
+  );
+  if (!renderable.length) {
+    return void 0;
+  }
+  const cacheDir = path4.join(rootDir, ".sidecar", "cache", "widgets");
+  await mkdir(cacheDir, { recursive: true });
+  const appStyle = await prepareAppStyle(rootDir, cacheDir);
+  const configure = await loadWidgetBundlerHook(rootDir, cacheDir, config?.configure);
+  const safeId = "code-mode";
+  const entryFile = path4.join(cacheDir, `${safeId}.entry.tsx`);
+  await writeFile(entryFile, renderCodeModeWidgetEntry(rootDir, entryFile, renderable, appStyle));
+  const baseOptions = enforceWidgetBuildInvariants({
+    absWorkingDir: rootDir,
+    alias: sidecarWidgetAliases(rootDir),
+    bundle: true,
+    define: {
+      "process.env.NODE_ENV": JSON.stringify("production")
+    },
+    entryPoints: [entryFile],
+    format: "iife",
+    jsx: "automatic",
+    minify: true,
+    nodePaths: [
+      path4.join(rootDir, "node_modules"),
+      path4.join(process.cwd(), "node_modules")
+    ],
+    outfile: "widget.js",
+    platform: "browser",
+    sourcemap: false,
+    write: false
+  });
+  const staticOptions = widgetBuildOptionsFromConfig(rootDir, config);
+  const configuredOptions = configure ? await configureWidgetBuild(configure, {
+    rootDir,
+    outDir,
+    entryFile,
+    widget: {
+      toolId: "execute_code",
+      toolName: "Execute Code",
+      target,
+      sourceFile: path4.relative(rootDir, entryFile)
+    },
+    esbuildOptions: mergeWidgetBuildOptions(baseOptions, staticOptions)
+  }) : void 0;
+  const bundled = await esbuild(enforceWidgetBuildInvariants(
+    mergeWidgetBuildOptions(baseOptions, staticOptions, configuredOptions),
+    { rootDir, entryFile }
+  ));
+  const outputFiles = bundled.outputFiles ?? [];
+  const javascript = outputFiles.find((file) => file.path.endsWith(".js"))?.text ?? "";
+  const css = outputFiles.filter((file) => file.path.endsWith(".css")).map((file) => file.text).join("\n");
+  const html = renderWidgetHtml("Execute Code", javascript, css);
+  const hash = createHash("sha256").update(html).digest("hex").slice(0, 12);
+  const outputDir = path4.join(outDir, "public", "widgets", safeId);
+  const outputFile = path4.join(outputDir, `widget.${hash}.html`);
+  const resourceUri = `ui://${safeId}/widget.${hash}.html`;
+  const options = {
+    description: "Renders the selected result from a Sidecar code-mode execution.",
+    csp: {
+      connectDomains: [],
+      resourceDomains: []
+    }
+  };
+  await mkdir(outputDir, { recursive: true });
+  await writeFile(outputFile, html);
+  return {
+    sourceFile: path4.relative(rootDir, entryFile),
+    variant: "shared",
+    resourceUri,
+    resourceMeta: widgetResourceMeta(options, target),
+    outputFile: path4.relative(outDir, outputFile),
+    options
+  };
+}
 function widgetBuildOptionsFromConfig(rootDir, config) {
   const esbuildConfig = config?.esbuild;
   if (!esbuildConfig) {
@@ -911,6 +988,105 @@ function enforceWidgetBuildInvariants(options, required) {
     write: false
   };
 }
+function renderCodeModeWidgetEntry(rootDir, entryFile, entries, appStyle) {
+  const entryDir = path4.dirname(entryFile);
+  const imports = entries.map((entry, index) => {
+    const sourceFile = path4.join(rootDir, entry.widget.sourceFile);
+    return `import Widget${index} from ${JSON.stringify(toImportSpecifier(entryDir, sourceFile))};`;
+  }).join("\n");
+  const registry = entries.map((entry, index) => `${JSON.stringify(entry.id)}: Widget${index}`).join(",\n  ");
+  return `import React, { useMemo } from "react";
+import { createRoot } from "react-dom/client";
+import {
+  SidecarWidgetProvider,
+  SidecarWidgetRoot,
+  browserBridge,
+  useToolResult
+} from "@sidecar-ai/react";
+import { Heading, Stack, Surface, Text } from "@sidecar-ai/native/components";
+import "@sidecar-ai/native/styles.css";
+${appStyle ? `import ${JSON.stringify(toImportSpecifier(entryDir, appStyle))};` : ""}
+${imports}
+
+const registry = {
+  ${registry}
+};
+
+function nestedResult(result, payload) {
+  return {
+    ...result,
+    structuredContent: payload?.result ?? payload?.value,
+    structured: payload?.result ?? payload?.value,
+    content: payload?.content ?? result.content ?? [],
+    meta: payload?.meta ?? result.meta ?? {},
+    _meta: payload?.meta ?? result._meta ?? {},
+  };
+}
+
+function createNestedBridge(result, payload) {
+  return {
+    ...browserBridge,
+    getToolResult() {
+      return nestedResult(result, payload);
+    },
+    subscribeToolResult(listener) {
+      return browserBridge.subscribeToolResult((next) => {
+        const nextPayload = next?.structuredContent?.codeMode;
+        listener(nestedResult(next, nextPayload));
+      });
+    },
+  };
+}
+
+function GenericCodeModeResult({ payload }) {
+  return React.createElement("main", { className: "sidecar-code-mode" },
+    React.createElement(Stack, { gap: "md" },
+      React.createElement(Heading, { level: 1 }, "Code result"),
+      React.createElement(Surface, { variant: "card" },
+        React.createElement("pre", {
+          style: {
+            margin: 0,
+            overflowWrap: "anywhere",
+            whiteSpace: "pre-wrap"
+          }
+        }, JSON.stringify(payload?.value ?? payload ?? {}, null, 2))
+      )
+    )
+  );
+}
+
+function CodeModeWidget() {
+  const result = useToolResult();
+  const payload = result.structuredContent?.codeMode;
+  const renderer = payload?.renderer;
+  const Component = renderer ? registry[renderer] : undefined;
+  const bridge = useMemo(() => createNestedBridge(result, payload), [result, payload]);
+
+  if (Component) {
+    return React.createElement(
+      SidecarWidgetProvider,
+      { bridge },
+      React.createElement(Component)
+    );
+  }
+
+  if (payload?.ok === false) {
+    return React.createElement("main", { className: "sidecar-code-mode" },
+      React.createElement(Stack, { gap: "sm" },
+        React.createElement(Heading, { level: 1 }, "Code failed"),
+        React.createElement(Text, { tone: "muted" }, "The generated code did not complete successfully.")
+      )
+    );
+  }
+
+  return React.createElement(GenericCodeModeResult, { payload });
+}
+
+createRoot(document.getElementById("root")).render(
+  React.createElement(SidecarWidgetRoot, null, React.createElement(CodeModeWidget))
+);
+`;
+}
 function sidecarWidgetAliases(rootDir) {
   return {
     ...devSidecarBundleAliases(rootDir) ?? {},
@@ -959,6 +1135,7 @@ function devSidecarBundleAliases(rootDir) {
     return void 0;
   }
   return {
+    "sidecar-ai/remote": path4.join(repoRoot, "packages", "sidecar-ai", "src", "remote.ts"),
     "sidecar-ai": path4.join(repoRoot, "packages", "sidecar-ai", "src", "index.ts"),
     "@sidecar-ai/client": path4.join(repoRoot, "packages", "client", "src", "index.ts"),
     "@sidecar-ai/core": path4.join(repoRoot, "packages", "core", "src", "index.ts"),
@@ -1720,6 +1897,7 @@ function readStringArrayProperty2(definition, propertyName) {
 
 // packages/compiler/src/build.ts
 import { mkdir as mkdir9, writeFile as writeFile9 } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
 import path19 from "path";
 
 // packages/compiler/src/config.ts
@@ -1761,6 +1939,10 @@ function analyzeProjectConfig(rootDir) {
     pagination: {
       pageSize: readNumberNested(definition, "pagination", "pageSize") ?? 50,
       hasOverride: hasProperty(readObjectProperty3(definition, "pagination"), "override")
+    },
+    codeMode: readCodeModeConfig(definition),
+    remoteExecution: {
+      enabled: readBooleanProperty3(definition, "remoteExecution") ?? false
     }
   };
 }
@@ -1818,9 +2000,75 @@ function defaultCompilerConfig() {
     pagination: {
       pageSize: 50,
       hasOverride: false
+    },
+    codeMode: {
+      enabled: false,
+      unsafe: false,
+      render: {
+        enabled: true,
+        strategy: "last-renderable"
+      }
+    },
+    remoteExecution: {
+      enabled: false
     }
   };
 }
+function readCodeModeConfig(definition) {
+  const defaults = defaultCompilerConfig().codeMode;
+  const property = definition.getProperty("codeMode");
+  if (!property || !Node5.isPropertyAssignment(property)) {
+    return defaults;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  if (!initializer) {
+    return defaults;
+  }
+  if (initializer.getKind() === SyntaxKind3.TrueKeyword) {
+    return { ...defaults, enabled: true };
+  }
+  if (initializer.getKind() === SyntaxKind3.FalseKeyword) {
+    return { ...defaults, enabled: false };
+  }
+  if (!Node5.isObjectLiteralExpression(initializer)) {
+    return defaults;
+  }
+  return {
+    enabled: true,
+    unsafe: readBooleanProperty3(initializer, "unsafe") ?? false,
+    render: readCodeModeRenderConfig(initializer) ?? defaults.render
+  };
+}
+function readCodeModeRenderConfig(definition) {
+  const property = definition.getProperty("render");
+  if (!property || !Node5.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = unwrapExpression(property.getInitializer());
+  if (!initializer) {
+    return void 0;
+  }
+  if (initializer.getKind() === SyntaxKind3.TrueKeyword) {
+    return { enabled: true, strategy: "last-renderable" };
+  }
+  if (initializer.getKind() === SyntaxKind3.FalseKeyword) {
+    return { enabled: false, strategy: "last-renderable" };
+  }
+  if (!Node5.isObjectLiteralExpression(initializer)) {
+    return void 0;
+  }
+  return {
+    enabled: readBooleanProperty3(initializer, "enabled") ?? true,
+    strategy: readRenderStrategy(initializer) ?? "last-renderable"
+  };
+}
+function readRenderStrategy(definition) {
+  const value = readStringProperty3(definition, "strategy");
+  if (value === "last-renderable" || value === "first-renderable" || value === "explicit") {
+    return value;
+  }
+  return void 0;
+}
 function readTargetNested(definition, section, propertyName) {
   const value = readStringNested(definition, section, propertyName);
   return value === "mcp" || value === "chatgpt" || value === "claude" ? value : void 0;
@@ -1841,7 +2089,10 @@ function readBooleanNested(definition, section, propertyName) {
   if (!object) {
     return void 0;
   }
-  const property = object.getProperty(propertyName);
+  return readBooleanProperty3(object, propertyName);
+}
+function readBooleanProperty3(definition, propertyName) {
+  const property = definition.getProperty(propertyName);
   if (!property || !Node5.isPropertyAssignment(property)) {
     return void 0;
   }
@@ -2870,12 +3121,12 @@ function readArgInput(node) {
   if (Node7.isObjectLiteralExpression(initializer)) {
     return {
       description: getOptionalStringProperty2(initializer, "description"),
-      required: readBooleanProperty3(initializer, "required")
+      required: readBooleanProperty4(initializer, "required")
     };
   }
   return void 0;
 }
-function readBooleanProperty3(definition, propertyName) {
+function readBooleanProperty4(definition, propertyName) {
   const property = definition.getProperty(propertyName);
   if (!property || !Node7.isPropertyAssignment(property)) {
     return void 0;
@@ -2994,7 +3245,7 @@ function analyzeResourceFile(sourceFile, rootDir) {
     mimeType: descriptor.mimeType,
     size: descriptor.size,
     annotations: descriptor.annotations,
-    subscribe: readBooleanProperty4(definition, "subscribe"),
+    subscribe: readBooleanProperty5(definition, "subscribe"),
     descriptor
   };
 }
@@ -3055,7 +3306,7 @@ function getOptionalNumberProperty(definition, propertyName) {
   const initializer = unwrapExpression(property.getInitializer());
   return initializer && Node8.isNumericLiteral(initializer) ? Number(initializer.getLiteralText()) : void 0;
 }
-function readBooleanProperty4(definition, propertyName) {
+function readBooleanProperty5(definition, propertyName) {
   const property = definition.getProperty(propertyName);
   if (!property || !Node8.isPropertyAssignment(property)) {
     return void 0;
@@ -3203,7 +3454,7 @@ function renderServerEntry(rootDir, entryFile, manifest, identity) {
     `import { pathToFileURL } from "node:url";`,
     `import { createSidecarHttpHandler } from "@sidecar-ai/server";`,
     `import { isSidecarAuth } from "@sidecar-ai/auth";`,
-    `import { isSidecarPrompt, isSidecarResource, isSidecarTool } from "@sidecar-ai/core";`,
+    `import { isSidecarPrompt, isSidecarRemote, isSidecarResource, isSidecarTool } from "@sidecar-ai/core";`,
     `import { isSidecarProxy } from "@sidecar-ai/server/proxy";`,
     ...tools.map(
       (entry, index) => `import tool${index} from ${JSON.stringify(toImportSpecifier(entryDir, path18.join(rootDir, entry.sourceFile)))};`
@@ -3216,6 +3467,7 @@ function renderServerEntry(rootDir, entryFile, manifest, identity) {
     ),
     existsSync6(path18.join(rootDir, "auth.ts")) ? `import authExport from ${JSON.stringify(toImportSpecifier(entryDir, path18.join(rootDir, "auth.ts")))};` : `const authExport = undefined;`,
     existsSync6(path18.join(rootDir, "proxy.ts")) ? `import proxyExport from ${JSON.stringify(toImportSpecifier(entryDir, path18.join(rootDir, "proxy.ts")))};` : `const proxyExport = undefined;`,
+    existsSync6(path18.join(rootDir, "remote.ts")) ? `import remoteExport from ${JSON.stringify(toImportSpecifier(entryDir, path18.join(rootDir, "remote.ts")))};` : `const remoteExport = undefined;`,
     existsSync6(path18.join(rootDir, "sidecar.config.ts")) ? `import configExport from ${JSON.stringify(toImportSpecifier(entryDir, path18.join(rootDir, "sidecar.config.ts")))};` : `const configExport = undefined;`
   ].join("\n");
   return `${imports}
@@ -3228,6 +3480,9 @@ const auth = loadedAuth && process.env.SIDECAR_MCP_URL
   ? loadedAuth.withResource(process.env.SIDECAR_MCP_URL)
   : loadedAuth;
 const proxy = proxyExport === undefined ? undefined : assertProxy(proxyExport);
+const remoteExecution = manifest.codeMode?.remoteExecution
+  ? assertRemote(remoteExport)
+  : undefined;
 const runtimeConfig = configExport && typeof configExport === "object" ? configExport : undefined;
 
 if (auth && !process.env.SIDECAR_MCP_URL) {
@@ -3241,6 +3496,21 @@ export const handler = createSidecarHttpHandler({
   publicUrl: process.env.SIDECAR_PUBLIC_URL ?? process.env.SIDECAR_MCP_URL,
   auth,
   proxy,
+  codeMode: manifest.codeMode
+    ? {
+        enabled: true,
+        unsafe: manifest.codeMode.unsafe,
+        render: manifest.codeMode.render,
+        widgetMeta: manifest.codeMode.widget?.resourceUri
+          ? {
+              ui: { resourceUri: manifest.codeMode.widget.resourceUri },
+              "ui/resourceUri": manifest.codeMode.widget.resourceUri,
+              ...(manifest.target === "chatgpt" ? { "openai/outputTemplate": manifest.codeMode.widget.resourceUri } : {}),
+            }
+          : undefined,
+      }
+    : undefined,
+  remoteExecution,
   tools: [
 ${tools.map((entry, index) => `    loadTool(${JSON.stringify(entry.sourceFile)}, tool${index}, manifest.tools[${index}].descriptor),`).join("\n")}
   ],
@@ -3272,12 +3542,23 @@ if (isDirectRun()) {
   server.listen(port, host, () => {
     const localHost = host === "0.0.0.0" ? "127.0.0.1" : host;
     console.log(\`MCP running on Streamable HTTP at http://\${localHost}:\${port}\${process.env.SIDECAR_MCP_PATH ?? "/mcp"}\`);
+    printRuntimeUrls(localHost, port);
   });
 
   process.on("SIGTERM", () => shutdown());
   process.on("SIGINT", () => shutdown());
 }
 
+function printRuntimeUrls(localHost, port) {
+  const mcpPath = process.env.SIDECAR_MCP_PATH ?? "/mcp";
+  console.log("Sidecar URLs:");
+  console.log(\`  Local MCP: http://\${localHost}:\${port}\${mcpPath}\`);
+  console.log(\`  Public MCP: \${process.env.SIDECAR_MCP_URL ?? "set SIDECAR_MCP_URL=https://your-host.example.com" + mcpPath}\`);
+  if (process.env.SIDECAR_PUBLIC_URL) {
+    console.log(\`  Public base: \${process.env.SIDECAR_PUBLIC_URL}\`);
+  }
+}
+
 function loadTool(sourceFile, value, descriptor) {
   const tool = unwrapRuntimeDefault(value);
   if (!isSidecarTool(tool)) {
@@ -3322,6 +3603,14 @@ function assertProxy(value) {
   return proxyValue;
 }
 
+function assertRemote(value) {
+  const remoteValue = unwrapRuntimeDefault(value);
+  if (!isSidecarRemote(remoteValue)) {
+    throw new Error("remote.ts must default-export remote({ execute }) from sidecar-ai/remote.");
+  }
+  return remoteValue;
+}
+
 function unwrapRuntimeDefault(value) {
   if (
     value &&
@@ -3362,7 +3651,7 @@ function shutdown() {
 `;
 }
 function renderWidgetResources(manifest) {
-  return manifest.tools.filter((entry) => entry.widget?.outputFile).map((entry) => `    {
+  const toolWidgets = manifest.tools.filter((entry) => entry.widget?.outputFile).map((entry) => `    {
       uri: ${JSON.stringify(entry.widget?.resourceUri)},
       name: ${JSON.stringify(entry.name)},
       description: ${JSON.stringify(entry.widget?.options?.description)},
@@ -3370,6 +3659,15 @@ function renderWidgetResources(manifest) {
       text: readWidget(${JSON.stringify(entry.widget?.outputFile)}),
       _meta: ${JSON.stringify(entry.widget?.resourceMeta ?? void 0)},
     },`).join("\n");
+  const codeModeWidget = manifest.codeMode?.widget?.outputFile ? `    {
+      uri: ${JSON.stringify(manifest.codeMode.widget.resourceUri)},
+      name: "Execute Code",
+      description: ${JSON.stringify(manifest.codeMode.widget.options?.description)},
+      mimeType: "text/html;profile=mcp-app",
+      text: readWidget(${JSON.stringify(manifest.codeMode.widget.outputFile)}),
+      _meta: ${JSON.stringify(manifest.codeMode.widget.resourceMeta ?? void 0)},
+    },` : "";
+  return [codeModeWidget, toolWidgets].filter(Boolean).join("\n");
 }
 function renderServerPackage(identity) {
   return `${JSON.stringify({
@@ -3419,6 +3717,7 @@ function sidecarBundleAliases(rootDir) {
     return void 0;
   }
   return {
+    "sidecar-ai/remote": path18.join(repoRoot, "packages", "sidecar-ai", "src", "remote.ts"),
     "sidecar-ai": path18.join(repoRoot, "packages", "sidecar-ai", "src", "index.ts"),
     "@sidecar-ai/auth": path18.join(repoRoot, "packages", "auth", "src", "index.ts"),
     "@sidecar-ai/core": path18.join(repoRoot, "packages", "core", "src", "index.ts"),
@@ -3462,6 +3761,12 @@ async function buildProject(options) {
   const target = options.target ?? config.build.target ?? "mcp";
   const host = options.host ?? config.build.host ?? "node";
   const plugins = options.plugins ?? config.build.plugins ?? false;
+  if (config.codeMode.enabled && !config.codeMode.unsafe && !config.remoteExecution.enabled) {
+    throw new Error("Code mode requires remoteExecution: true, or codeMode: { unsafe: true } for trusted local use.");
+  }
+  if (config.codeMode.enabled && config.remoteExecution.enabled && !existsSync7(path19.join(rootDir, "remote.ts"))) {
+    throw new Error("remoteExecution: true requires a reserved remote.ts file at the project root.");
+  }
   const tools = await analyzeProjectTools(rootDir, { target });
   const resources = await analyzeProjectResources(rootDir);
   const resourceTemplates = [];
@@ -3480,6 +3785,7 @@ async function buildProject(options) {
   const outDir = resolveInsideRoot(rootDir, options.outDir ?? config.build.outDir ?? defaultBuildOutDir(host, target));
   const runtimeOutDir = resolveRuntimeOutputDir(outDir, host);
   await buildWidgets(rootDir, runtimeOutDir, tools, config.build.widgets);
+  const codeModeWidget = config.codeMode.enabled && config.codeMode.render.enabled ? await buildCodeModeWidget(rootDir, runtimeOutDir, tools, target, config.build.widgets) : void 0;
   const manifest = {
     version: 1,
     target,
@@ -3488,6 +3794,13 @@ async function buildProject(options) {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     config,
     tools,
+    codeMode: config.codeMode.enabled ? {
+      enabled: true,
+      unsafe: config.codeMode.unsafe,
+      remoteExecution: config.remoteExecution.enabled,
+      render: config.codeMode.render,
+      widget: codeModeWidget
+    } : void 0,
     resources,
     resourceTemplates,
     prompts,