@sidecar-ai/cli 0.1.0-alpha.4 → 0.1.0-alpha.6

package/dist/index.js

@@ -1686,6 +1686,12 @@ function analyzeProjectConfig(rootDir) {
     return defaultCompilerConfig();
   }
   return {
+    build: {
+      target: readTargetNested(definition, "build", "target"),
+      host: readHostNested(definition, "build", "host"),
+      outDir: readStringNested(definition, "build", "outDir"),
+      plugins: readBooleanNested(definition, "build", "plugins")
+    },
     resources: {
       subscribe: readBooleanNested(definition, "resources", "subscribe") ?? false,
       listChanged: readBooleanNested(definition, "resources", "listChanged") ?? false
@@ -1704,6 +1710,7 @@ function analyzeProjectConfig(rootDir) {
 }
 function defaultCompilerConfig() {
   return {
+    build: {},
     resources: {
       subscribe: false,
       listChanged: false
@@ -1720,6 +1727,26 @@ function defaultCompilerConfig() {
     }
   };
 }
+function readTargetNested(definition, section, propertyName) {
+  const value = readStringNested(definition, section, propertyName);
+  return value === "mcp" || value === "chatgpt" || value === "claude" ? value : void 0;
+}
+function readHostNested(definition, section, propertyName) {
+  const value = readStringNested(definition, section, propertyName);
+  return value === "node" || value === "vercel" ? value : void 0;
+}
+function readStringNested(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.isStringLiteral(initializer) ? initializer.getLiteralText() : void 0;
+}
 function readBooleanNested(definition, section, propertyName) {
   const object = readObjectProperty3(definition, section);
   if (!object) {
@@ -2987,8 +3014,10 @@ import { mkdir as mkdir8, rm, writeFile as writeFile8 } from "fs/promises";
 import path17 from "path";
 import { build as esbuild2 } from "esbuild";
 var SERVER_ENTRYPOINT = "server/index.js";
-var VERCEL_ENTRYPOINT = "api/sidecar.js";
-async function buildServerOutput(rootDir, outDir, manifest, identity, host = "node") {
+var VERCEL_FUNCTION_DIR = "functions/api/sidecar.func";
+var VERCEL_ENTRYPOINT = `${VERCEL_FUNCTION_DIR}/index.js`;
+var VERCEL_HANDLER_FILE = "index.js";
+async function buildServerOutput(rootDir, outDir, manifest, identity, host = "node", options = {}) {
   const cacheDir = path17.join(rootDir, ".sidecar", "cache", "server");
   await mkdir8(cacheDir, { recursive: true });
   const entryFile = path17.join(cacheDir, "index.ts");
@@ -3018,9 +3047,13 @@ const require = __sidecarCreateRequire(import.meta.url);`
   });
   await writeFile8(path17.join(outDir, "package.json"), renderServerPackage(identity));
   if (host === "vercel") {
-    await mkdir8(path17.join(outDir, "api"), { recursive: true });
-    await writeFile8(path17.join(outDir, VERCEL_ENTRYPOINT), renderVercelEntrypoint());
-    await writeFile8(path17.join(outDir, "vercel.json"), renderVercelConfig());
+    const vercelOutputDir = options.vercelOutputDir ?? outDir;
+    await rm(path17.join(vercelOutputDir, "api"), { recursive: true, force: true });
+    await rm(path17.join(vercelOutputDir, "vercel.json"), { force: true });
+    await writeFile8(path17.join(outDir, VERCEL_HANDLER_FILE), renderVercelEntrypoint());
+    await writeFile8(path17.join(outDir, ".vc-config.json"), renderVercelFunctionConfig());
+    await mkdir8(vercelOutputDir, { recursive: true });
+    await writeFile8(path17.join(vercelOutputDir, "config.json"), renderVercelOutputConfig());
   } else {
     await rm(path17.join(outDir, "api"), { recursive: true, force: true });
     await rm(path17.join(outDir, "vercel.json"), { force: true });
@@ -3221,23 +3254,29 @@ function renderServerPackage(identity) {
 `;
 }
 function renderVercelEntrypoint() {
-  return `export { default } from "../server/index.js";
+  return `export { default } from "./server/index.js";
+`;
+}
+function renderVercelFunctionConfig() {
+  return `${JSON.stringify({
+    runtime: "nodejs22.x",
+    handler: VERCEL_HANDLER_FILE,
+    launcherType: "Nodejs",
+    shouldAddHelpers: true,
+    supportsResponseStreaming: true,
+    maxDuration: 300
+  }, null, 2)}
 `;
 }
-function renderVercelConfig() {
+function renderVercelOutputConfig() {
   return `${JSON.stringify({
-    rewrites: [
+    version: 3,
+    routes: [
       {
-        source: "/(.*)",
-        destination: "/api/sidecar"
+        src: "/(.*)",
+        dest: "/api/sidecar"
       }
-    ],
-    functions: {
-      "api/sidecar.js": {
-        includeFiles: "public/**",
-        maxDuration: 300
-      }
-    }
+    ]
   }, null, 2)}
 `;
 }
@@ -3286,9 +3325,10 @@ function findSidecarRepoRoot2(startDir) {
 // packages/compiler/src/build.ts
 async function buildProject(options) {
   const rootDir = path18.resolve(options.rootDir);
-  const target = options.target ?? "mcp";
-  const host = options.host ?? "node";
   const config = analyzeProjectConfig(rootDir);
+  const target = options.target ?? config.build.target ?? "mcp";
+  const host = options.host ?? config.build.host ?? "node";
+  const plugins = options.plugins ?? config.build.plugins ?? false;
   const tools = await analyzeProjectTools(rootDir, { target });
   const resources = await analyzeProjectResources(rootDir);
   const resourceTemplates = [];
@@ -3304,8 +3344,9 @@ async function buildProject(options) {
   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 outDir = resolveInsideRoot(rootDir, options.outDir ?? config.build.outDir ?? defaultBuildOutDir(host, target));
+  const runtimeOutDir = resolveRuntimeOutputDir(outDir, host);
+  await buildWidgets(rootDir, runtimeOutDir, tools);
   const manifest = {
     version: 1,
     target,
@@ -3319,20 +3360,43 @@ async function buildProject(options) {
     prompts,
     diagnostics
   };
-  await mkdir9(outDir, { recursive: true });
+  await mkdir9(runtimeOutDir, { recursive: true });
   await writeFile9(
-    path18.join(outDir, "manifest.sidecar.json"),
+    path18.join(runtimeOutDir, "manifest.sidecar.json"),
     `${JSON.stringify(manifest, null, 2)}
 `
   );
-  await writeFile9(path18.join(outDir, "README.md"), renderMcpReadme(manifest));
+  await writeFile9(path18.join(runtimeOutDir, "README.md"), renderMcpReadme(manifest));
   await writeGeneratedTypes(rootDir, tools);
-  await buildServerOutput(rootDir, outDir, manifest, identity, host);
-  if (options.plugins) {
-    await buildPluginPackages(rootDir, path18.dirname(outDir), manifest);
+  await buildServerOutput(rootDir, runtimeOutDir, manifest, identity, host, {
+    vercelOutputDir: outDir
+  });
+  if (plugins) {
+    await buildPluginPackages(rootDir, resolvePluginOutputBase(rootDir, outDir, host), manifest);
   }
   return manifest;
 }
+function defaultBuildOutDir(host, target) {
+  if (host === "vercel") {
+    return ".vercel/output";
+  }
+  return `out/${target}`;
+}
+function resolveRuntimeOutputDir(outDir, host) {
+  if (host === "vercel") {
+    return path18.join(outDir, VERCEL_FUNCTION_DIR);
+  }
+  return outDir;
+}
+function resolvePluginOutputBase(rootDir, outDir, host) {
+  if (host === "vercel" && isVercelBuildOutputDir(outDir)) {
+    return path18.join(rootDir, "out");
+  }
+  return path18.dirname(outDir);
+}
+function isVercelBuildOutputDir(outDir) {
+  return path18.basename(outDir) === "output" && path18.basename(path18.dirname(outDir)) === ".vercel";
+}
 function resolveInsideRoot(rootDir, output) {
   const resolved = path18.resolve(rootDir, output);
   const relative = path18.relative(rootDir, resolved);
@@ -3389,7 +3453,7 @@ Set \`PORT\` or \`SIDECAR_PORT\` to choose the listen port. Hosted/authenticated
 function renderVercelReadmeSection() {
   return `## Deploy To Vercel
 
-This output includes a Vercel Function shim at \`api/sidecar.js\` and a \`vercel.json\` rewrite that sends Streamable HTTP traffic to \`/mcp\`. Deploy this output directory with Vercel and set \`SIDECAR_MCP_URL\` to the public \`https://.../mcp\` URL.
+This output uses Vercel's Build Output API. The MCP function is emitted at \`${VERCEL_FUNCTION_DIR}\`, and \`config.json\` routes Streamable HTTP traffic to it. Set \`SIDECAR_MCP_URL\` to the public \`https://.../mcp\` URL in Vercel.
 `;
 }
 
@@ -3899,6 +3963,11 @@ function createSidecarHttpHandler(options) {
   const streamHub = createSseHub();
   const mcp = createSidecarMcpServer(options);
   return async (request, response) => {
+    const pathname = request.url?.split("?")[0];
+    const requestLog = createHttpRequestLog(request, pathname);
+    response.once("finish", () => {
+      logHttpRequest(requestLog, response.statusCode);
+    });
     if (isRejectedOrigin(request, options.allowedOrigins)) {
       response.writeHead(403, { "content-type": "application/json" });
       response.end(JSON.stringify({ error: "forbidden_origin" }));
@@ -3910,16 +3979,17 @@ function createSidecarHttpHandler(options) {
       response.end(proxyResult.body ?? "");
       return;
     }
-    const pathname = request.url?.split("?")[0];
     if (options.auth && request.method === "GET" && isProtectedResourceMetadataPath(pathname, endpoint)) {
       response.writeHead(200, { "content-type": "application/json" });
       response.end(JSON.stringify(options.auth.metadata()));
       return;
     }
+    if (options.auth && request.method === "GET" && pathname === "/.well-known/oauth-authorization-server") {
+      await proxyAuthorizationServerMetadata(options.auth, response);
+      return;
+    }
     if (request.method === "GET" && pathname === endpoint) {
       try {
-        validateProtocolVersion(request);
-        validateGetHeaders(request);
         const fetchRequest = toFetchRequest(request, options.publicUrl ?? options.auth?.resource);
         if (options.auth) {
           const authSession = await authorizeHttpRequest(options.auth, fetchRequest, response);
@@ -3927,6 +3997,8 @@ function createSidecarHttpHandler(options) {
             return;
           }
         }
+        validateProtocolVersion(request);
+        validateGetHeaders(request);
         streamHub.open(response);
       } catch (error) {
         const status = error instanceof JsonRpcHttpError ? error.status : 400;
@@ -3955,6 +4027,11 @@ function createSidecarHttpHandler(options) {
       return;
     }
     try {
+      const fetchRequest = toFetchRequest(request, options.publicUrl ?? options.auth?.resource);
+      const authSession = options.auth ? await authorizeHttpRequest(options.auth, fetchRequest, response) : void 0;
+      if (options.auth && authSession === AUTH_RESPONSE_SENT) {
+        return;
+      }
       validateProtocolVersion(request);
       validatePostHeaders(request);
       const body = await readJson(request, maxBodyBytes);
@@ -3967,11 +4044,6 @@ function createSidecarHttpHandler(options) {
         return;
       }
       const rpcRequest = assertJsonRpcRequest(body);
-      const fetchRequest = toFetchRequest(request, options.publicUrl ?? options.auth?.resource);
-      const authSession = options.auth ? await authorizeHttpRequest(options.auth, fetchRequest, response) : void 0;
-      if (options.auth && authSession === AUTH_RESPONSE_SENT) {
-        return;
-      }
       if (rpcRequest.id !== void 0 && hasProgressToken(rpcRequest)) {
         const stream = createSseStream(response, { supportsRequestProgress: true });
         const payload2 = await mcp.handle(rpcRequest, {
@@ -4063,6 +4135,73 @@ function escapeRegExp(value) {
 function isProtectedResourceMetadataPath(pathname, endpoint) {
   return pathname === "/.well-known/oauth-protected-resource" || pathname === `/.well-known/oauth-protected-resource${endpoint}`;
 }
+function createHttpRequestLog(request, pathname) {
+  return {
+    method: request.method,
+    path: pathname,
+    host: truncateHeader(singleHeader(request.headers.host)),
+    accept: truncateHeader(singleHeader(request.headers.accept)),
+    contentType: truncateHeader(singleHeader(request.headers["content-type"])),
+    contentLength: truncateHeader(singleHeader(request.headers["content-length"])),
+    mcpProtocolVersion: truncateHeader(singleHeader(request.headers["mcp-protocol-version"])),
+    origin: truncateHeader(singleHeader(request.headers.origin)),
+    userAgent: truncateHeader(singleHeader(request.headers["user-agent"])),
+    authorization: request.headers.authorization ? "present" : "absent",
+    cookie: request.headers.cookie ? "present" : "absent"
+  };
+}
+function logHttpRequest(metadata, status) {
+  const debug = process.env.SIDECAR_DEBUG === "1" || process.env.SIDECAR_LOG_LEVEL === "debug";
+  if (!debug && status < 400) {
+    return;
+  }
+  const message = JSON.stringify({
+    event: "sidecar.mcp.http",
+    status,
+    ...stripUndefined4(metadata)
+  });
+  if (status >= 500) {
+    console.error(message);
+  } else if (status >= 400) {
+    console.warn(message);
+  } else {
+    console.info(message);
+  }
+}
+function singleHeader(value) {
+  return Array.isArray(value) ? value.join(", ") : value;
+}
+function truncateHeader(value) {
+  if (!value) {
+    return void 0;
+  }
+  return value.length > 240 ? `${value.slice(0, 237)}...` : value;
+}
+async function proxyAuthorizationServerMetadata(auth, response) {
+  const [authorizationServer] = auth.authorizationServers;
+  if (!authorizationServer) {
+    response.writeHead(404, { "content-type": "application/json" });
+    response.end(JSON.stringify({ error: "authorization_server_not_configured" }));
+    return;
+  }
+  try {
+    const url = new URL("/.well-known/oauth-authorization-server", authorizationServer);
+    const upstream = await fetch(url, { headers: { accept: "application/json" } });
+    const body = await upstream.text();
+    response.writeHead(upstream.ok ? 200 : 502, {
+      "content-type": upstream.headers.get("content-type") ?? "application/json"
+    });
+    response.end(body);
+  } catch (error) {
+    console.warn(JSON.stringify({
+      event: "sidecar.mcp.authorization_metadata_proxy_failed",
+      authorizationServer,
+      message: error instanceof Error ? error.message : "Unknown error"
+    }));
+    response.writeHead(502, { "content-type": "application/json" });
+    response.end(JSON.stringify({ error: "authorization_metadata_unavailable" }));
+  }
+}
 var JsonRpcError = class extends Error {
   constructor(code, message, data) {
     super(message);
@@ -5094,26 +5233,27 @@ async function main(argv) {
   const rootDir = readOption(argv, "--cwd") ?? cwd();
   switch (command) {
     case "build": {
-      const target = readTarget(argv);
-      const host = readHost(argv);
-      const outDir = readOption(argv, "--out") ?? `out/${target}`;
-      const plugins = argv.includes("--plugins");
+      const target = readOptionalTarget(argv);
+      const host = readOptionalHost(argv) ?? detectHostFromEnvironment();
+      const outDir = readOption(argv, "--out");
+      const plugins = readOptionalPlugins(argv);
       const strict = argv.includes("--strict");
       const manifest = await buildProject({ rootDir, host, outDir, plugins, strict, target });
+      const resolvedOutDir = outDir ?? manifest.config.build.outDir ?? defaultBuildOutDir2(manifest.host, manifest.target);
       printDiagnostics(manifest.diagnostics ?? []);
       if (strict && manifest.diagnostics?.length) {
         exit(1);
       }
       console.log(
-        `Built ${manifest.tools.length} ${target} tool${manifest.tools.length === 1 ? "" : "s"}, ${manifest.resources.length} resource${manifest.resources.length === 1 ? "" : "s"}, and ${manifest.prompts.length} prompt${manifest.prompts.length === 1 ? "" : "s"} to ${outDir}.`
+        `Built ${manifest.tools.length} ${manifest.target} tool${manifest.tools.length === 1 ? "" : "s"}, ${manifest.resources.length} resource${manifest.resources.length === 1 ? "" : "s"}, and ${manifest.prompts.length} prompt${manifest.prompts.length === 1 ? "" : "s"} to ${resolvedOutDir}.`
       );
-      console.log(`Host runtime: ${host}`);
-      if (host === "vercel") {
-        console.log(`Vercel MCP function: ${path19.join(outDir, VERCEL_ENTRYPOINT)}`);
+      console.log(`Host runtime: ${manifest.host}`);
+      if (manifest.host === "vercel") {
+        console.log(`Vercel MCP function: ${path19.join(resolvedOutDir, VERCEL_ENTRYPOINT)}`);
       } else {
-        console.log(`Hostable MCP server: ${path19.join(outDir, SERVER_ENTRYPOINT)}`);
+        console.log(`Hostable MCP server: ${path19.join(resolvedOutDir, SERVER_ENTRYPOINT)}`);
       }
-      if (plugins) {
+      if (plugins ?? manifest.config.build.plugins) {
         console.log("Built claude-plugin package.");
       }
       return;
@@ -5243,7 +5383,7 @@ async function main(argv) {
       console.log(`Sidecar
 
 Usage:
-  sidecar build [--cwd <dir>] [--target mcp|chatgpt|claude] [--host node|vercel] [--out <dir>] [--plugins] [--strict]
+  sidecar build [--cwd <dir>] [--target mcp|chatgpt|claude] [--host node|vercel] [--out <dir>] [--plugins|--no-plugins] [--strict]
   sidecar check [--cwd <dir>] [--target mcp|chatgpt|claude] [--strict]
   sidecar dev [--cwd <dir>] [--target mcp|chatgpt|claude] [--port <port>] [--tunnel [cloudflared|wrangler]]
   sidecar inspect [--cwd <dir>] [--target mcp|chatgpt|claude]
@@ -5251,20 +5391,51 @@ Usage:
 `);
   }
 }
+function defaultBuildOutDir2(host, target) {
+  if (host === "vercel") {
+    return ".vercel/output";
+  }
+  return `out/${target}`;
+}
 function readTarget(argv) {
-  const target = readOption(argv, "--target") ?? "mcp";
+  const target = readOptionalTarget(argv) ?? "mcp";
+  return target;
+}
+function readOptionalTarget(argv) {
+  const target = readOption(argv, "--target");
+  if (!target) {
+    return void 0;
+  }
   if (target === "mcp" || target === "chatgpt" || target === "claude") {
     return target;
   }
   throw new Error(`Unsupported Sidecar target "${target}". Expected mcp, chatgpt, or claude.`);
 }
-function readHost(argv) {
-  const host = readOption(argv, "--host") ?? "node";
+function readOptionalHost(argv) {
+  const host = readOption(argv, "--host");
+  if (!host) {
+    return void 0;
+  }
   if (host === "node" || host === "vercel") {
     return host;
   }
   throw new Error(`Unsupported Sidecar host "${host}". Expected node or vercel.`);
 }
+function detectHostFromEnvironment() {
+  if (process.env.VERCEL === "1") {
+    return "vercel";
+  }
+  return void 0;
+}
+function readOptionalPlugins(argv) {
+  if (argv.includes("--plugins")) {
+    return true;
+  }
+  if (argv.includes("--no-plugins")) {
+    return false;
+  }
+  return void 0;
+}
 async function previewComponents(options) {
   const cliDir = path19.dirname(fileURLToPath(import.meta.url));
   const css = await readFile8(path19.join(cliDir, "../../native/src/styles.css"), "utf8").catch(() => readFile8(path19.join(process.cwd(), "packages/native/src/styles.css"), "utf8")).catch(() => "");