@mycadet/credential-executor 0.12.10 → 0.13.0-dev.202610171617.9ea363e

package/node_modules/@mycadet/service-contracts/src/__tests__/ingress.test.ts

@@ -10,7 +10,7 @@ import {
   trimmedNonEmptyString,
   TUNNEL_PROVIDERS,
   type TunnelRecord,
-  tunnelHostForPlatformHost,
+  tunnelHostForCloudHost,
 } from "../ingress.js";
 import {
   buildTwilioMediaStreamUrl,
@@ -19,27 +19,27 @@ import {
   resolveTwilioPublicBaseUrl,
 } from "../twilio-ingress.js";
 
-describe("tunnelHostForPlatformHost", () => {
+describe("tunnelHostForCloudHost", () => {
   test("maps the prod platform host to the prod tunnel", () => {
-    expect(tunnelHostForPlatformHost("cloud.mycadet.ai")).toBe(
+    expect(tunnelHostForCloudHost("cloud.mycadet.ai")).toBe(
       "tunnel.mycadet.ai",
     );
   });
 
   test("maps env-prefixed platform hosts to their env tunnel", () => {
-    expect(tunnelHostForPlatformHost("staging-cloud.mycadet.ai")).toBe(
-      "tunnel-staging.mycadet.ai",
+    expect(tunnelHostForCloudHost("staging-cloud.mycadet.ai")).toBe(
+      "staging-tunnel.mycadet.ai",
     );
-    expect(tunnelHostForPlatformHost("dev-cloud.mycadet.ai")).toBe(
-      "tunnel-dev.mycadet.ai",
+    expect(tunnelHostForCloudHost("dev-cloud.mycadet.ai")).toBe(
+      "dev-tunnel.mycadet.ai",
     );
   });
 
   test("returns null for hosts outside the deployment convention", () => {
-    expect(tunnelHostForPlatformHost("localhost")).toBeNull();
-    expect(tunnelHostForPlatformHost("platform.example.com")).toBeNull();
+    expect(tunnelHostForCloudHost("localhost")).toBeNull();
+    expect(tunnelHostForCloudHost("platform.example.com")).toBeNull();
     expect(
-      tunnelHostForPlatformHost("staging-cloud.mycadet.ai.evil.com"),
+      tunnelHostForCloudHost("staging-cloud.mycadet.ai.evil.com"),
     ).toBeNull();
   });
 });

package/node_modules/@mycadet/service-contracts/src/channels.ts

@@ -39,7 +39,6 @@ export const CHANNEL_IDS = [
   "slack",
   "email",
   "platform",
-  "a2a",
   "discord",
   "plugin",
   // Internal id for conversations a guardian shares with a contact. It has no

package/node_modules/@mycadet/service-contracts/src/ingress.ts

@@ -1,17 +1,17 @@
 /**
  * Map a Cadet Cloud host onto its environment's tunnel host, following the
  * deployment naming convention (`cloud.mycadet.ai` → `tunnel.mycadet.ai`,
- * `{env}-cloud.mycadet.ai` → `tunnel-{env}.mycadet.ai`). Returns null for
+ * `{env}-cloud.mycadet.ai` → `{env}-tunnel.mycadet.ai`). Returns null for
  * hosts outside that convention (localhost, custom domains). Shared by the
  * gateway speech relay and the web live-voice client so the two ends of the
  * cloud-speech transport can't drift.
  */
-export function tunnelHostForPlatformHost(host: string): string | null {
+export function tunnelHostForCloudHost(host: string): string | null {
   if (host === "cloud.mycadet.ai") {
     return "tunnel.mycadet.ai";
   }
   const match = /^([a-z0-9-]+)-cloud\.mycadet\.ai$/.exec(host);
-  return match ? `tunnel-${match[1]}.mycadet.ai` : null;
+  return match ? `${match[1]}-tunnel.mycadet.ai` : null;
 }
 
 export function normalizePublicBaseUrl(value: unknown): string | undefined {

package/package.json

@@ -1,6 +1,10 @@
 {
   "name": "@mycadet/credential-executor",
-  "version": "0.12.10",
+  "version": "0.13.0-dev.202610171617.9ea363e",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vargasjr-dev/mycadet-temp.git"
+  },
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/http/request-errors.test.ts

@@ -0,0 +1,29 @@
+import { expect, test } from "bun:test";
+import { withCesHttpErrorLogging } from "./request-errors.js";
+
+test("CES HTTP failures log the exception and return a safe correlation id", async () => {
+  const captured: Array<Record<string, unknown>> = [];
+  const failure = new Error("backend unavailable");
+  const response = await withCesHttpErrorLogging(
+    new Request("http://127.0.0.1:8090/v1/credentials", {
+      headers: { Authorization: "Bearer fixture-secret" },
+    }),
+    async () => {
+      throw failure;
+    },
+    {
+      error: (context) => {
+        captured.push(context);
+      },
+    },
+  );
+  const body = await response.json();
+  expect(response.status).toBe(500);
+  expect(body.error).toBe("Internal server error");
+  expect(body.request_id).toBe(response.headers.get("x-ces-error-id"));
+  expect(captured[0]?.err).toBe(failure);
+  expect(captured[0]?.method).toBe("GET");
+  expect(captured[0]?.path).toBe("/v1/credentials");
+  expect(JSON.stringify(body)).not.toContain("fixture-secret");
+  expect(JSON.stringify(captured)).not.toContain("fixture-secret");
+});

package/src/http/request-errors.ts

@@ -0,0 +1,34 @@
+import { randomUUID } from "node:crypto";
+
+type RequestLogger = {
+  error(context: Record<string, unknown>, message: string): void;
+};
+
+/** Keep exception diagnostics in CES logs and expose only a correlation id. */
+export async function withCesHttpErrorLogging(
+  request: Request,
+  handle: () => Promise<Response>,
+  logger: RequestLogger,
+): Promise<Response> {
+  try {
+    return await handle();
+  } catch (err) {
+    const requestId = randomUUID();
+    logger.error(
+      {
+        err,
+        requestId,
+        method: request.method,
+        path: new URL(request.url).pathname,
+      },
+      "CES HTTP request failed",
+    );
+    return Response.json(
+      { error: "Internal server error", request_id: requestId },
+      {
+        status: 500,
+        headers: { "x-ces-error-id": requestId },
+      },
+    );
+  }
+}

package/src/main.ts

@@ -51,6 +51,7 @@ import {
 } from "./http/credential-routes.js";
 import { handleLogExportRoute } from "./http/log-export-routes.js";
 import { isLoopbackAddress } from "./http/loopback-address.js";
+import { withCesHttpErrorLogging } from "./http/request-errors.js";
 import { handleMetadataRoute } from "./http/metadata-routes.js";
 import { CES_MIGRATIONS } from "./migrations/registry.js";
 import { runCesMigrations } from "./migrations/runner.js";
@@ -283,29 +284,35 @@ function startHealthServer(
         return new Response("Not Found", { status: 404 });
       }
 
-      // Credential CRUD routes (only if service token is configured)
-      if (credentialDeps) {
-        const metadataResponse = await handleMetadataRoute(req);
-        if (metadataResponse) {
-          return metadataResponse;
-        }
-        const credentialResponse = await handleCredentialRoute(
-          req,
-          credentialDeps,
-        );
-        if (credentialResponse) {
-          return credentialResponse;
-        }
-      }
-
-      // Log export route
-      const logExportResponse = await handleLogExportRoute(
+      return withCesHttpErrorLogging(
         req,
-        getCesLogDir("managed"),
-      );
-      if (logExportResponse) return logExportResponse;
+        async () => {
+          // Credential CRUD routes (only if service token is configured)
+          if (credentialDeps) {
+            const metadataResponse = await handleMetadataRoute(req);
+            if (metadataResponse) {
+              return metadataResponse;
+            }
+            const credentialResponse = await handleCredentialRoute(
+              req,
+              credentialDeps,
+            );
+            if (credentialResponse) {
+              return credentialResponse;
+            }
+          }
 
-      return new Response("Not Found", { status: 404 });
+          // Log export route
+          const logExportResponse = await handleLogExportRoute(
+            req,
+            getCesLogDir("managed"),
+          );
+          if (logExportResponse) return logExportResponse;
+
+          return new Response("Not Found", { status: 404 });
+        },
+        log,
+      );
     },
   });