@jdi-code/claude-code 1.0.3

package/dist/chunk-a9vdeb6y.js

@@ -0,0 +1,258 @@
+// @bun
+import {
+  require_dist_cjs2 as require_dist_cjs
+} from "./chunk-2nayx6q1.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@smithy+core@3.23.13/node_modules/@smithy/core/dist-cjs/submodules/event-streams/index.js
+class EventStreamSerde {
+  marshaller;
+  serializer;
+  deserializer;
+  serdeContext;
+  defaultContentType;
+  constructor({ marshaller, serializer, deserializer, serdeContext, defaultContentType }) {
+    this.marshaller = marshaller;
+    this.serializer = serializer;
+    this.deserializer = deserializer;
+    this.serdeContext = serdeContext;
+    this.defaultContentType = defaultContentType;
+  }
+  async serializeEventStream({ eventStream, requestSchema, initialRequest }) {
+    const marshaller = this.marshaller;
+    const eventStreamMember = requestSchema.getEventStreamMember();
+    const unionSchema = requestSchema.getMemberSchema(eventStreamMember);
+    const serializer = this.serializer;
+    const defaultContentType = this.defaultContentType;
+    const initialRequestMarker = Symbol("initialRequestMarker");
+    const eventStreamIterable = {
+      async* [Symbol.asyncIterator]() {
+        if (initialRequest) {
+          const headers = {
+            ":event-type": { type: "string", value: "initial-request" },
+            ":message-type": { type: "string", value: "event" },
+            ":content-type": { type: "string", value: defaultContentType }
+          };
+          serializer.write(requestSchema, initialRequest);
+          const body = serializer.flush();
+          yield {
+            [initialRequestMarker]: true,
+            headers,
+            body
+          };
+        }
+        for await (const page of eventStream) {
+          yield page;
+        }
+      }
+    };
+    return marshaller.serialize(eventStreamIterable, (event) => {
+      if (event[initialRequestMarker]) {
+        return {
+          headers: event.headers,
+          body: event.body
+        };
+      }
+      const unionMember = Object.keys(event).find((key) => {
+        return key !== "__type";
+      }) ?? "";
+      const { additionalHeaders, body, eventType, explicitPayloadContentType } = this.writeEventBody(unionMember, unionSchema, event);
+      const headers = {
+        ":event-type": { type: "string", value: eventType },
+        ":message-type": { type: "string", value: "event" },
+        ":content-type": { type: "string", value: explicitPayloadContentType ?? defaultContentType },
+        ...additionalHeaders
+      };
+      return {
+        headers,
+        body
+      };
+    });
+  }
+  async deserializeEventStream({ response, responseSchema, initialResponseContainer }) {
+    const marshaller = this.marshaller;
+    const eventStreamMember = responseSchema.getEventStreamMember();
+    const unionSchema = responseSchema.getMemberSchema(eventStreamMember);
+    const memberSchemas = unionSchema.getMemberSchemas();
+    const initialResponseMarker = Symbol("initialResponseMarker");
+    const asyncIterable = marshaller.deserialize(response.body, async (event) => {
+      const unionMember = Object.keys(event).find((key) => {
+        return key !== "__type";
+      }) ?? "";
+      const body = event[unionMember].body;
+      if (unionMember === "initial-response") {
+        const dataObject = await this.deserializer.read(responseSchema, body);
+        delete dataObject[eventStreamMember];
+        return {
+          [initialResponseMarker]: true,
+          ...dataObject
+        };
+      } else if (unionMember in memberSchemas) {
+        const eventStreamSchema = memberSchemas[unionMember];
+        if (eventStreamSchema.isStructSchema()) {
+          const out = {};
+          let hasBindings = false;
+          for (const [name, member] of eventStreamSchema.structIterator()) {
+            const { eventHeader, eventPayload } = member.getMergedTraits();
+            hasBindings = hasBindings || Boolean(eventHeader || eventPayload);
+            if (eventPayload) {
+              if (member.isBlobSchema()) {
+                out[name] = body;
+              } else if (member.isStringSchema()) {
+                out[name] = (this.serdeContext?.utf8Encoder ?? utilUtf8.toUtf8)(body);
+              } else if (member.isStructSchema()) {
+                out[name] = await this.deserializer.read(member, body);
+              }
+            } else if (eventHeader) {
+              const value = event[unionMember].headers[name]?.value;
+              if (value != null) {
+                if (member.isNumericSchema()) {
+                  if (value && typeof value === "object" && "bytes" in value) {
+                    out[name] = BigInt(value.toString());
+                  } else {
+                    out[name] = Number(value);
+                  }
+                } else {
+                  out[name] = value;
+                }
+              }
+            }
+          }
+          if (hasBindings) {
+            return {
+              [unionMember]: out
+            };
+          }
+          if (body.byteLength === 0) {
+            return {
+              [unionMember]: {}
+            };
+          }
+        }
+        return {
+          [unionMember]: await this.deserializer.read(eventStreamSchema, body)
+        };
+      } else {
+        return {
+          $unknown: event
+        };
+      }
+    });
+    const asyncIterator = asyncIterable[Symbol.asyncIterator]();
+    const firstEvent = await asyncIterator.next();
+    if (firstEvent.done) {
+      return asyncIterable;
+    }
+    if (firstEvent.value?.[initialResponseMarker]) {
+      if (!responseSchema) {
+        throw new Error("@smithy::core/protocols - initial-response event encountered in event stream but no response schema given.");
+      }
+      for (const [key, value] of Object.entries(firstEvent.value)) {
+        initialResponseContainer[key] = value;
+      }
+    }
+    return {
+      async* [Symbol.asyncIterator]() {
+        if (!firstEvent?.value?.[initialResponseMarker]) {
+          yield firstEvent.value;
+        }
+        while (true) {
+          const { done, value } = await asyncIterator.next();
+          if (done) {
+            break;
+          }
+          yield value;
+        }
+      }
+    };
+  }
+  writeEventBody(unionMember, unionSchema, event) {
+    const serializer = this.serializer;
+    let eventType = unionMember;
+    let explicitPayloadMember = null;
+    let explicitPayloadContentType;
+    const isKnownSchema = (() => {
+      const struct = unionSchema.getSchema();
+      return struct[4].includes(unionMember);
+    })();
+    const additionalHeaders = {};
+    if (!isKnownSchema) {
+      const [type, value] = event[unionMember];
+      eventType = type;
+      serializer.write(15, value);
+    } else {
+      const eventSchema = unionSchema.getMemberSchema(unionMember);
+      if (eventSchema.isStructSchema()) {
+        for (const [memberName, memberSchema] of eventSchema.structIterator()) {
+          const { eventHeader, eventPayload } = memberSchema.getMergedTraits();
+          if (eventPayload) {
+            explicitPayloadMember = memberName;
+          } else if (eventHeader) {
+            const value = event[unionMember][memberName];
+            let type = "binary";
+            if (memberSchema.isNumericSchema()) {
+              if ((-2) ** 31 <= value && value <= 2 ** 31 - 1) {
+                type = "integer";
+              } else {
+                type = "long";
+              }
+            } else if (memberSchema.isTimestampSchema()) {
+              type = "timestamp";
+            } else if (memberSchema.isStringSchema()) {
+              type = "string";
+            } else if (memberSchema.isBooleanSchema()) {
+              type = "boolean";
+            }
+            if (value != null) {
+              additionalHeaders[memberName] = {
+                type,
+                value
+              };
+              delete event[unionMember][memberName];
+            }
+          }
+        }
+        if (explicitPayloadMember !== null) {
+          const payloadSchema = eventSchema.getMemberSchema(explicitPayloadMember);
+          if (payloadSchema.isBlobSchema()) {
+            explicitPayloadContentType = "application/octet-stream";
+          } else if (payloadSchema.isStringSchema()) {
+            explicitPayloadContentType = "text/plain";
+          }
+          serializer.write(payloadSchema, event[unionMember][explicitPayloadMember]);
+        } else {
+          serializer.write(eventSchema, event[unionMember]);
+        }
+      } else if (eventSchema.isUnitSchema()) {
+        serializer.write(eventSchema, {});
+      } else {
+        throw new Error("@smithy/core/event-streams - non-struct member not supported in event stream union.");
+      }
+    }
+    const messageSerialization = serializer.flush() ?? new Uint8Array;
+    const body = typeof messageSerialization === "string" ? (this.serdeContext?.utf8Decoder ?? utilUtf8.fromUtf8)(messageSerialization) : messageSerialization;
+    return {
+      body,
+      eventType,
+      explicitPayloadContentType,
+      additionalHeaders
+    };
+  }
+}
+var utilUtf8, $EventStreamSerde;
+var init_event_streams = __esm(() => {
+  utilUtf8 = require_dist_cjs();
+  $EventStreamSerde = EventStreamSerde;
+});
+init_event_streams();
+
+export {
+  $EventStreamSerde as EventStreamSerde
+};
+export default {
+  get EventStreamSerde() {
+    return $EventStreamSerde;
+  }
+};

package/dist/chunk-a9zh40sj.js

@@ -0,0 +1,48 @@
+// @bun
+import {
+  require_index_node_http,
+  require_src,
+  require_src1 as require_src2
+} from "./chunk-90wp6wez.js";
+import"./chunk-a8ejc632.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-p2816w9z.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@opentelemetry+exporter-logs-otlp-proto@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-logs-otlp-proto/build/esm/platform/node/OTLPLogExporter.js
+var import_otlp_exporter_base, import_otlp_transformer, import_node_http, OTLPLogExporter;
+var init_OTLPLogExporter = __esm(() => {
+  import_otlp_exporter_base = __toESM(require_src(), 1);
+  import_otlp_transformer = __toESM(require_src2(), 1);
+  import_node_http = __toESM(require_index_node_http(), 1);
+  OTLPLogExporter = class OTLPLogExporter extends import_otlp_exporter_base.OTLPExporterBase {
+    constructor(config = {}) {
+      super(import_node_http.createOtlpHttpExportDelegate(import_node_http.convertLegacyHttpOptions(config, "LOGS", "v1/logs", {
+        "Content-Type": "application/x-protobuf"
+      }), import_otlp_transformer.ProtobufLogsSerializer));
+    }
+  };
+});
+
+// node_modules/.bun/@opentelemetry+exporter-logs-otlp-proto@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-logs-otlp-proto/build/esm/platform/node/index.js
+var init_node = __esm(() => {
+  init_OTLPLogExporter();
+});
+
+// node_modules/.bun/@opentelemetry+exporter-logs-otlp-proto@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-logs-otlp-proto/build/esm/platform/index.js
+var init_platform = __esm(() => {
+  init_node();
+});
+
+// node_modules/.bun/@opentelemetry+exporter-logs-otlp-proto@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-logs-otlp-proto/build/esm/index.js
+var init_esm = __esm(() => {
+  init_platform();
+});
+init_esm();
+
+export {
+  OTLPLogExporter
+};

package/dist/chunk-ae76ded0.js

@@ -0,0 +1,30 @@
+// @bun
+// src/bridge/capacityWake.ts
+function createCapacityWake(outerSignal) {
+  let wakeController = new AbortController;
+  function wake() {
+    wakeController.abort();
+    wakeController = new AbortController;
+  }
+  function signal() {
+    const merged = new AbortController;
+    const abort = () => merged.abort();
+    if (outerSignal.aborted || wakeController.signal.aborted) {
+      merged.abort();
+      return { signal: merged.signal, cleanup: () => {} };
+    }
+    outerSignal.addEventListener("abort", abort, { once: true });
+    const capSig = wakeController.signal;
+    capSig.addEventListener("abort", abort, { once: true });
+    return {
+      signal: merged.signal,
+      cleanup: () => {
+        outerSignal.removeEventListener("abort", abort);
+        capSig.removeEventListener("abort", abort);
+      }
+    };
+  }
+  return { signal, wake };
+}
+
+export { createCapacityWake };

package/dist/chunk-amhzxqj4.js

@@ -0,0 +1,22 @@
+// @bun
+import {
+  require_sts
+} from "./chunk-meefz2g4.js";
+import"./chunk-h0qngp9w.js";
+import"./chunk-p452k1xp.js";
+import"./chunk-n7ttdtk0.js";
+import"./chunk-wzpdet3m.js";
+import"./chunk-p2d5nh3g.js";
+import"./chunk-jzmz18nn.js";
+import"./chunk-n0qaeaa5.js";
+import"./chunk-2k995y2x.js";
+import"./chunk-wfz0qffj.js";
+import"./chunk-b4wg70y1.js";
+import"./chunk-nka1g8f4.js";
+import"./chunk-30rst83v.js";
+import"./chunk-j2k4p94p.js";
+import"./chunk-hk9xz7gk.js";
+import"./chunk-xsq9ae7x.js";
+import"./chunk-2nayx6q1.js";
+import"./chunk-qp2qdcda.js";
+export default require_sts();

package/dist/chunk-ax83mpvw.js

@@ -0,0 +1,250 @@
+// @bun
+import {
+  extractErrorDetail,
+  init_debugUtils,
+  init_sessionIdCompat,
+  toCompatSessionId
+} from "./chunk-9e2kqv5g.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  logForDebugging
+} from "./chunk-nxsh6de2.js";
+import {
+  __esm,
+  __require
+} from "./chunk-qp2qdcda.js";
+
+// src/bridge/createSession.ts
+async function createBridgeSession({
+  environmentId,
+  title,
+  events,
+  gitRepoUrl,
+  branch,
+  signal,
+  baseUrl: baseUrlOverride,
+  getAccessToken,
+  permissionMode
+}) {
+  const { getClaudeAIOAuthTokens } = await import("./chunk-9wm5e9e9.js");
+  const { getOrganizationUUID } = await import("./chunk-tf40vqky.js");
+  const { getOauthConfig } = await import("./chunk-jafes477.js");
+  const { getOAuthHeaders } = await import("./chunk-0gemty6d.js");
+  const { parseGitHubRepository } = await import("./chunk-q6av622g.js");
+  const { getDefaultBranch } = await import("./chunk-3gqdqmzb.js");
+  const { getMainLoopModel } = await import("./chunk-67kbbt9h.js");
+  const { default: axios } = await import("./chunk-8hq5kk3y.js");
+  const accessToken = getAccessToken?.() ?? getClaudeAIOAuthTokens()?.accessToken;
+  if (!accessToken) {
+    logForDebugging("[bridge] No access token for session creation");
+    return null;
+  }
+  const orgUUID = await getOrganizationUUID();
+  if (!orgUUID) {
+    logForDebugging("[bridge] No org UUID for session creation");
+    return null;
+  }
+  let gitSource = null;
+  let gitOutcome = null;
+  if (gitRepoUrl) {
+    const { parseGitRemote } = await import("./chunk-q6av622g.js");
+    const parsed = parseGitRemote(gitRepoUrl);
+    if (parsed) {
+      const { host, owner, name } = parsed;
+      const revision = branch || await getDefaultBranch() || undefined;
+      gitSource = {
+        type: "git_repository",
+        url: `https://${host}/${owner}/${name}`,
+        revision
+      };
+      gitOutcome = {
+        type: "git_repository",
+        git_info: {
+          type: "github",
+          repo: `${owner}/${name}`,
+          branches: [`claude/${branch || "task"}`]
+        }
+      };
+    } else {
+      const ownerRepo = parseGitHubRepository(gitRepoUrl);
+      if (ownerRepo) {
+        const [owner, name] = ownerRepo.split("/");
+        if (owner && name) {
+          const revision = branch || await getDefaultBranch() || undefined;
+          gitSource = {
+            type: "git_repository",
+            url: `https://github.com/${owner}/${name}`,
+            revision
+          };
+          gitOutcome = {
+            type: "git_repository",
+            git_info: {
+              type: "github",
+              repo: `${owner}/${name}`,
+              branches: [`claude/${branch || "task"}`]
+            }
+          };
+        }
+      }
+    }
+  }
+  const requestBody = {
+    ...title !== undefined && { title },
+    events,
+    session_context: {
+      sources: gitSource ? [gitSource] : [],
+      outcomes: gitOutcome ? [gitOutcome] : [],
+      model: getMainLoopModel()
+    },
+    environment_id: environmentId,
+    source: "remote-control",
+    ...permissionMode && { permission_mode: permissionMode }
+  };
+  const headers = {
+    ...getOAuthHeaders(accessToken),
+    "anthropic-beta": "ccr-byoc-2025-07-29",
+    "x-organization-uuid": orgUUID
+  };
+  const url = `${baseUrlOverride ?? getOauthConfig().BASE_API_URL}/v1/sessions`;
+  let response;
+  try {
+    response = await axios.post(url, requestBody, {
+      headers,
+      signal,
+      validateStatus: (s) => s < 500
+    });
+  } catch (err) {
+    logForDebugging(`[bridge] Session creation request failed: ${errorMessage(err)}`);
+    return null;
+  }
+  const isSuccess = response.status === 200 || response.status === 201;
+  if (!isSuccess) {
+    const detail = extractErrorDetail(response.data);
+    logForDebugging(`[bridge] Session creation failed with status ${response.status}${detail ? `: ${detail}` : ""}`);
+    return null;
+  }
+  const sessionData = response.data;
+  if (!sessionData || typeof sessionData !== "object" || !("id" in sessionData) || typeof sessionData.id !== "string") {
+    logForDebugging("[bridge] No session ID in response");
+    return null;
+  }
+  return sessionData.id;
+}
+async function getBridgeSession(sessionId, opts) {
+  const { getClaudeAIOAuthTokens } = await import("./chunk-9wm5e9e9.js");
+  const { getOrganizationUUID } = await import("./chunk-tf40vqky.js");
+  const { getOauthConfig } = await import("./chunk-jafes477.js");
+  const { getOAuthHeaders } = await import("./chunk-0gemty6d.js");
+  const { default: axios } = await import("./chunk-8hq5kk3y.js");
+  const accessToken = opts?.getAccessToken?.() ?? getClaudeAIOAuthTokens()?.accessToken;
+  if (!accessToken) {
+    logForDebugging("[bridge] No access token for session fetch");
+    return null;
+  }
+  const orgUUID = await getOrganizationUUID();
+  if (!orgUUID) {
+    logForDebugging("[bridge] No org UUID for session fetch");
+    return null;
+  }
+  const headers = {
+    ...getOAuthHeaders(accessToken),
+    "anthropic-beta": "ccr-byoc-2025-07-29",
+    "x-organization-uuid": orgUUID
+  };
+  const url = `${opts?.baseUrl ?? getOauthConfig().BASE_API_URL}/v1/sessions/${sessionId}`;
+  logForDebugging(`[bridge] Fetching session ${sessionId}`);
+  let response;
+  try {
+    response = await axios.get(url, { headers, timeout: 1e4, validateStatus: (s) => s < 500 });
+  } catch (err) {
+    logForDebugging(`[bridge] Session fetch request failed: ${errorMessage(err)}`);
+    return null;
+  }
+  if (response.status !== 200) {
+    const detail = extractErrorDetail(response.data);
+    logForDebugging(`[bridge] Session fetch failed with status ${response.status}${detail ? `: ${detail}` : ""}`);
+    return null;
+  }
+  return response.data;
+}
+async function archiveBridgeSession(sessionId, opts) {
+  const { getClaudeAIOAuthTokens } = await import("./chunk-9wm5e9e9.js");
+  const { getOrganizationUUID } = await import("./chunk-tf40vqky.js");
+  const { getOauthConfig } = await import("./chunk-jafes477.js");
+  const { getOAuthHeaders } = await import("./chunk-0gemty6d.js");
+  const { default: axios } = await import("./chunk-8hq5kk3y.js");
+  const accessToken = opts?.getAccessToken?.() ?? getClaudeAIOAuthTokens()?.accessToken;
+  if (!accessToken) {
+    logForDebugging("[bridge] No access token for session archive");
+    return;
+  }
+  const orgUUID = await getOrganizationUUID();
+  if (!orgUUID) {
+    logForDebugging("[bridge] No org UUID for session archive");
+    return;
+  }
+  const headers = {
+    ...getOAuthHeaders(accessToken),
+    "anthropic-beta": "ccr-byoc-2025-07-29",
+    "x-organization-uuid": orgUUID
+  };
+  const url = `${opts?.baseUrl ?? getOauthConfig().BASE_API_URL}/v1/sessions/${sessionId}/archive`;
+  logForDebugging(`[bridge] Archiving session ${sessionId}`);
+  const response = await axios.post(url, {}, {
+    headers,
+    timeout: opts?.timeoutMs ?? 1e4,
+    validateStatus: (s) => s < 500
+  });
+  if (response.status === 200) {
+    logForDebugging(`[bridge] Session ${sessionId} archived successfully`);
+  } else {
+    const detail = extractErrorDetail(response.data);
+    logForDebugging(`[bridge] Session archive failed with status ${response.status}${detail ? `: ${detail}` : ""}`);
+  }
+}
+async function updateBridgeSessionTitle(sessionId, title, opts) {
+  const { getClaudeAIOAuthTokens } = await import("./chunk-9wm5e9e9.js");
+  const { getOrganizationUUID } = await import("./chunk-tf40vqky.js");
+  const { getOauthConfig } = await import("./chunk-jafes477.js");
+  const { getOAuthHeaders } = await import("./chunk-0gemty6d.js");
+  const { default: axios } = await import("./chunk-8hq5kk3y.js");
+  const accessToken = opts?.getAccessToken?.() ?? getClaudeAIOAuthTokens()?.accessToken;
+  if (!accessToken) {
+    logForDebugging("[bridge] No access token for session title update");
+    return;
+  }
+  const orgUUID = await getOrganizationUUID();
+  if (!orgUUID) {
+    logForDebugging("[bridge] No org UUID for session title update");
+    return;
+  }
+  const headers = {
+    ...getOAuthHeaders(accessToken),
+    "anthropic-beta": "ccr-byoc-2025-07-29",
+    "x-organization-uuid": orgUUID
+  };
+  const compatId = toCompatSessionId(sessionId);
+  const url = `${opts?.baseUrl ?? getOauthConfig().BASE_API_URL}/v1/sessions/${compatId}`;
+  logForDebugging(`[bridge] Updating session title: ${compatId} \u2192 ${title}`);
+  try {
+    const response = await axios.patch(url, { title }, { headers, timeout: 1e4, validateStatus: (s) => s < 500 });
+    if (response.status === 200) {
+      logForDebugging(`[bridge] Session title updated successfully`);
+    } else {
+      const detail = extractErrorDetail(response.data);
+      logForDebugging(`[bridge] Session title update failed with status ${response.status}${detail ? `: ${detail}` : ""}`);
+    }
+  } catch (err) {
+    logForDebugging(`[bridge] Session title update request failed: ${errorMessage(err)}`);
+  }
+}
+var init_createSession = __esm(() => {
+  init_debug();
+  init_errors();
+  init_debugUtils();
+  init_sessionIdCompat();
+});
+
+export { createBridgeSession, getBridgeSession, archiveBridgeSession, updateBridgeSessionTitle, init_createSession };