cngkit 1.1.2 → 1.1.4

package/dist/chunk-HBBUFPJG.js

@@ -0,0 +1,4585 @@
+import {
+  createPeerId,
+  createRoomCode,
+  resolveApiBaseUrl
+} from "./chunk-XWVFKUUD.js";
+import {
+  formatCngkitHelp
+} from "./chunk-SSRUN6G5.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/command-actions.ts
+import process4 from "process";
+
+// ../../packages/client/src/generated/core/json.ts
+var toJson = (value, replacer, space) => {
+  return JSON.stringify(value, replacer, space);
+};
+function fromJson(text, reviver) {
+  return JSON.parse(text, reviver);
+}
+
+// ../../packages/client/src/generated/errors/CngApiError.ts
+var CngApiError = class extends Error {
+  statusCode;
+  body;
+  rawResponse;
+  cause;
+  constructor({
+    message,
+    statusCode,
+    body,
+    rawResponse,
+    cause
+  }) {
+    super(buildMessage({ message, statusCode, body }));
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.name = "CngApiError";
+    this.statusCode = statusCode;
+    this.body = body;
+    this.rawResponse = rawResponse;
+    if (cause != null) {
+      this.cause = cause;
+    }
+  }
+};
+function buildMessage({
+  message,
+  statusCode,
+  body
+}) {
+  const lines = [];
+  if (message != null) {
+    lines.push(message);
+  }
+  if (statusCode != null) {
+    lines.push(`Status code: ${statusCode.toString()}`);
+  }
+  if (body != null) {
+    lines.push(`Body: ${toJson(body, void 0, 2)}`);
+  }
+  return lines.join("\n");
+}
+
+// ../../packages/client/src/generated/errors/CngApiTimeoutError.ts
+var CngApiTimeoutError = class extends Error {
+  cause;
+  constructor(message, opts) {
+    super(message);
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.name = "CngApiTimeoutError";
+    if (opts?.cause != null) {
+      this.cause = opts.cause;
+    }
+  }
+};
+
+// ../../packages/client/src/generated/api/errors/BadGatewayError.ts
+var BadGatewayError = class extends CngApiError {
+  constructor(body, rawResponse) {
+    super({
+      message: "BadGatewayError",
+      statusCode: 502,
+      body,
+      rawResponse
+    });
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.name = "BadGatewayError";
+  }
+};
+
+// ../../packages/client/src/generated/api/errors/BadRequestError.ts
+var BadRequestError = class extends CngApiError {
+  constructor(body, rawResponse) {
+    super({
+      message: "BadRequestError",
+      statusCode: 400,
+      body,
+      rawResponse
+    });
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.name = "BadRequestError";
+  }
+};
+
+// ../../packages/client/src/generated/api/errors/ConflictError.ts
+var ConflictError = class extends CngApiError {
+  constructor(body, rawResponse) {
+    super({
+      message: "ConflictError",
+      statusCode: 409,
+      body,
+      rawResponse
+    });
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.name = "ConflictError";
+  }
+};
+
+// ../../packages/client/src/generated/api/errors/ContentTooLargeError.ts
+var ContentTooLargeError = class extends CngApiError {
+  constructor(body, rawResponse) {
+    super({
+      message: "ContentTooLargeError",
+      statusCode: 413,
+      body,
+      rawResponse
+    });
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.name = "ContentTooLargeError";
+  }
+};
+
+// ../../packages/client/src/generated/api/errors/InternalServerError.ts
+var InternalServerError = class extends CngApiError {
+  constructor(body, rawResponse) {
+    super({
+      message: "InternalServerError",
+      statusCode: 500,
+      body,
+      rawResponse
+    });
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.name = "InternalServerError";
+  }
+};
+
+// ../../packages/client/src/generated/api/errors/NotFoundError.ts
+var NotFoundError = class extends CngApiError {
+  constructor(body, rawResponse) {
+    super({
+      message: "NotFoundError",
+      statusCode: 404,
+      body,
+      rawResponse
+    });
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.name = "NotFoundError";
+  }
+};
+
+// ../../packages/client/src/generated/api/errors/ServiceUnavailableError.ts
+var ServiceUnavailableError = class extends CngApiError {
+  constructor(body, rawResponse) {
+    super({
+      message: "ServiceUnavailableError",
+      statusCode: 503,
+      body,
+      rawResponse
+    });
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.name = "ServiceUnavailableError";
+  }
+};
+
+// ../../packages/client/src/generated/api/errors/UnauthorizedError.ts
+var UnauthorizedError = class extends CngApiError {
+  constructor(body, rawResponse) {
+    super({
+      message: "UnauthorizedError",
+      statusCode: 401,
+      body,
+      rawResponse
+    });
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.name = "UnauthorizedError";
+  }
+};
+
+// ../../packages/client/src/generated/api/resources/llm/client/requests/CreateLlmChatRequest.ts
+var CreateLlmChatRequest;
+((CreateLlmChatRequest2) => {
+  let Messages;
+  ((Messages2) => {
+    let Item;
+    ((Item2) => {
+      Item2.Role = {
+        System: "system",
+        User: "user",
+        Assistant: "assistant"
+      };
+      let Parts;
+      ((Parts2) => {
+        let Item3;
+        ((Item4) => {
+          Item4.Type = {
+            Text: "text"
+          };
+          Item4.State = {
+            Streaming: "streaming",
+            Done: "done"
+          };
+        })(Item3 = Parts2.Item || (Parts2.Item = {}));
+      })(Parts = Item2.Parts || (Item2.Parts = {}));
+    })(Item = Messages2.Item || (Messages2.Item = {}));
+  })(Messages = CreateLlmChatRequest2.Messages || (CreateLlmChatRequest2.Messages = {}));
+})(CreateLlmChatRequest || (CreateLlmChatRequest = {}));
+
+// ../../packages/client/src/generated/api/resources/llm/types/GetLlmHealthResponse.ts
+var GetLlmHealthResponse;
+((GetLlmHealthResponse2) => {
+  GetLlmHealthResponse2.Service = {
+    CurlyNgBackend: "curly-ng-backend"
+  };
+  GetLlmHealthResponse2.Model = {
+    CfGoogleGemma426Ba4BIt: "@cf/google/gemma-4-26b-a4b-it"
+  };
+})(GetLlmHealthResponse || (GetLlmHealthResponse = {}));
+
+// ../../packages/client/src/generated/api/resources/system/types/GetHealthResponse.ts
+var GetHealthResponse;
+((GetHealthResponse2) => {
+  GetHealthResponse2.Service = {
+    CurlyNgBackend: "curly-ng-backend"
+  };
+})(GetHealthResponse || (GetHealthResponse = {}));
+
+// ../../packages/client/src/generated/api/resources/telemetry/client/requests/NavigationEventRequest.ts
+var NavigationEventRequest;
+((NavigationEventRequest2) => {
+  NavigationEventRequest2.EventType = {
+    PageView: "page_view",
+    Interaction: "interaction"
+  };
+  NavigationEventRequest2.InteractionType = {
+    Click: "click",
+    Submit: "submit"
+  };
+})(NavigationEventRequest || (NavigationEventRequest = {}));
+
+// ../../packages/client/src/generated/api/types/HarnessCatalogSummary.ts
+var HarnessCatalogSummary;
+((HarnessCatalogSummary2) => {
+  HarnessCatalogSummary2.Name = {
+    CurlyHarness: "curly-harness"
+  };
+})(HarnessCatalogSummary || (HarnessCatalogSummary = {}));
+
+// ../../packages/client/src/generated/api/types/HarnessSemanticSearchResponse.ts
+var HarnessSemanticSearchResponse;
+((HarnessSemanticSearchResponse2) => {
+  HarnessSemanticSearchResponse2.Model = {
+    CfBaaiBgeBaseEnV15: "@cf/baai/bge-base-en-v1.5"
+  };
+})(HarnessSemanticSearchResponse || (HarnessSemanticSearchResponse = {}));
+
+// ../../packages/client/src/generated/api/types/HarnessVectorizeBinding.ts
+var HarnessVectorizeBinding;
+((HarnessVectorizeBinding2) => {
+  HarnessVectorizeBinding2.Index = {
+    CurlyNgAgents: "curly-ng-agents"
+  };
+  HarnessVectorizeBinding2.Binding = {
+    Vectorize: "VECTORIZE"
+  };
+})(HarnessVectorizeBinding || (HarnessVectorizeBinding = {}));
+
+// ../../packages/client/src/generated/core/headers.ts
+function mergeHeaders(...headersArray) {
+  const result = {};
+  for (const [key, value] of headersArray.filter((headers) => headers != null).flatMap((headers) => Object.entries(headers))) {
+    const insensitiveKey = key.toLowerCase();
+    if (value != null) {
+      result[insensitiveKey] = value;
+    } else if (insensitiveKey in result) {
+      delete result[insensitiveKey];
+    }
+  }
+  return result;
+}
+
+// ../../packages/client/src/generated/core/fetcher/EndpointSupplier.ts
+var EndpointSupplier = {
+  get: async (supplier, arg) => {
+    if (typeof supplier === "function") {
+      return supplier(arg);
+    } else {
+      return supplier;
+    }
+  }
+};
+
+// ../../packages/client/src/generated/core/logging/logger.ts
+var LogLevel = {
+  Debug: "debug",
+  Info: "info",
+  Warn: "warn",
+  Error: "error"
+};
+var logLevelMap = {
+  [LogLevel.Debug]: 1,
+  [LogLevel.Info]: 2,
+  [LogLevel.Warn]: 3,
+  [LogLevel.Error]: 4
+};
+var ConsoleLogger = class {
+  debug(message, ...args) {
+    console.debug(message, ...args);
+  }
+  info(message, ...args) {
+    console.info(message, ...args);
+  }
+  warn(message, ...args) {
+    console.warn(message, ...args);
+  }
+  error(message, ...args) {
+    console.error(message, ...args);
+  }
+};
+var Logger = class {
+  level;
+  logger;
+  silent;
+  /**
+   * Creates a new logger instance.
+   * @param config - Logger configuration
+   */
+  constructor(config) {
+    this.level = logLevelMap[config.level];
+    this.logger = config.logger;
+    this.silent = config.silent;
+  }
+  /**
+   * Checks if a log level should be output based on configuration.
+   * @param level - The log level to check
+   * @returns True if the level should be logged
+   */
+  shouldLog(level) {
+    return !this.silent && this.level <= logLevelMap[level];
+  }
+  /**
+   * Checks if debug logging is enabled.
+   * @returns True if debug logs should be output
+   */
+  isDebug() {
+    return this.shouldLog(LogLevel.Debug);
+  }
+  /**
+   * Logs a debug message if debug logging is enabled.
+   * @param message - The message to log
+   * @param args - Additional arguments to log
+   */
+  debug(message, ...args) {
+    if (this.isDebug()) {
+      this.logger.debug(message, ...args);
+    }
+  }
+  /**
+   * Checks if info logging is enabled.
+   * @returns True if info logs should be output
+   */
+  isInfo() {
+    return this.shouldLog(LogLevel.Info);
+  }
+  /**
+   * Logs an info message if info logging is enabled.
+   * @param message - The message to log
+   * @param args - Additional arguments to log
+   */
+  info(message, ...args) {
+    if (this.isInfo()) {
+      this.logger.info(message, ...args);
+    }
+  }
+  /**
+   * Checks if warning logging is enabled.
+   * @returns True if warning logs should be output
+   */
+  isWarn() {
+    return this.shouldLog(LogLevel.Warn);
+  }
+  /**
+   * Logs a warning message if warning logging is enabled.
+   * @param message - The message to log
+   * @param args - Additional arguments to log
+   */
+  warn(message, ...args) {
+    if (this.isWarn()) {
+      this.logger.warn(message, ...args);
+    }
+  }
+  /**
+   * Checks if error logging is enabled.
+   * @returns True if error logs should be output
+   */
+  isError() {
+    return this.shouldLog(LogLevel.Error);
+  }
+  /**
+   * Logs an error message if error logging is enabled.
+   * @param message - The message to log
+   * @param args - Additional arguments to log
+   */
+  error(message, ...args) {
+    if (this.isError()) {
+      this.logger.error(message, ...args);
+    }
+  }
+};
+function createLogger(config) {
+  if (config == null) {
+    return defaultLogger;
+  }
+  if (config instanceof Logger) {
+    return config;
+  }
+  config = config ?? {};
+  config.level ??= LogLevel.Info;
+  config.logger ??= new ConsoleLogger();
+  config.silent ??= true;
+  return new Logger(config);
+}
+var defaultLogger = new Logger({
+  level: LogLevel.Info,
+  logger: new ConsoleLogger(),
+  silent: true
+});
+
+// ../../packages/client/src/generated/core/url/qs.ts
+var defaultQsOptions = {
+  arrayFormat: "indices",
+  encode: true
+};
+function encodeValue(value, shouldEncode) {
+  if (value === void 0) {
+    return "";
+  }
+  if (value === null) {
+    return "";
+  }
+  const stringValue = String(value);
+  return shouldEncode ? encodeURIComponent(stringValue) : stringValue;
+}
+function stringifyObject(obj, prefix = "", options) {
+  const parts = [];
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}[${key}]` : key;
+    if (value === void 0) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        continue;
+      }
+      const effectiveFormat = options.arrayFormat;
+      if (effectiveFormat === "comma") {
+        const encodedKey = options.encode ? encodeURIComponent(fullKey) : fullKey;
+        const encodedValues = value.filter((item) => item !== void 0 && item !== null).map((item) => encodeValue(item, options.encode));
+        if (encodedValues.length > 0) {
+          parts.push(`${encodedKey}=${encodedValues.join(",")}`);
+        }
+      } else {
+        for (let i = 0; i < value.length; i++) {
+          const item = value[i];
+          if (item === void 0) {
+            continue;
+          }
+          if (typeof item === "object" && !Array.isArray(item) && item !== null) {
+            const arrayKey = effectiveFormat === "indices" ? `${fullKey}[${i}]` : fullKey;
+            parts.push(...stringifyObject(item, arrayKey, options));
+          } else {
+            const arrayKey = effectiveFormat === "indices" ? `${fullKey}[${i}]` : fullKey;
+            const encodedKey = options.encode ? encodeURIComponent(arrayKey) : arrayKey;
+            parts.push(`${encodedKey}=${encodeValue(item, options.encode)}`);
+          }
+        }
+      }
+    } else if (typeof value === "object" && value !== null) {
+      if (Object.keys(value).length === 0) {
+        continue;
+      }
+      parts.push(...stringifyObject(value, fullKey, options));
+    } else {
+      const encodedKey = options.encode ? encodeURIComponent(fullKey) : fullKey;
+      parts.push(`${encodedKey}=${encodeValue(value, options.encode)}`);
+    }
+  }
+  return parts;
+}
+function toQueryString(obj, options) {
+  if (obj == null || typeof obj !== "object") {
+    return "";
+  }
+  const parts = stringifyObject(obj, "", {
+    ...defaultQsOptions,
+    ...options
+  });
+  return parts.join("&");
+}
+
+// ../../packages/client/src/generated/core/fetcher/createRequestUrl.ts
+function createRequestUrl(baseUrl, queryParameters) {
+  const queryString = toQueryString(queryParameters, { arrayFormat: "repeat" });
+  return queryString ? `${baseUrl}?${queryString}` : baseUrl;
+}
+
+// ../../packages/client/src/generated/core/fetcher/BinaryResponse.ts
+function getBinaryResponse(response) {
+  const binaryResponse = {
+    get bodyUsed() {
+      return response.bodyUsed;
+    },
+    stream: () => response.body,
+    arrayBuffer: response.arrayBuffer.bind(response),
+    blob: response.blob.bind(response)
+  };
+  if ("bytes" in response && typeof response.bytes === "function") {
+    binaryResponse.bytes = response.bytes.bind(response);
+  }
+  return binaryResponse;
+}
+
+// ../../packages/client/src/generated/core/fetcher/getResponseBody.ts
+function retainResponse(target, response) {
+  Object.defineProperty(target, "__fern_response_ref", {
+    value: response,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+}
+async function getResponseBody(response, responseType) {
+  switch (responseType) {
+    case "binary-response":
+      return getBinaryResponse(response);
+    case "blob":
+      return await response.blob();
+    case "arrayBuffer":
+      return await response.arrayBuffer();
+    case "sse":
+      if (response.body == null) {
+        return {
+          ok: false,
+          error: {
+            reason: "body-is-null",
+            statusCode: response.status
+          }
+        };
+      }
+      retainResponse(response.body, response);
+      return response.body;
+    case "streaming":
+      if (response.body == null) {
+        return {
+          ok: false,
+          error: {
+            reason: "body-is-null",
+            statusCode: response.status
+          }
+        };
+      }
+      retainResponse(response.body, response);
+      return response.body;
+    case "text":
+      return await response.text();
+  }
+  const text = await response.text();
+  if (text.length > 0) {
+    try {
+      const responseBody = fromJson(text);
+      return responseBody;
+    } catch (_err) {
+      return {
+        ok: false,
+        error: {
+          reason: "non-json",
+          statusCode: response.status,
+          rawBody: text
+        }
+      };
+    }
+  }
+  return void 0;
+}
+
+// ../../packages/client/src/generated/core/fetcher/getErrorResponseBody.ts
+async function getErrorResponseBody(response) {
+  let contentType = response.headers.get("Content-Type")?.toLowerCase();
+  if (contentType == null || contentType.length === 0) {
+    return getResponseBody(response);
+  }
+  if (contentType.indexOf(";") !== -1) {
+    contentType = contentType.split(";")[0]?.trim() ?? "";
+  }
+  switch (contentType) {
+    case "application/hal+json":
+    case "application/json":
+    case "application/ld+json":
+    case "application/problem+json":
+    case "application/vnd.api+json":
+    case "text/json": {
+      const text = await response.text();
+      return text.length > 0 ? fromJson(text) : void 0;
+    }
+    default:
+      if (contentType.startsWith("application/vnd.") && contentType.endsWith("+json")) {
+        const text = await response.text();
+        return text.length > 0 ? fromJson(text) : void 0;
+      }
+      return await response.text();
+  }
+}
+
+// ../../packages/client/src/generated/core/fetcher/getFetchFn.ts
+async function getFetchFn() {
+  return fetch;
+}
+
+// ../../packages/client/src/generated/core/fetcher/getRequestBody.ts
+async function getRequestBody({ body, type }) {
+  if (type === "form") {
+    return toQueryString(body, { arrayFormat: "repeat", encode: true });
+  }
+  if (type.includes("json")) {
+    return toJson(body);
+  } else {
+    return body;
+  }
+}
+
+// ../../packages/client/src/generated/core/fetcher/Headers.ts
+var Headers2;
+if (typeof globalThis.Headers !== "undefined") {
+  Headers2 = globalThis.Headers;
+} else {
+  Headers2 = class Headers3 {
+    headers;
+    constructor(init) {
+      this.headers = /* @__PURE__ */ new Map();
+      if (init) {
+        if (init instanceof Headers3) {
+          init.forEach((value, key) => this.append(key, value));
+        } else if (Array.isArray(init)) {
+          for (const [key, value] of init) {
+            if (typeof key === "string" && typeof value === "string") {
+              this.append(key, value);
+            } else {
+              throw new TypeError("Each header entry must be a [string, string] tuple");
+            }
+          }
+        } else {
+          for (const [key, value] of Object.entries(init)) {
+            if (typeof value === "string") {
+              this.append(key, value);
+            } else {
+              throw new TypeError("Header values must be strings");
+            }
+          }
+        }
+      }
+    }
+    append(name, value) {
+      const key = name.toLowerCase();
+      const existing = this.headers.get(key) || [];
+      this.headers.set(key, [...existing, value]);
+    }
+    delete(name) {
+      const key = name.toLowerCase();
+      this.headers.delete(key);
+    }
+    get(name) {
+      const key = name.toLowerCase();
+      const values = this.headers.get(key);
+      return values ? values.join(", ") : null;
+    }
+    has(name) {
+      const key = name.toLowerCase();
+      return this.headers.has(key);
+    }
+    set(name, value) {
+      const key = name.toLowerCase();
+      this.headers.set(key, [value]);
+    }
+    forEach(callbackfn, thisArg) {
+      const boundCallback = thisArg ? callbackfn.bind(thisArg) : callbackfn;
+      this.headers.forEach((values, key) => boundCallback(values.join(", "), key, this));
+    }
+    getSetCookie() {
+      return this.headers.get("set-cookie") || [];
+    }
+    *entries() {
+      for (const [key, values] of this.headers.entries()) {
+        yield [key, values.join(", ")];
+      }
+    }
+    *keys() {
+      yield* this.headers.keys();
+    }
+    *values() {
+      for (const values of this.headers.values()) {
+        yield values.join(", ");
+      }
+    }
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+  };
+}
+
+// ../../packages/client/src/generated/core/fetcher/signals.ts
+var TIMEOUT = "timeout";
+function getTimeoutSignal(timeoutMs) {
+  const controller = new AbortController();
+  const abortId = setTimeout(() => controller.abort(TIMEOUT), timeoutMs);
+  return { signal: controller.signal, abortId };
+}
+function anySignal(...args) {
+  const signals = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+  const controller = new AbortController();
+  for (const signal of signals) {
+    if (signal.aborted) {
+      controller.abort(signal?.reason);
+      return controller.signal;
+    }
+    signal.addEventListener("abort", () => controller.abort(signal?.reason), {
+      signal: controller.signal
+    });
+    if (signal.aborted) {
+      controller.abort(signal?.reason);
+      return controller.signal;
+    }
+  }
+  return controller.signal;
+}
+
+// ../../packages/client/src/generated/core/fetcher/makeRequest.ts
+var _cacheNoStoreSupported;
+function isCacheNoStoreSupported() {
+  if (_cacheNoStoreSupported != null) {
+    return _cacheNoStoreSupported;
+  }
+  try {
+    new Request("http://localhost", { cache: "no-store" });
+    _cacheNoStoreSupported = true;
+  } catch {
+    _cacheNoStoreSupported = false;
+  }
+  return _cacheNoStoreSupported;
+}
+var makeRequest = async (fetchFn, url, method, headers, requestBody, timeoutMs, abortSignal, withCredentials, duplex, disableCache) => {
+  const signals = [];
+  let timeoutAbortId;
+  if (timeoutMs != null) {
+    const { signal, abortId } = getTimeoutSignal(timeoutMs);
+    timeoutAbortId = abortId;
+    signals.push(signal);
+  }
+  if (abortSignal != null) {
+    signals.push(abortSignal);
+  }
+  const newSignals = anySignal(signals);
+  const response = await fetchFn(url, {
+    method,
+    headers,
+    body: requestBody,
+    signal: newSignals,
+    credentials: withCredentials ? "include" : void 0,
+    // @ts-ignore
+    duplex,
+    ...disableCache && isCacheNoStoreSupported() ? { cache: "no-store" } : {}
+  });
+  if (timeoutAbortId != null) {
+    clearTimeout(timeoutAbortId);
+  }
+  return response;
+};
+
+// ../../packages/client/src/generated/core/fetcher/RawResponse.ts
+var abortRawResponse = {
+  headers: new Headers2(),
+  redirected: false,
+  status: 499,
+  statusText: "Client Closed Request",
+  type: "error",
+  url: ""
+};
+var unknownRawResponse = {
+  headers: new Headers2(),
+  redirected: false,
+  status: 0,
+  statusText: "Unknown Error",
+  type: "error",
+  url: ""
+};
+function toRawResponse(response) {
+  return {
+    headers: response.headers,
+    redirected: response.redirected,
+    status: response.status,
+    statusText: response.statusText,
+    type: response.type,
+    url: response.url
+  };
+}
+
+// ../../packages/client/src/generated/core/fetcher/requestWithRetries.ts
+var INITIAL_RETRY_DELAY = 1e3;
+var MAX_RETRY_DELAY = 6e4;
+var DEFAULT_MAX_RETRIES = 2;
+var JITTER_FACTOR = 0.2;
+function isRetryableStatusCode(statusCode) {
+  return [408, 429].includes(statusCode) || statusCode >= 500;
+}
+function addPositiveJitter(delay) {
+  const jitterMultiplier = 1 + Math.random() * JITTER_FACTOR;
+  return delay * jitterMultiplier;
+}
+function addSymmetricJitter(delay) {
+  const jitterMultiplier = 1 + (Math.random() - 0.5) * JITTER_FACTOR;
+  return delay * jitterMultiplier;
+}
+function getRetryDelayFromHeaders(response, retryAttempt) {
+  const retryAfter = response.headers.get("Retry-After");
+  if (retryAfter) {
+    const retryAfterSeconds = parseInt(retryAfter, 10);
+    if (!Number.isNaN(retryAfterSeconds) && retryAfterSeconds > 0) {
+      return Math.min(retryAfterSeconds * 1e3, MAX_RETRY_DELAY);
+    }
+    const retryAfterDate = new Date(retryAfter);
+    if (!Number.isNaN(retryAfterDate.getTime())) {
+      const delay = retryAfterDate.getTime() - Date.now();
+      if (delay > 0) {
+        return Math.min(Math.max(delay, 0), MAX_RETRY_DELAY);
+      }
+    }
+  }
+  const rateLimitReset = response.headers.get("X-RateLimit-Reset");
+  if (rateLimitReset) {
+    const resetTime = parseInt(rateLimitReset, 10);
+    if (!Number.isNaN(resetTime)) {
+      const delay = resetTime * 1e3 - Date.now();
+      if (delay > 0) {
+        return addPositiveJitter(Math.min(delay, MAX_RETRY_DELAY));
+      }
+    }
+  }
+  return addSymmetricJitter(Math.min(INITIAL_RETRY_DELAY * 2 ** retryAttempt, MAX_RETRY_DELAY));
+}
+async function requestWithRetries(requestFn, maxRetries = DEFAULT_MAX_RETRIES) {
+  let response = await requestFn();
+  for (let i = 0; i < maxRetries; ++i) {
+    if (isRetryableStatusCode(response.status)) {
+      const delay = getRetryDelayFromHeaders(response, i);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      response = await requestFn();
+    } else {
+      break;
+    }
+  }
+  return response;
+}
+
+// ../../packages/client/src/generated/core/fetcher/Fetcher.ts
+var SENSITIVE_HEADERS = /* @__PURE__ */ new Set([
+  "authorization",
+  "www-authenticate",
+  "x-api-key",
+  "api-key",
+  "apikey",
+  "x-api-token",
+  "x-auth-token",
+  "auth-token",
+  "cookie",
+  "set-cookie",
+  "proxy-authorization",
+  "proxy-authenticate",
+  "x-csrf-token",
+  "x-xsrf-token",
+  "x-session-token",
+  "x-access-token"
+]);
+function redactHeaders(headers) {
+  const filtered = {};
+  for (const [key, value] of headers instanceof Headers2 ? headers.entries() : Object.entries(headers)) {
+    if (SENSITIVE_HEADERS.has(key.toLowerCase())) {
+      filtered[key] = "[REDACTED]";
+    } else {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+var SENSITIVE_QUERY_PARAMS = /* @__PURE__ */ new Set([
+  "api_key",
+  "api-key",
+  "apikey",
+  "token",
+  "access_token",
+  "access-token",
+  "auth_token",
+  "auth-token",
+  "password",
+  "passwd",
+  "secret",
+  "api_secret",
+  "api-secret",
+  "apisecret",
+  "key",
+  "session",
+  "session_id",
+  "session-id"
+]);
+function redactQueryParameters(queryParameters) {
+  if (queryParameters == null) {
+    return void 0;
+  }
+  const redacted = {};
+  for (const [key, value] of Object.entries(queryParameters)) {
+    redacted[key] = SENSITIVE_QUERY_PARAMS.has(key.toLowerCase()) ? "[REDACTED]" : value;
+  }
+  return redacted;
+}
+function redactUrl(url) {
+  const protocolIndex = url.indexOf("://");
+  if (protocolIndex === -1) return url;
+  const afterProtocol = protocolIndex + 3;
+  const pathStart = url.indexOf("/", afterProtocol);
+  let queryStart = url.indexOf("?", afterProtocol);
+  let fragmentStart = url.indexOf("#", afterProtocol);
+  const firstDelimiter = Math.min(
+    pathStart === -1 ? url.length : pathStart,
+    queryStart === -1 ? url.length : queryStart,
+    fragmentStart === -1 ? url.length : fragmentStart
+  );
+  let atIndex = -1;
+  for (let i = afterProtocol; i < firstDelimiter; i++) {
+    if (url[i] === "@") {
+      atIndex = i;
+    }
+  }
+  if (atIndex !== -1) {
+    url = `${url.slice(0, afterProtocol)}[REDACTED]@${url.slice(atIndex + 1)}`;
+  }
+  queryStart = url.indexOf("?");
+  if (queryStart === -1) return url;
+  fragmentStart = url.indexOf("#", queryStart);
+  const queryEnd = fragmentStart !== -1 ? fragmentStart : url.length;
+  const queryString = url.slice(queryStart + 1, queryEnd);
+  if (queryString.length === 0) return url;
+  const lower = queryString.toLowerCase();
+  const hasSensitive = lower.includes("token") || lower.includes("key") || lower.includes("password") || lower.includes("passwd") || lower.includes("secret") || lower.includes("session") || lower.includes("auth");
+  if (!hasSensitive) {
+    return url;
+  }
+  const redactedParams = [];
+  const params = queryString.split("&");
+  for (const param of params) {
+    const equalIndex = param.indexOf("=");
+    if (equalIndex === -1) {
+      redactedParams.push(param);
+      continue;
+    }
+    const key = param.slice(0, equalIndex);
+    let shouldRedact = SENSITIVE_QUERY_PARAMS.has(key.toLowerCase());
+    if (!shouldRedact && key.includes("%")) {
+      try {
+        const decodedKey = decodeURIComponent(key);
+        shouldRedact = SENSITIVE_QUERY_PARAMS.has(decodedKey.toLowerCase());
+      } catch {
+      }
+    }
+    redactedParams.push(shouldRedact ? `${key}=[REDACTED]` : param);
+  }
+  return url.slice(0, queryStart + 1) + redactedParams.join("&") + url.slice(queryEnd);
+}
+async function getHeaders(args) {
+  const newHeaders = new Headers2();
+  newHeaders.set(
+    "Accept",
+    args.responseType === "json" ? "application/json" : args.responseType === "text" ? "text/plain" : args.responseType === "sse" ? "text/event-stream" : "*/*"
+  );
+  if (args.body !== void 0 && args.contentType != null) {
+    newHeaders.set("Content-Type", args.contentType);
+  }
+  if (args.headers == null) {
+    return newHeaders;
+  }
+  for (const [key, value] of Object.entries(args.headers)) {
+    const result = await EndpointSupplier.get(value, { endpointMetadata: args.endpointMetadata ?? {} });
+    if (typeof result === "string") {
+      newHeaders.set(key, result);
+      continue;
+    }
+    if (result == null) {
+      continue;
+    }
+    newHeaders.set(key, `${result}`);
+  }
+  return newHeaders;
+}
+async function fetcherImpl(args) {
+  let url = args.url;
+  if (args.queryString != null && args.queryString.length > 0) {
+    url = `${url}?${args.queryString}`;
+  } else {
+    url = createRequestUrl(args.url, args.queryParameters);
+  }
+  const requestBody = await getRequestBody({
+    body: args.body,
+    type: args.requestType ?? "other"
+  });
+  const fetchFn = args.fetchFn ?? await getFetchFn();
+  const headers = await getHeaders(args);
+  const logger = createLogger(args.logging);
+  if (logger.isDebug()) {
+    const metadata = {
+      method: args.method,
+      url: redactUrl(url),
+      headers: redactHeaders(headers),
+      queryParameters: redactQueryParameters(args.queryParameters),
+      hasBody: requestBody != null
+    };
+    logger.debug("Making HTTP request", metadata);
+  }
+  try {
+    const response = await requestWithRetries(
+      async () => makeRequest(
+        fetchFn,
+        url,
+        args.method,
+        headers,
+        requestBody,
+        args.timeoutMs,
+        args.abortSignal,
+        args.withCredentials,
+        args.duplex,
+        args.responseType === "streaming" || args.responseType === "sse"
+      ),
+      args.maxRetries
+    );
+    if (response.status >= 200 && response.status < 400) {
+      if (logger.isDebug()) {
+        const metadata = {
+          method: args.method,
+          url: redactUrl(url),
+          statusCode: response.status,
+          responseHeaders: redactHeaders(response.headers)
+        };
+        logger.debug("HTTP request succeeded", metadata);
+      }
+      const body = await getResponseBody(response, args.responseType);
+      return {
+        ok: true,
+        body,
+        headers: response.headers,
+        rawResponse: toRawResponse(response)
+      };
+    } else {
+      if (logger.isError()) {
+        const metadata = {
+          method: args.method,
+          url: redactUrl(url),
+          statusCode: response.status,
+          responseHeaders: redactHeaders(Object.fromEntries(response.headers.entries()))
+        };
+        logger.error("HTTP request failed with error status", metadata);
+      }
+      return {
+        ok: false,
+        error: {
+          reason: "status-code",
+          statusCode: response.status,
+          body: await getErrorResponseBody(response)
+        },
+        rawResponse: toRawResponse(response)
+      };
+    }
+  } catch (error) {
+    if (args.abortSignal?.aborted) {
+      if (logger.isError()) {
+        const metadata = {
+          method: args.method,
+          url: redactUrl(url)
+        };
+        logger.error("HTTP request was aborted", metadata);
+      }
+      return {
+        ok: false,
+        error: {
+          reason: "unknown",
+          errorMessage: "The user aborted a request",
+          cause: error
+        },
+        rawResponse: abortRawResponse
+      };
+    } else if (error instanceof Error && error.name === "AbortError") {
+      if (logger.isError()) {
+        const metadata = {
+          method: args.method,
+          url: redactUrl(url),
+          timeoutMs: args.timeoutMs
+        };
+        logger.error("HTTP request timed out", metadata);
+      }
+      return {
+        ok: false,
+        error: {
+          reason: "timeout",
+          cause: error
+        },
+        rawResponse: abortRawResponse
+      };
+    } else if (error instanceof Error) {
+      if (logger.isError()) {
+        const metadata = {
+          method: args.method,
+          url: redactUrl(url),
+          errorMessage: error.message
+        };
+        logger.error("HTTP request failed with error", metadata);
+      }
+      return {
+        ok: false,
+        error: {
+          reason: "unknown",
+          errorMessage: error.message,
+          cause: error
+        },
+        rawResponse: unknownRawResponse
+      };
+    }
+    if (logger.isError()) {
+      const metadata = {
+        method: args.method,
+        url: redactUrl(url),
+        error: toJson(error)
+      };
+      logger.error("HTTP request failed with unknown error", metadata);
+    }
+    return {
+      ok: false,
+      error: {
+        reason: "unknown",
+        errorMessage: toJson(error),
+        cause: error
+      },
+      rawResponse: unknownRawResponse
+    };
+  }
+}
+var fetcher = fetcherImpl;
+
+// ../../packages/client/src/generated/core/fetcher/HttpResponsePromise.ts
+var HttpResponsePromise = class _HttpResponsePromise extends Promise {
+  innerPromise;
+  unwrappedPromise;
+  constructor(promise) {
+    super((resolve) => {
+      resolve(void 0);
+    });
+    this.innerPromise = promise;
+  }
+  /**
+   * Creates an `HttpResponsePromise` from a function that returns a promise.
+   *
+   * @param fn - A function that returns a promise resolving to a `WithRawResponse` object.
+   * @param args - Arguments to pass to the function.
+   * @returns An `HttpResponsePromise` instance.
+   */
+  static fromFunction(fn, ...args) {
+    return new _HttpResponsePromise(fn(...args));
+  }
+  /**
+   * Creates a function that returns an `HttpResponsePromise` from a function that returns a promise.
+   *
+   * @param fn - A function that returns a promise resolving to a `WithRawResponse` object.
+   * @returns A function that returns an `HttpResponsePromise` instance.
+   */
+  static interceptFunction(fn) {
+    return (...args) => {
+      return _HttpResponsePromise.fromPromise(fn(...args));
+    };
+  }
+  /**
+   * Creates an `HttpResponsePromise` from an existing promise.
+   *
+   * @param promise - A promise resolving to a `WithRawResponse` object.
+   * @returns An `HttpResponsePromise` instance.
+   */
+  static fromPromise(promise) {
+    return new _HttpResponsePromise(promise);
+  }
+  /**
+   * Creates an `HttpResponsePromise` from an executor function.
+   *
+   * @param executor - A function that takes resolve and reject callbacks to create a promise.
+   * @returns An `HttpResponsePromise` instance.
+   */
+  static fromExecutor(executor) {
+    const promise = new Promise(executor);
+    return new _HttpResponsePromise(promise);
+  }
+  /**
+   * Creates an `HttpResponsePromise` from a resolved result.
+   *
+   * @param result - A `WithRawResponse` object to resolve immediately.
+   * @returns An `HttpResponsePromise` instance.
+   */
+  static fromResult(result) {
+    const promise = Promise.resolve(result);
+    return new _HttpResponsePromise(promise);
+  }
+  unwrap() {
+    if (!this.unwrappedPromise) {
+      this.unwrappedPromise = this.innerPromise.then(({ data }) => data);
+    }
+    return this.unwrappedPromise;
+  }
+  /** @inheritdoc */
+  then(onfulfilled, onrejected) {
+    return this.unwrap().then(onfulfilled, onrejected);
+  }
+  /** @inheritdoc */
+  catch(onrejected) {
+    return this.unwrap().catch(onrejected);
+  }
+  /** @inheritdoc */
+  finally(onfinally) {
+    return this.unwrap().finally(onfinally);
+  }
+  /**
+   * Retrieves the data and raw response.
+   *
+   * @returns A promise resolving to a `WithRawResponse` object.
+   */
+  async withRawResponse() {
+    return await this.innerPromise;
+  }
+};
+
+// ../../packages/client/src/generated/core/url/join.ts
+function join(base, ...segments) {
+  if (!base) {
+    return "";
+  }
+  if (segments.length === 0) {
+    return base;
+  }
+  if (base.includes("://")) {
+    let url;
+    try {
+      url = new URL(base);
+    } catch {
+      return joinPath(base, ...segments);
+    }
+    const lastSegment = segments[segments.length - 1];
+    const shouldPreserveTrailingSlash = lastSegment?.endsWith("/");
+    for (const segment of segments) {
+      const cleanSegment = trimSlashes(segment);
+      if (cleanSegment) {
+        url.pathname = joinPathSegments(url.pathname, cleanSegment);
+      }
+    }
+    if (shouldPreserveTrailingSlash && !url.pathname.endsWith("/")) {
+      url.pathname += "/";
+    }
+    return url.toString();
+  }
+  return joinPath(base, ...segments);
+}
+function joinPath(base, ...segments) {
+  if (segments.length === 0) {
+    return base;
+  }
+  let result = base;
+  const lastSegment = segments[segments.length - 1];
+  const shouldPreserveTrailingSlash = lastSegment?.endsWith("/");
+  for (const segment of segments) {
+    const cleanSegment = trimSlashes(segment);
+    if (cleanSegment) {
+      result = joinPathSegments(result, cleanSegment);
+    }
+  }
+  if (shouldPreserveTrailingSlash && !result.endsWith("/")) {
+    result += "/";
+  }
+  return result;
+}
+function joinPathSegments(left, right) {
+  if (left.endsWith("/")) {
+    return left + right;
+  }
+  return `${left}/${right}`;
+}
+function trimSlashes(str) {
+  if (!str) return str;
+  let start = 0;
+  let end = str.length;
+  if (str.startsWith("/")) start = 1;
+  if (str.endsWith("/")) end = str.length - 1;
+  return start === 0 && end === str.length ? str : str.slice(start, end);
+}
+
+// ../../packages/client/src/generated/core/fetcher/Supplier.ts
+var Supplier = {
+  get: async (supplier) => {
+    if (typeof supplier === "function") {
+      return supplier();
+    } else {
+      return supplier;
+    }
+  }
+};
+
+// ../../packages/client/src/generated/core/fetcher/makePassthroughRequest.ts
+async function makePassthroughRequest(input, init, clientOptions, requestOptions) {
+  const logger = createLogger(clientOptions.logging);
+  let url;
+  let effectiveInit = init;
+  if (input instanceof Request) {
+    url = input.url;
+    if (init == null) {
+      effectiveInit = {
+        method: input.method,
+        headers: Object.fromEntries(input.headers.entries()),
+        body: input.body,
+        signal: input.signal,
+        credentials: input.credentials,
+        cache: input.cache,
+        redirect: input.redirect,
+        referrer: input.referrer,
+        integrity: input.integrity,
+        mode: input.mode
+      };
+    }
+  } else {
+    url = input instanceof URL ? input.toString() : input;
+  }
+  const baseUrl = (clientOptions.baseUrl != null ? await Supplier.get(clientOptions.baseUrl) : void 0) ?? (clientOptions.environment != null ? await Supplier.get(clientOptions.environment) : void 0);
+  let fullUrl;
+  if (url.startsWith("http://") || url.startsWith("https://")) {
+    fullUrl = url;
+  } else if (baseUrl != null) {
+    fullUrl = join(baseUrl, url);
+  } else {
+    fullUrl = url;
+  }
+  const mergedHeaders = {};
+  if (clientOptions.headers != null) {
+    for (const [key, value] of Object.entries(clientOptions.headers)) {
+      const resolved = await EndpointSupplier.get(value, { endpointMetadata: {} });
+      if (resolved != null) {
+        mergedHeaders[key.toLowerCase()] = `${resolved}`;
+      }
+    }
+  }
+  if (clientOptions.getAuthHeaders != null) {
+    const authHeaders = await clientOptions.getAuthHeaders();
+    for (const [key, value] of Object.entries(authHeaders)) {
+      mergedHeaders[key.toLowerCase()] = value;
+    }
+  }
+  if (effectiveInit?.headers != null) {
+    const initHeaders = effectiveInit.headers instanceof Headers ? Object.fromEntries(effectiveInit.headers.entries()) : Array.isArray(effectiveInit.headers) ? Object.fromEntries(effectiveInit.headers) : effectiveInit.headers;
+    for (const [key, value] of Object.entries(initHeaders)) {
+      if (value != null) {
+        mergedHeaders[key.toLowerCase()] = value;
+      }
+    }
+  }
+  if (requestOptions?.headers != null) {
+    for (const [key, value] of Object.entries(requestOptions.headers)) {
+      mergedHeaders[key.toLowerCase()] = value;
+    }
+  }
+  const method = effectiveInit?.method ?? "GET";
+  const body = effectiveInit?.body;
+  const timeoutInSeconds = requestOptions?.timeoutInSeconds ?? clientOptions.timeoutInSeconds;
+  const timeoutMs = timeoutInSeconds != null ? timeoutInSeconds * 1e3 : void 0;
+  const maxRetries = requestOptions?.maxRetries ?? clientOptions.maxRetries;
+  const abortSignal = requestOptions?.abortSignal ?? effectiveInit?.signal ?? void 0;
+  const fetchFn = clientOptions.fetch ?? await getFetchFn();
+  if (logger.isDebug()) {
+    logger.debug("Making passthrough HTTP request", {
+      method,
+      url: fullUrl,
+      hasBody: body != null
+    });
+  }
+  const response = await requestWithRetries(
+    async () => makeRequest(
+      fetchFn,
+      fullUrl,
+      method,
+      mergedHeaders,
+      body ?? void 0,
+      timeoutMs,
+      abortSignal,
+      effectiveInit?.credentials === "include",
+      void 0,
+      // duplex
+      false
+      // disableCache
+    ),
+    maxRetries
+  );
+  if (logger.isDebug()) {
+    logger.debug("Passthrough HTTP request completed", {
+      method,
+      url: fullUrl,
+      statusCode: response.status
+    });
+  }
+  return response;
+}
+
+// ../../packages/client/src/generated/core/logging/index.ts
+var logging_exports = {};
+__export(logging_exports, {
+  ConsoleLogger: () => ConsoleLogger,
+  LogLevel: () => LogLevel,
+  Logger: () => Logger,
+  createLogger: () => createLogger
+});
+
+// ../../packages/client/src/generated/core/runtime/runtime.ts
+var RUNTIME = evaluateRuntime();
+function evaluateRuntime() {
+  const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+  if (isBrowser) {
+    return {
+      type: "browser",
+      version: window.navigator.userAgent
+    };
+  }
+  const isCloudflare = typeof globalThis !== "undefined" && globalThis?.navigator?.userAgent === "Cloudflare-Workers";
+  if (isCloudflare) {
+    return {
+      type: "workerd"
+    };
+  }
+  const isEdgeRuntime = typeof EdgeRuntime === "string";
+  if (isEdgeRuntime) {
+    return {
+      type: "edge-runtime"
+    };
+  }
+  const isWebWorker = typeof self === "object" && typeof self?.importScripts === "function" && (self.constructor?.name === "DedicatedWorkerGlobalScope" || self.constructor?.name === "ServiceWorkerGlobalScope" || self.constructor?.name === "SharedWorkerGlobalScope");
+  if (isWebWorker) {
+    return {
+      type: "web-worker"
+    };
+  }
+  const isDeno = typeof Deno !== "undefined" && typeof Deno.version !== "undefined" && typeof Deno.version.deno !== "undefined";
+  if (isDeno) {
+    return {
+      type: "deno",
+      version: Deno.version.deno
+    };
+  }
+  const isBun = typeof Bun !== "undefined" && typeof Bun.version !== "undefined";
+  if (isBun) {
+    return {
+      type: "bun",
+      version: Bun.version
+    };
+  }
+  const isReactNative = typeof navigator !== "undefined" && navigator?.product === "ReactNative";
+  if (isReactNative) {
+    return {
+      type: "react-native"
+    };
+  }
+  const _process = typeof process !== "undefined" ? process : void 0;
+  const isNode = typeof _process !== "undefined" && typeof _process.versions?.node === "string";
+  if (isNode) {
+    return {
+      type: "node",
+      version: _process.versions.node,
+      parsedVersion: Number(_process.versions.node.split(".")[0])
+    };
+  }
+  return {
+    type: "unknown"
+  };
+}
+
+// ../../packages/client/src/generated/core/stream/Stream.ts
+var DATA_PREFIX = "data:";
+var EVENT_PREFIX = "event:";
+var Stream = class {
+  stream;
+  parse;
+  /**
+   * The prefix to use for each message. For example,
+   * for SSE, the prefix is "data: ".
+   */
+  prefix;
+  messageTerminator;
+  streamTerminator;
+  eventDiscriminator;
+  controller = new AbortController();
+  decoder;
+  constructor({ stream, parse, eventShape, signal }) {
+    this.stream = stream;
+    this.parse = parse;
+    if (eventShape.type === "sse") {
+      this.prefix = DATA_PREFIX;
+      this.messageTerminator = "\n";
+      this.streamTerminator = eventShape.streamTerminator;
+      this.eventDiscriminator = eventShape.eventDiscriminator;
+    } else {
+      this.messageTerminator = eventShape.messageTerminator;
+    }
+    signal?.addEventListener("abort", () => this.controller.abort());
+    if (typeof TextDecoder !== "undefined") {
+      this.decoder = new TextDecoder("utf-8");
+    }
+  }
+  async *iterMessages() {
+    if (this.eventDiscriminator != null) {
+      yield* this.iterSseEvents();
+    } else {
+      yield* this.iterDataMessages();
+    }
+  }
+  async *iterDataMessages() {
+    const stream = readableStreamAsyncIterable(this.stream);
+    let buf = "";
+    let prefixSeen = false;
+    for await (const chunk of stream) {
+      buf += this.decodeChunk(chunk);
+      let terminatorIndex;
+      while ((terminatorIndex = buf.indexOf(this.messageTerminator)) >= 0) {
+        let line = buf.slice(0, terminatorIndex);
+        buf = buf.slice(terminatorIndex + this.messageTerminator.length);
+        if (!line.trim()) {
+          continue;
+        }
+        if (!prefixSeen && this.prefix != null) {
+          const prefixIndex = line.indexOf(this.prefix);
+          if (prefixIndex === -1) {
+            continue;
+          }
+          prefixSeen = true;
+          line = line.slice(prefixIndex + this.prefix.length);
+        }
+        if (this.streamTerminator != null && line.includes(this.streamTerminator)) {
+          return;
+        }
+        const message = await this.parse(fromJson(line));
+        yield message;
+        prefixSeen = false;
+      }
+    }
+  }
+  async *iterSseEvents() {
+    const stream = readableStreamAsyncIterable(this.stream);
+    let buf = "";
+    let eventType;
+    let dataValue;
+    for await (const chunk of stream) {
+      buf += this.decodeChunk(chunk);
+      let terminatorIndex;
+      while ((terminatorIndex = buf.indexOf("\n")) >= 0) {
+        const line = buf.slice(0, terminatorIndex).replace(/\r$/, "");
+        buf = buf.slice(terminatorIndex + 1);
+        if (!line.trim()) {
+          if (dataValue != null) {
+            const message = await this.dispatchSseEvent(dataValue, eventType);
+            if (message == null) {
+              return;
+            }
+            yield message;
+          }
+          eventType = void 0;
+          dataValue = void 0;
+          continue;
+        }
+        if (line.startsWith(EVENT_PREFIX)) {
+          eventType = line.slice(EVENT_PREFIX.length).trim();
+        } else if (line.startsWith(DATA_PREFIX)) {
+          const val = line.slice(DATA_PREFIX.length).trim();
+          dataValue = dataValue != null ? `${dataValue}
+${val}` : val;
+        }
+      }
+    }
+    if (dataValue != null) {
+      const message = await this.dispatchSseEvent(dataValue, eventType);
+      if (message != null) {
+        yield message;
+      }
+    }
+  }
+  /**
+   * Parses and returns a single SSE event, or returns null if the event is a stream terminator.
+   */
+  async dispatchSseEvent(dataValue, eventType) {
+    if (this.streamTerminator != null && dataValue.includes(this.streamTerminator)) {
+      return null;
+    }
+    return this.parse(this.injectDiscriminator(fromJson(dataValue), eventType));
+  }
+  injectDiscriminator(parsed, eventType) {
+    if (this.eventDiscriminator == null || eventType == null) {
+      return parsed;
+    }
+    if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return parsed;
+    }
+    const obj = parsed;
+    if (this.eventDiscriminator in obj) {
+      return parsed;
+    }
+    return { [this.eventDiscriminator]: eventType, ...obj };
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const message of this.iterMessages()) {
+      yield message;
+    }
+  }
+  decodeChunk(chunk) {
+    let decoded = "";
+    if (this.decoder != null) {
+      decoded += this.decoder.decode(chunk, { stream: true });
+    } else if (RUNTIME.type === "node" && typeof chunk !== "undefined") {
+      decoded += Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    }
+    return decoded;
+  }
+};
+function readableStreamAsyncIterable(stream) {
+  if (stream[Symbol.asyncIterator]) {
+    return stream;
+  }
+  const reader = stream.getReader();
+  return {
+    async next() {
+      try {
+        const result = await reader.read();
+        if (result?.done) {
+          reader.releaseLock();
+        }
+        return result;
+      } catch (e) {
+        reader.releaseLock();
+        throw e;
+      }
+    },
+    async return() {
+      const cancelPromise = reader.cancel();
+      reader.releaseLock();
+      await cancelPromise;
+      return { done: true, value: void 0 };
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+}
+
+// ../../packages/client/src/generated/core/url/index.ts
+var url_exports = {};
+__export(url_exports, {
+  encodePathParam: () => encodePathParam,
+  join: () => join,
+  queryBuilder: () => queryBuilder,
+  toQueryString: () => toQueryString
+});
+
+// ../../packages/client/src/generated/core/url/encodePathParam.ts
+function encodePathParam(param) {
+  if (param === null) {
+    return "null";
+  }
+  const typeofParam = typeof param;
+  switch (typeofParam) {
+    case "undefined":
+      return "undefined";
+    case "string":
+    case "number":
+    case "boolean":
+      break;
+    default:
+      param = String(param);
+      break;
+  }
+  return encodeURIComponent(param);
+}
+
+// ../../packages/client/src/generated/core/url/QueryStringBuilder.ts
+function queryBuilder() {
+  return new QueryStringBuilder();
+}
+var QueryStringBuilder = class {
+  parts = /* @__PURE__ */ new Map();
+  /**
+   * Adds a query parameter, serializing it immediately.
+   *
+   * By default arrays use "repeat" format (`key=a&key=b`).
+   * Pass `{ style: "comma" }` for OpenAPI `explode: false` parameters
+   * to get comma-separated values (`key=a,b,c`).
+   *
+   * Null / undefined values are silently skipped.
+   */
+  add(key, value, options) {
+    if (value === void 0 || value === null) {
+      return this;
+    }
+    const serialized = toQueryString(
+      { [key]: value },
+      { arrayFormat: options?.style === "comma" ? "comma" : "repeat" }
+    );
+    if (serialized.length > 0) {
+      this.parts.set(key, serialized);
+    }
+    return this;
+  }
+  /**
+   * Adds multiple query parameters at once from a record.
+   * All parameters use the default "repeat" array format.
+   * Null / undefined values are silently skipped.
+   */
+  addMany(params) {
+    if (params != null) {
+      for (const [key, value] of Object.entries(params)) {
+        this.add(key, value);
+      }
+    }
+    return this;
+  }
+  /**
+   * Merges additional query parameters supplied at call-time via
+   * `requestOptions.queryParams`. Overrides existing keys (last-write-wins).
+   */
+  mergeAdditional(additionalParams) {
+    if (additionalParams != null) {
+      for (const [key, value] of Object.entries(additionalParams)) {
+        if (value === void 0 || value === null) {
+          continue;
+        }
+        const serialized = toQueryString({ [key]: value }, { arrayFormat: "repeat" });
+        if (serialized.length > 0) {
+          this.parts.set(key, serialized);
+        }
+      }
+    }
+    return this;
+  }
+  /**
+   * Returns the assembled query string (without the leading `?`).
+   * Returns an empty string when no parameters were added.
+   */
+  build() {
+    return [...this.parts.values()].join("&");
+  }
+};
+
+// ../../packages/client/src/generated/BaseClient.ts
+function normalizeClientOptions(options) {
+  const headers = mergeHeaders(
+    {
+      "X-Fern-Language": "JavaScript",
+      "X-Fern-Runtime": RUNTIME.type,
+      "X-Fern-Runtime-Version": RUNTIME.version
+    },
+    options?.headers
+  );
+  return {
+    ...options,
+    logging: logging_exports.createLogger(options?.logging),
+    headers
+  };
+}
+
+// ../../packages/client/src/generated/environments.ts
+var CngApiEnvironment = {
+  Default: "https://curly.ng"
+};
+
+// ../../packages/client/src/generated/errors/handleNonStatusCodeError.ts
+function handleNonStatusCodeError(error, rawResponse, method, path6) {
+  switch (error.reason) {
+    case "non-json":
+      throw new CngApiError({
+        statusCode: error.statusCode,
+        body: error.rawBody,
+        rawResponse
+      });
+    case "body-is-null":
+      throw new CngApiError({
+        statusCode: error.statusCode,
+        rawResponse
+      });
+    case "timeout":
+      throw new CngApiTimeoutError(`Timeout exceeded when calling ${method} ${path6}.`, {
+        cause: error.cause
+      });
+    case "unknown":
+      throw new CngApiError({
+        message: error.errorMessage,
+        rawResponse,
+        cause: error.cause
+      });
+    default:
+      throw new CngApiError({
+        message: "Unknown error",
+        rawResponse
+      });
+  }
+}
+
+// ../../packages/client/src/generated/api/resources/auth/client/Client.ts
+var AuthClient = class {
+  _options;
+  constructor(options = {}) {
+    this._options = normalizeClientOptions(options);
+  }
+  /**
+   * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link CngApi.UnauthorizedError}
+   *
+   * @example
+   *     await client.auth.getAuthWhoami()
+   */
+  getAuthWhoami(requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getAuthWhoami(requestOptions));
+  }
+  async __getAuthWhoami(requestOptions) {
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/auth/whoami"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 401:
+          throw new UnauthorizedError(_response.error.body, _response.rawResponse);
+        default:
+          throw new CngApiError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/auth/whoami");
+  }
+};
+
+// ../../packages/client/src/generated/api/resources/harnessFilesystem/client/Client.ts
+var HarnessFilesystemClient = class {
+  _options;
+  constructor(options = {}) {
+    this._options = normalizeClientOptions(options);
+  }
+  /**
+   * @param {CngApi.GetHarnessFilesystemReadRequest} request
+   * @param {HarnessFilesystemClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link CngApi.BadRequestError}
+   * @throws {@link CngApi.NotFoundError}
+   * @throws {@link CngApi.ContentTooLargeError}
+   *
+   * @example
+   *     await client.harnessFilesystem.getHarnessFilesystemRead({
+   *         file_path: "file_path"
+   *     })
+   */
+  getHarnessFilesystemRead(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getHarnessFilesystemRead(request, requestOptions));
+  }
+  async __getHarnessFilesystemRead(request, requestOptions) {
+    const { file_path: filePath, offset, limit } = request;
+    const _queryParams = {
+      file_path: filePath,
+      offset,
+      limit
+    };
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/filesystem/read"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 413:
+          throw new ContentTooLargeError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new CngApiError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/harness/filesystem/read");
+  }
+  /**
+   * @param {CngApi.GetHarnessFilesystemGrepRequest} request
+   * @param {HarnessFilesystemClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link CngApi.BadRequestError}
+   *
+   * @example
+   *     await client.harnessFilesystem.getHarnessFilesystemGrep({
+   *         pattern: "pattern"
+   *     })
+   */
+  getHarnessFilesystemGrep(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getHarnessFilesystemGrep(request, requestOptions));
+  }
+  async __getHarnessFilesystemGrep(request, requestOptions) {
+    const { pattern, path: path6, include, output_mode: outputMode, context, case_insensitive: caseInsensitive } = request;
+    const _queryParams = {
+      pattern,
+      path: path6,
+      include,
+      output_mode: outputMode != null ? outputMode : void 0,
+      context,
+      case_insensitive: Array.isArray(caseInsensitive) ? caseInsensitive.map((item) => typeof item === "string" ? item : toJson(item)) : caseInsensitive != null ? typeof caseInsensitive === "string" ? caseInsensitive : toJson(caseInsensitive) : void 0
+    };
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/filesystem/grep"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        default:
+          throw new CngApiError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/harness/filesystem/grep");
+  }
+  /**
+   * @param {CngApi.GetHarnessFilesystemGlobRequest} request
+   * @param {HarnessFilesystemClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link CngApi.BadRequestError}
+   *
+   * @example
+   *     await client.harnessFilesystem.getHarnessFilesystemGlob({
+   *         pattern: "pattern"
+   *     })
+   */
+  getHarnessFilesystemGlob(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getHarnessFilesystemGlob(request, requestOptions));
+  }
+  async __getHarnessFilesystemGlob(request, requestOptions) {
+    const { pattern, path: path6 } = request;
+    const _queryParams = {
+      pattern,
+      path: path6
+    };
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/filesystem/glob"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        default:
+          throw new CngApiError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/harness/filesystem/glob");
+  }
+};
+
+// ../../packages/client/src/generated/api/resources/harnessInternalKnowledges/client/Client.ts
+var HarnessInternalKnowledgesClient = class {
+  _options;
+  constructor(options = {}) {
+    this._options = normalizeClientOptions(options);
+  }
+  /**
+   * @param {HarnessInternalKnowledgesClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link CngApi.UnauthorizedError}
+   * @throws {@link CngApi.ServiceUnavailableError}
+   *
+   * @example
+   *     await client.harnessInternalKnowledges.createHarnessSubskillAssetsSyncPlan()
+   */
+  createHarnessSubskillAssetsSyncPlan(requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__createHarnessSubskillAssetsSyncPlan(requestOptions));
+  }
+  async __createHarnessSubskillAssetsSyncPlan(requestOptions) {
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/internal/knowledges/sync-plans"
+      ),
+      method: "POST",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      responseType: "text",
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 401:
+          throw new UnauthorizedError(_response.error.body, _response.rawResponse);
+        case 503:
+          throw new ServiceUnavailableError(_response.error.body, _response.rawResponse);
+        default:
+          throw new CngApiError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(
+      _response.error,
+      _response.rawResponse,
+      "POST",
+      "/api/harness/internal/knowledges/sync-plans"
+    );
+  }
+  /**
+   * @param {CngApi.GetHarnessSubskillAssetRawFileRequest} request
+   * @param {HarnessInternalKnowledgesClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link CngApi.UnauthorizedError}
+   * @throws {@link CngApi.NotFoundError}
+   * @throws {@link CngApi.ServiceUnavailableError}
+   *
+   * @example
+   *     await client.harnessInternalKnowledges.getHarnessSubskillAssetRawFile({
+   *         path: "x",
+   *         sha256: "sha256"
+   *     })
+   */
+  getHarnessSubskillAssetRawFile(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getHarnessSubskillAssetRawFile(request, requestOptions));
+  }
+  async __getHarnessSubskillAssetRawFile(request, requestOptions) {
+    const { path: path6, sha256 } = request;
+    const _queryParams = {
+      path: path6,
+      sha256
+    };
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/internal/knowledges/files/raw"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      responseType: "text",
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 401:
+          throw new UnauthorizedError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 503:
+          throw new ServiceUnavailableError(_response.error.body, _response.rawResponse);
+        default:
+          throw new CngApiError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(
+      _response.error,
+      _response.rawResponse,
+      "GET",
+      "/api/harness/internal/knowledges/files/raw"
+    );
+  }
+  /**
+   * @param {HarnessInternalKnowledgesClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link CngApi.UnauthorizedError}
+   *
+   * @example
+   *     await client.harnessInternalKnowledges.listHarnessSubskillAssetHashes()
+   */
+  listHarnessSubskillAssetHashes(requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__listHarnessSubskillAssetHashes(requestOptions));
+  }
+  async __listHarnessSubskillAssetHashes(requestOptions) {
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/internal/knowledges/files/hashes"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 401:
+          throw new UnauthorizedError(_response.error.body, _response.rawResponse);
+        default:
+          throw new CngApiError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(
+      _response.error,
+      _response.rawResponse,
+      "GET",
+      "/api/harness/internal/knowledges/files/hashes"
+    );
+  }
+  /**
+   * @param {CngApi.HarnessUploadAddRequest} request
+   * @param {HarnessInternalKnowledgesClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link CngApi.UnauthorizedError}
+   * @throws {@link CngApi.ConflictError}
+   *
+   * @example
+   *     await client.harnessInternalKnowledges.replaceHarnessSubskillAssets({
+   *         uploadedAt: "uploadedAt",
+   *         files: [{
+   *                 path: "path",
+   *                 sha256: "sha256",
+   *                 size: 1,
+   *                 mode: "mode",
+   *                 assetKind: "skill",
+   *                 subskillName: "subskillName",
+   *                 displayTitle: "displayTitle",
+   *                 displayDescription: "displayDescription",
+   *                 displayRating: 1,
+   *                 bodyText: "bodyText"
+   *             }]
+   *     })
+   */
+  replaceHarnessSubskillAssets(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__replaceHarnessSubskillAssets(request, requestOptions));
+  }
+  async __replaceHarnessSubskillAssets(request, requestOptions) {
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/internal/knowledges/files"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: request,
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 401:
+          throw new UnauthorizedError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new CngApiError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(
+      _response.error,
+      _response.rawResponse,
+      "POST",
+      "/api/harness/internal/knowledges/files"
+    );
+  }
+  /**
+   * @param {CngApi.HarnessUploadRemoveRequest} request
+   * @param {HarnessInternalKnowledgesClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link CngApi.UnauthorizedError}
+   * @throws {@link CngApi.ConflictError}
+   *
+   * @example
+   *     await client.harnessInternalKnowledges.deleteHarnessSubskillAssets({
+   *         uploadedAt: "uploadedAt",
+   *         paths: ["paths"]
+   *     })
+   */
+  deleteHarnessSubskillAssets(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__deleteHarnessSubskillAssets(request, requestOptions));
+  }
+  async __deleteHarnessSubskillAssets(request, requestOptions) {
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/internal/knowledges/files"
+      ),
+      method: "DELETE",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: request,
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 401:
+          throw new UnauthorizedError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new CngApiError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(
+      _response.error,
+      _response.rawResponse,
+      "DELETE",
+      "/api/harness/internal/knowledges/files"
+    );
+  }
+  /**
+   * @param {CngApi.HarnessUploadSubskillAssetsVectorizeRequest} request
+   * @param {HarnessInternalKnowledgesClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link CngApi.UnauthorizedError}
+   * @throws {@link CngApi.InternalServerError}
+   *
+   * @example
+   *     await client.harnessInternalKnowledges.createHarnessSubskillAssetsIndex({
+   *         runId: "runId",
+   *         offset: 1,
+   *         limit: 1
+   *     })
+   */
+  createHarnessSubskillAssetsIndex(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__createHarnessSubskillAssetsIndex(request, requestOptions));
+  }
+  async __createHarnessSubskillAssetsIndex(request, requestOptions) {
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/internal/knowledges/indexes"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: request,
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 401:
+          throw new UnauthorizedError(_response.error.body, _response.rawResponse);
+        case 500:
+          throw new InternalServerError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new CngApiError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(
+      _response.error,
+      _response.rawResponse,
+      "POST",
+      "/api/harness/internal/knowledges/indexes"
+    );
+  }
+};
+
+// ../../packages/client/src/generated/api/resources/harnessKnowledges/client/Client.ts
+var HarnessKnowledgesClient = class {
+  _options;
+  constructor(options = {}) {
+    this._options = normalizeClientOptions(options);
+  }
+  /**
+   * @param {HarnessKnowledgesClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.harnessKnowledges.getHarnessKnowledgesCatalog()
+   */
+  getHarnessKnowledgesCatalog(requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getHarnessKnowledgesCatalog(requestOptions));
+  }
+  async __getHarnessKnowledgesCatalog(requestOptions) {
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/knowledges/catalog"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      throw new CngApiError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body,
+        rawResponse: _response.rawResponse
+      });
+    }
+    return handleNonStatusCodeError(
+      _response.error,
+      _response.rawResponse,
+      "GET",
+      "/api/harness/knowledges/catalog"
+    );
+  }
+  /**
+   * @param {HarnessKnowledgesClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.harnessKnowledges.listHarnessKnowledgesAudiences()
+   */
+  listHarnessKnowledgesAudiences(requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__listHarnessKnowledgesAudiences(requestOptions));
+  }
+  async __listHarnessKnowledgesAudiences(requestOptions) {
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/knowledges/audiences"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      throw new CngApiError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body,
+        rawResponse: _response.rawResponse
+      });
+    }
+    return handleNonStatusCodeError(
+      _response.error,
+      _response.rawResponse,
+      "GET",
+      "/api/harness/knowledges/audiences"
+    );
+  }
+  /**
+   * @param {CngApi.ListHarnessSubskillAssetsRequest} request
+   * @param {HarnessKnowledgesClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.harnessKnowledges.listHarnessSubskillAssets()
+   */
+  listHarnessSubskillAssets(request = {}, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__listHarnessSubskillAssets(request, requestOptions));
+  }
+  async __listHarnessSubskillAssets(request = {}, requestOptions) {
+    const { q, audience, limit } = request;
+    const _queryParams = {
+      q,
+      audience: audience != null ? audience : void 0,
+      limit
+    };
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/knowledges/files"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      throw new CngApiError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body,
+        rawResponse: _response.rawResponse
+      });
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/harness/knowledges/files");
+  }
+  /**
+   * @param {CngApi.SearchHarnessKnowledgesRequest} request
+   * @param {HarnessKnowledgesClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link CngApi.InternalServerError}
+   *
+   * @example
+   *     await client.harnessKnowledges.searchHarnessKnowledges({
+   *         q: "q"
+   *     })
+   */
+  searchHarnessKnowledges(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__searchHarnessKnowledges(request, requestOptions));
+  }
+  async __searchHarnessKnowledges(request, requestOptions) {
+    const { q, limit } = request;
+    const _queryParams = {
+      q,
+      limit
+    };
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/knowledges/search"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 500:
+          throw new InternalServerError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new CngApiError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(
+      _response.error,
+      _response.rawResponse,
+      "GET",
+      "/api/harness/knowledges/search"
+    );
+  }
+  /**
+   * @param {HarnessKnowledgesClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.harnessKnowledges.getHarnessKnowledgesConnectome()
+   */
+  getHarnessKnowledgesConnectome(requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getHarnessKnowledgesConnectome(requestOptions));
+  }
+  async __getHarnessKnowledgesConnectome(requestOptions) {
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/knowledges/connectome"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      throw new CngApiError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body,
+        rawResponse: _response.rawResponse
+      });
+    }
+    return handleNonStatusCodeError(
+      _response.error,
+      _response.rawResponse,
+      "GET",
+      "/api/harness/knowledges/connectome"
+    );
+  }
+  /**
+   * @param {HarnessKnowledgesClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.harnessKnowledges.getHarnessKnowledgesBrain()
+   */
+  getHarnessKnowledgesBrain(requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getHarnessKnowledgesBrain(requestOptions));
+  }
+  async __getHarnessKnowledgesBrain(requestOptions) {
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/knowledges/brain"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      throw new CngApiError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body,
+        rawResponse: _response.rawResponse
+      });
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/harness/knowledges/brain");
+  }
+  /**
+   * Returns the full subskill index for agent discovery. Use search for semantic lookup, or filesystem/read for content.
+   *
+   * @param {HarnessKnowledgesClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.harnessKnowledges.listHarnessKnowledgesSubskills()
+   */
+  listHarnessKnowledgesSubskills(requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__listHarnessKnowledgesSubskills(requestOptions));
+  }
+  async __listHarnessKnowledgesSubskills(requestOptions) {
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/knowledges/subskills"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      throw new CngApiError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body,
+        rawResponse: _response.rawResponse
+      });
+    }
+    return handleNonStatusCodeError(
+      _response.error,
+      _response.rawResponse,
+      "GET",
+      "/api/harness/knowledges/subskills"
+    );
+  }
+  /**
+   * @param {HarnessKnowledgesClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.harnessKnowledges.getHarnessKnowledgesInstallScript()
+   */
+  getHarnessKnowledgesInstallScript(requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getHarnessKnowledgesInstallScript(requestOptions));
+  }
+  async __getHarnessKnowledgesInstallScript(requestOptions) {
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/knowledges/install.sh"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      responseType: "text",
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      throw new CngApiError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body,
+        rawResponse: _response.rawResponse
+      });
+    }
+    return handleNonStatusCodeError(
+      _response.error,
+      _response.rawResponse,
+      "GET",
+      "/api/harness/knowledges/install.sh"
+    );
+  }
+  /**
+   * @param {HarnessKnowledgesClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.harnessKnowledges.getHarnessKnowledgesInstallPowerShell()
+   */
+  getHarnessKnowledgesInstallPowerShell(requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getHarnessKnowledgesInstallPowerShell(requestOptions));
+  }
+  async __getHarnessKnowledgesInstallPowerShell(requestOptions) {
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/knowledges/install.ps1"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      responseType: "text",
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      throw new CngApiError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body,
+        rawResponse: _response.rawResponse
+      });
+    }
+    return handleNonStatusCodeError(
+      _response.error,
+      _response.rawResponse,
+      "GET",
+      "/api/harness/knowledges/install.ps1"
+    );
+  }
+};
+
+// ../../packages/client/src/generated/api/resources/llm/client/Client.ts
+var LlmClient = class {
+  _options;
+  constructor(options = {}) {
+    this._options = normalizeClientOptions(options);
+  }
+  /**
+   * @param {LlmClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.llm.getLlmHealth()
+   */
+  getLlmHealth(requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getLlmHealth(requestOptions));
+  }
+  async __getLlmHealth(requestOptions) {
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/llm/health"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      throw new CngApiError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body,
+        rawResponse: _response.rawResponse
+      });
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/llm/health");
+  }
+  createLlmChat(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__createLlmChat(request, requestOptions));
+  }
+  async __createLlmChat(request, requestOptions) {
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/llm/chat"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: request,
+      responseType: "sse",
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: new Stream({
+          stream: _response.body,
+          parse: (data) => data,
+          signal: requestOptions?.abortSignal,
+          eventShape: {
+            type: "sse"
+          }
+        }),
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        default:
+          throw new CngApiError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/api/llm/chat");
+  }
+};
+
+// ../../packages/client/src/generated/api/resources/polar/client/Client.ts
+var PolarClient = class {
+  _options;
+  constructor(options = {}) {
+    this._options = normalizeClientOptions(options);
+  }
+  /**
+   * @param {PolarClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link CngApi.BadGatewayError}
+   * @throws {@link CngApi.ServiceUnavailableError}
+   *
+   * @example
+   *     await client.polar.createHarnessPolarCheckout()
+   */
+  createHarnessPolarCheckout(requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__createHarnessPolarCheckout(requestOptions));
+  }
+  async __createHarnessPolarCheckout(requestOptions) {
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/polar/harness/checkout"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: void 0, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 502:
+          throw new BadGatewayError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        case 503:
+          throw new ServiceUnavailableError(_response.error.body, _response.rawResponse);
+        default:
+          throw new CngApiError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/polar/harness/checkout");
+  }
+};
+
+// ../../packages/client/src/generated/api/resources/system/client/Client.ts
+var SystemClient = class {
+  _options;
+  constructor(options = {}) {
+    this._options = normalizeClientOptions(options);
+  }
+  /**
+   * @param {SystemClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.system.getHealth()
+   */
+  getHealth(requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getHealth(requestOptions));
+  }
+  async __getHealth(requestOptions) {
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/health"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      throw new CngApiError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body,
+        rawResponse: _response.rawResponse
+      });
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/health");
+  }
+};
+
+// ../../packages/client/src/generated/api/resources/telemetry/client/Client.ts
+var TelemetryClient = class {
+  _options;
+  constructor(options = {}) {
+    this._options = normalizeClientOptions(options);
+  }
+  /**
+   * @param {CngApi.NavigationEventRequest} request
+   * @param {TelemetryClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link CngApi.BadRequestError}
+   *
+   * @example
+   *     await client.telemetry.createNavigationEvent({
+   *         url: "url",
+   *         pathname: "pathname",
+   *         timestamp: "2024-01-15T09:30:00Z"
+   *     })
+   */
+  createNavigationEvent(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__createNavigationEvent(request, requestOptions));
+  }
+  async __createNavigationEvent(request, requestOptions) {
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/navigation-events"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: request,
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        default:
+          throw new CngApiError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/api/navigation-events");
+  }
+};
+
+// ../../packages/client/src/generated/Client.ts
+var CngApiClient = class {
+  _options;
+  _system;
+  _auth;
+  _harnessKnowledges;
+  _harnessFilesystem;
+  _harnessInternalKnowledges;
+  _polar;
+  _telemetry;
+  _llm;
+  constructor(options = {}) {
+    this._options = normalizeClientOptions(options);
+  }
+  get system() {
+    return this._system ??= new SystemClient(this._options);
+  }
+  get auth() {
+    return this._auth ??= new AuthClient(this._options);
+  }
+  get harnessKnowledges() {
+    return this._harnessKnowledges ??= new HarnessKnowledgesClient(this._options);
+  }
+  get harnessFilesystem() {
+    return this._harnessFilesystem ??= new HarnessFilesystemClient(this._options);
+  }
+  get harnessInternalKnowledges() {
+    return this._harnessInternalKnowledges ??= new HarnessInternalKnowledgesClient(this._options);
+  }
+  get polar() {
+    return this._polar ??= new PolarClient(this._options);
+  }
+  get telemetry() {
+    return this._telemetry ??= new TelemetryClient(this._options);
+  }
+  get llm() {
+    return this._llm ??= new LlmClient(this._options);
+  }
+  /**
+   * Make a passthrough request using the SDK's configured auth, retry, logging, etc.
+   * This is useful for making requests to endpoints not yet supported in the SDK.
+   * The input can be a URL string, URL object, or Request object. Relative paths are resolved against the configured base URL.
+   *
+   * @param {Request | string | URL} input - The URL, path, or Request object.
+   * @param {RequestInit} init - Standard fetch RequestInit options.
+   * @param {core.PassthroughRequest.RequestOptions} requestOptions - Per-request overrides (timeout, retries, headers, abort signal).
+   * @returns {Promise<Response>} A standard Response object.
+   */
+  async fetch(input, init, requestOptions) {
+    return makePassthroughRequest(
+      input,
+      init,
+      {
+        baseUrl: this._options.baseUrl ?? this._options.environment,
+        headers: this._options.headers,
+        timeoutInSeconds: this._options.timeoutInSeconds,
+        maxRetries: this._options.maxRetries,
+        fetch: this._options.fetch,
+        logging: this._options.logging
+      },
+      requestOptions
+    );
+  }
+};
+
+// ../../packages/client/src/generated/core/logging/exports.ts
+var logging;
+((logging2) => {
+  logging2.LogLevel = LogLevel;
+  logging2.ConsoleLogger = ConsoleLogger;
+})(logging || (logging = {}));
+
+// src/api.ts
+function createCngApiClient(options) {
+  return new CngApiClient({
+    baseUrl: resolveApiBaseUrl(options),
+    timeoutInSeconds: 15,
+    maxRetries: 1
+  });
+}
+async function readBackendHealth(options) {
+  try {
+    const client = createCngApiClient(options);
+    const health = await client.system.getHealth();
+    return {
+      ok: true,
+      service: health.service
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      message: error instanceof Error ? error.message : "unknown error"
+    };
+  }
+}
+
+// src/browser.ts
+import { spawn } from "child_process";
+import process2 from "process";
+async function openBrowserUrl(url) {
+  const command = browserOpenCommand(url);
+  return await new Promise((resolve, reject) => {
+    const childProcess = spawn(command.command, command.args, {
+      detached: true,
+      stdio: "ignore"
+    });
+    childProcess.on("error", (error) => {
+      if (error.code === "ENOENT") {
+        resolve(false);
+        return;
+      }
+      reject(error);
+    });
+    childProcess.on("spawn", () => {
+      childProcess.unref();
+      resolve(true);
+    });
+  });
+}
+function browserOpenCommand(url) {
+  if (process2.platform === "darwin") {
+    return { command: "open", args: [url] };
+  }
+  if (process2.platform === "win32") {
+    return { command: "cmd", args: ["/c", "start", "", url] };
+  }
+  return { command: "xdg-open", args: [url] };
+}
+
+// src/scrub/masker.ts
+import fs from "fs/promises";
+import path from "path";
+async function scrubFindingsInline(targetPath, findings) {
+  const target = await resolveScrubTarget(targetPath);
+  const findingsByFile = groupFindingsBySafePath(target, findings);
+  let filesChanged = 0;
+  let replacements = 0;
+  for (const [absolutePath, fileFindings] of findingsByFile.safeFindingsByPath) {
+    const originalContent = await fs.readFile(absolutePath, "utf8");
+    let scrubbedContent = originalContent;
+    let fileReplacements = 0;
+    for (const finding of fileFindings) {
+      const placeholder = formatSecretPlaceholder(finding);
+      const nextContent = scrubbedContent.split(finding.rawSecret).join(placeholder);
+      if (nextContent !== scrubbedContent) {
+        fileReplacements += countOccurrences(scrubbedContent, finding.rawSecret);
+        scrubbedContent = nextContent;
+      }
+    }
+    if (scrubbedContent !== originalContent) {
+      await fs.writeFile(absolutePath, scrubbedContent);
+      filesChanged += 1;
+      replacements += fileReplacements;
+    }
+  }
+  return {
+    filesChanged,
+    replacements,
+    skippedFindings: findingsByFile.skippedFindings
+  };
+}
+function formatSecretPlaceholder(finding) {
+  return `[CNGKIT_SECRET:${sanitizePlaceholderPart(finding.detectorName)}:${finding.verified ? "verified" : "unverified"}]`;
+}
+function groupFindingsBySafePath(target, findings) {
+  const safeFindingsByPath = /* @__PURE__ */ new Map();
+  let skippedFindings = 0;
+  for (const finding of findings) {
+    const absolutePath = resolveSafeFindingPath(target, finding.filePath);
+    if (!absolutePath) {
+      skippedFindings += 1;
+      continue;
+    }
+    const fileFindings = safeFindingsByPath.get(absolutePath) ?? [];
+    fileFindings.push(finding);
+    safeFindingsByPath.set(absolutePath, fileFindings);
+  }
+  return { safeFindingsByPath, skippedFindings };
+}
+async function resolveScrubTarget(targetPath) {
+  const absoluteTargetPath = path.resolve(targetPath);
+  const stat = await fs.stat(absoluteTargetPath);
+  if (stat.isFile()) {
+    return {
+      rootDir: path.dirname(absoluteTargetPath),
+      allowedFilePath: absoluteTargetPath
+    };
+  }
+  return {
+    rootDir: absoluteTargetPath
+  };
+}
+function resolveSafeFindingPath(target, findingFilePath) {
+  const absolutePath = path.isAbsolute(findingFilePath) ? path.resolve(findingFilePath) : path.resolve(target.rootDir, findingFilePath);
+  if (target.allowedFilePath) {
+    return absolutePath === target.allowedFilePath ? absolutePath : void 0;
+  }
+  const normalizedRoot = `${path.resolve(target.rootDir)}${path.sep}`;
+  if (absolutePath === path.resolve(target.rootDir) || absolutePath.startsWith(normalizedRoot)) {
+    return absolutePath;
+  }
+  return void 0;
+}
+function countOccurrences(value, search) {
+  if (!search) {
+    return 0;
+  }
+  return value.split(search).length - 1;
+}
+function sanitizePlaceholderPart(value) {
+  return value.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "Unknown";
+}
+
+// src/scrub/trufflehog.ts
+import { spawn as spawn2 } from "child_process";
+import path2 from "path";
+
+// src/scrub/findings.ts
+function parseTruffleHogJsonLines(output) {
+  const findings = [];
+  for (const line of output.split(/\r?\n/)) {
+    const trimmedLine = line.trim();
+    if (!trimmedLine.startsWith("{")) {
+      continue;
+    }
+    const parsedLine = parseJsonRecord(trimmedLine);
+    if (!parsedLine) {
+      continue;
+    }
+    const finding = parseTruffleHogFinding(parsedLine);
+    if (finding) {
+      findings.push(finding);
+    }
+  }
+  return findings;
+}
+function parseTruffleHogFinding(finding) {
+  const rawSecret = readString(finding.Raw) || readString(finding.RawV2);
+  const filePath = readFilesystemFilePath(finding);
+  if (!rawSecret || !filePath) {
+    return void 0;
+  }
+  return {
+    detectorName: readString(finding.DetectorName) || "Unknown",
+    filePath,
+    line: readFilesystemLine(finding),
+    rawSecret,
+    redactedSecret: readString(finding.Redacted) || "",
+    verified: finding.Verified === true
+  };
+}
+function readFilesystemFilePath(finding) {
+  const filesystem = readFilesystemMetadata(finding);
+  if (!filesystem) {
+    return void 0;
+  }
+  return readString(filesystem.file) || readString(filesystem.path);
+}
+function readFilesystemLine(finding) {
+  const filesystem = readFilesystemMetadata(finding);
+  if (!filesystem) {
+    return void 0;
+  }
+  return typeof filesystem.line === "number" ? filesystem.line : void 0;
+}
+function readFilesystemMetadata(finding) {
+  const sourceMetadata = readRecord(finding.SourceMetadata);
+  const data = readRecord(sourceMetadata?.Data);
+  return readRecord(data?.Filesystem);
+}
+function parseJsonRecord(line) {
+  try {
+    return readRecord(JSON.parse(line));
+  } catch {
+    return void 0;
+  }
+}
+function isJsonRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function readRecord(value) {
+  return isJsonRecord(value) ? value : void 0;
+}
+function readString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+
+// src/scrub/trufflehog.ts
+async function scanFilesystemWithTruffleHog(targetPath, options) {
+  const absoluteTargetPath = path2.resolve(options.cwd, targetPath);
+  const { stdout } = await runTruffleHog([
+    "filesystem",
+    absoluteTargetPath,
+    "--json",
+    "--no-update",
+    "--force-skip-binaries",
+    "--force-skip-archives"
+  ]);
+  return parseTruffleHogJsonLines(stdout);
+}
+function runTruffleHog(args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2("trufflehog", args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    child.stdout.on("data", (chunk) => {
+      stdoutChunks.push(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderrChunks.push(chunk);
+    });
+    child.on("error", (error) => {
+      if (error.code === "ENOENT") {
+        reject(
+          new Error(
+            "TruffleHog is not installed. Install it with `brew install trufflehog` or see https://github.com/trufflesecurity/trufflehog."
+          )
+        );
+        return;
+      }
+      reject(error);
+    });
+    child.on("close", (exitCode) => {
+      const stdout = Buffer.concat(stdoutChunks).toString("utf8");
+      const stderr = Buffer.concat(stderrChunks).toString("utf8");
+      if (exitCode && exitCode !== 0) {
+        reject(new Error(`TruffleHog scan failed with exit code ${exitCode}: ${stderr.trim()}`));
+        return;
+      }
+      resolve({ stdout, stderr });
+    });
+  });
+}
+
+// src/sync/client.ts
+import process3 from "process";
+import chokidar from "chokidar";
+import WebSocket from "ws";
+
+// src/sync/files.ts
+import fs2 from "fs/promises";
+import path4 from "path";
+
+// src/sync/paths.ts
+import { execFile } from "child_process";
+import path3 from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function resolveRepoContext(cwd) {
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], {
+      cwd
+    });
+    return { rootDir: path3.resolve(stdout.trim()) };
+  } catch {
+    return { rootDir: path3.resolve(cwd) };
+  }
+}
+function toRepoRelativePath(rootDir, absolutePath) {
+  const relativePath = path3.relative(rootDir, absolutePath);
+  if (!relativePath || relativePath.startsWith("..") || path3.isAbsolute(relativePath)) {
+    return void 0;
+  }
+  return relativePath.split(path3.sep).join("/");
+}
+function resolveRepoPath(rootDir, relativePath) {
+  if (!isSafeRelativePath(relativePath)) {
+    return void 0;
+  }
+  const absolutePath = path3.resolve(rootDir, relativePath);
+  const normalizedRoot = `${path3.resolve(rootDir)}${path3.sep}`;
+  if (absolutePath !== path3.resolve(rootDir) && !absolutePath.startsWith(normalizedRoot)) {
+    return void 0;
+  }
+  return absolutePath;
+}
+function isSafeRelativePath(relativePath) {
+  if (!relativePath || relativePath.startsWith("/") || relativePath.includes("\0")) {
+    return false;
+  }
+  const normalizedParts = relativePath.split(/[\\/]+/).filter(Boolean);
+  if (normalizedParts.includes("..")) {
+    return false;
+  }
+  return normalizedParts[0] !== ".git";
+}
+async function shouldSyncRelativePath(context, relativePath) {
+  if (!isSafeRelativePath(relativePath)) {
+    return false;
+  }
+  try {
+    await execFileAsync("git", ["check-ignore", "--quiet", "--", relativePath], {
+      cwd: context.rootDir
+    });
+    return false;
+  } catch (error) {
+    const exitCode = typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+    return exitCode === 1;
+  }
+}
+
+// src/sync/files.ts
+function createSuppressionTracker(windowMs = 1500) {
+  const suppressedUntilByPath = /* @__PURE__ */ new Map();
+  return {
+    suppress(relativePath) {
+      suppressedUntilByPath.set(relativePath, Date.now() + windowMs);
+    },
+    isSuppressed(relativePath) {
+      const suppressedUntil = suppressedUntilByPath.get(relativePath);
+      if (!suppressedUntil) {
+        return false;
+      }
+      if (suppressedUntil < Date.now()) {
+        suppressedUntilByPath.delete(relativePath);
+        return false;
+      }
+      return true;
+    }
+  };
+}
+async function* collectSnapshotMessages(context, peerId) {
+  yield* collectDirectorySnapshot(context, context.rootDir, peerId);
+}
+async function* collectDirectorySnapshot(context, directoryPath, peerId) {
+  const entries = await fs2.opendir(directoryPath);
+  for await (const entry of entries) {
+    const absolutePath = path4.join(directoryPath, entry.name);
+    const relativePath = toRepoRelativePath(context.rootDir, absolutePath);
+    if (!relativePath || !await shouldSyncRelativePath(context, relativePath)) {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      yield* collectDirectorySnapshot(context, absolutePath, peerId);
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    const [content, stat] = await Promise.all([fs2.readFile(absolutePath), fs2.stat(absolutePath)]);
+    yield {
+      type: "file",
+      peerId,
+      path: relativePath,
+      contentBase64: content.toString("base64"),
+      mtimeMs: stat.mtimeMs,
+      sentAt: Date.now()
+    };
+  }
+}
+async function buildFileMessage(context, peerId, relativePath) {
+  if (!await shouldSyncRelativePath(context, relativePath)) {
+    return void 0;
+  }
+  const absolutePath = resolveRepoPath(context.rootDir, relativePath);
+  if (!absolutePath) {
+    return void 0;
+  }
+  const stat = await fs2.stat(absolutePath);
+  if (!stat.isFile()) {
+    return void 0;
+  }
+  const content = await fs2.readFile(absolutePath);
+  return {
+    type: "file",
+    peerId,
+    path: relativePath,
+    contentBase64: content.toString("base64"),
+    mtimeMs: stat.mtimeMs,
+    sentAt: Date.now()
+  };
+}
+async function applyRemoteMessage(context, message, suppressionTracker) {
+  const absolutePath = resolveRepoPath(context.rootDir, message.path);
+  if (!absolutePath || !await shouldSyncRelativePath(context, message.path)) {
+    return;
+  }
+  suppressionTracker.suppress(message.path);
+  if (message.type === "delete") {
+    await fs2.rm(absolutePath, { force: true });
+    return;
+  }
+  await fs2.mkdir(path4.dirname(absolutePath), { recursive: true });
+  await fs2.writeFile(absolutePath, Buffer.from(message.contentBase64, "base64"));
+}
+
+// src/sync/protocol.ts
+import { z } from "zod";
+var SyncBaseMessageSchema = z.object({
+  peerId: z.string().min(1),
+  sentAt: z.number().finite()
+});
+var SyncHelloMessageSchema = SyncBaseMessageSchema.extend({
+  type: z.literal("hello"),
+  role: z.union([z.literal("share"), z.literal("join")])
+});
+var SyncFileMessageSchema = SyncBaseMessageSchema.extend({
+  type: z.literal("file"),
+  path: z.string().min(1),
+  contentBase64: z.string(),
+  mtimeMs: z.number().finite()
+});
+var SyncDeleteMessageSchema = SyncBaseMessageSchema.extend({
+  type: z.literal("delete"),
+  path: z.string().min(1),
+  mtimeMs: z.number().finite()
+});
+var SyncSnapshotCompleteMessageSchema = SyncBaseMessageSchema.extend({
+  type: z.literal("snapshot-complete"),
+  fileCount: z.number().int().nonnegative()
+});
+var SyncMessageSchema = z.discriminatedUnion("type", [
+  SyncHelloMessageSchema,
+  SyncFileMessageSchema,
+  SyncDeleteMessageSchema,
+  SyncSnapshotCompleteMessageSchema
+]);
+function encodeSyncMessage(message) {
+  return JSON.stringify(SyncMessageSchema.parse(message));
+}
+function decodeSyncMessage(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  try {
+    return SyncMessageSchema.parse(JSON.parse(value));
+  } catch {
+    return void 0;
+  }
+}
+
+// src/sync/client.ts
+function createSyncWebSocketUrl(apiBaseUrl, roomCode) {
+  const url = new URL(apiBaseUrl);
+  url.protocol = url.protocol === "http:" ? "ws:" : "wss:";
+  url.pathname = `/api/cng/sync/${encodeURIComponent(roomCode)}`;
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+}
+function sendMessage(socket, message) {
+  if (socket.readyState === WebSocket.OPEN) {
+    socket.send(encodeSyncMessage(message));
+  }
+}
+async function startSyncSession(options) {
+  const repoContext = await resolveRepoContext(options.cwd);
+  const peerId = createPeerId();
+  const suppressionTracker = createSuppressionTracker();
+  const webSocketUrl = createSyncWebSocketUrl(options.apiBaseUrl, options.roomCode);
+  const socket = new WebSocket(webSocketUrl);
+  options.output.info(`Room: ${options.roomCode}`);
+  options.output.info(`Repo: ${repoContext.rootDir}`);
+  options.output.info(`Peer: ${peerId}`);
+  const watcherContext = {
+    repoContext,
+    socket,
+    peerId,
+    suppressionTracker,
+    output: options.output
+  };
+  const watcher = createRepoWatcher(watcherContext);
+  socket.on("open", () => {
+    sendMessage(socket, {
+      type: "hello",
+      peerId,
+      role: options.role,
+      sentAt: Date.now()
+    });
+    void sendInitialSnapshot(socket, repoContext, peerId, options.output);
+  });
+  socket.on("message", (data) => {
+    void handleRemoteMessage({
+      data,
+      repoContext,
+      peerId,
+      suppressionTracker,
+      output: options.output
+    });
+  });
+  await waitForSessionClose(socket, watcher);
+}
+function createRepoWatcher(context) {
+  const watcher = chokidar.watch(context.repoContext.rootDir, {
+    ignoreInitial: true,
+    ignored: (candidatePath) => {
+      const relativePath = toRepoRelativePath(context.repoContext.rootDir, candidatePath);
+      return relativePath?.split("/").includes(".git") ?? false;
+    }
+  });
+  watcher.on("add", (absolutePath) => {
+    void sendLocalFileChange(context, absolutePath);
+  });
+  watcher.on("change", (absolutePath) => {
+    void sendLocalFileChange(context, absolutePath);
+  });
+  watcher.on("unlink", (absolutePath) => {
+    void sendLocalDelete(context, absolutePath);
+  });
+  return watcher;
+}
+async function sendInitialSnapshot(socket, repoContext, peerId, output) {
+  let fileCount = 0;
+  for await (const message of collectSnapshotMessages(repoContext, peerId)) {
+    sendMessage(socket, message);
+    fileCount += 1;
+  }
+  sendMessage(socket, {
+    type: "snapshot-complete",
+    peerId,
+    sentAt: Date.now(),
+    fileCount
+  });
+  output.info(`sent snapshot ${fileCount} files`);
+}
+async function sendLocalFileChange(context, absolutePath) {
+  const relativePath = toRepoRelativePath(context.repoContext.rootDir, absolutePath);
+  if (!relativePath || context.suppressionTracker.isSuppressed(relativePath)) {
+    return;
+  }
+  const message = await buildFileMessage(context.repoContext, context.peerId, relativePath);
+  if (!message) {
+    return;
+  }
+  sendMessage(context.socket, message);
+  context.output.info(`sent file ${relativePath}`);
+}
+async function sendLocalDelete(context, absolutePath) {
+  const relativePath = toRepoRelativePath(context.repoContext.rootDir, absolutePath);
+  if (!relativePath || context.suppressionTracker.isSuppressed(relativePath)) {
+    return;
+  }
+  if (!await shouldSyncRelativePath(context.repoContext, relativePath)) {
+    return;
+  }
+  sendMessage(context.socket, {
+    type: "delete",
+    peerId: context.peerId,
+    path: relativePath,
+    mtimeMs: Date.now(),
+    sentAt: Date.now()
+  });
+  context.output.info(`sent delete ${relativePath}`);
+}
+async function handleRemoteMessage(options) {
+  const decodedMessage = decodeSyncMessage(options.data.toString());
+  if (!decodedMessage || decodedMessage.peerId === options.peerId) {
+    return;
+  }
+  if (decodedMessage.type === "hello") {
+    options.output.info(`peer joined ${decodedMessage.peerId}`);
+    return;
+  }
+  if (decodedMessage.type === "snapshot-complete") {
+    options.output.info(`peer snapshot complete ${decodedMessage.fileCount} files`);
+    return;
+  }
+  await applyRemoteMessage(options.repoContext, decodedMessage, options.suppressionTracker);
+  options.output.info(`applied ${decodedMessage.type} ${decodedMessage.path}`);
+}
+async function waitForSessionClose(socket, watcher) {
+  await new Promise((resolve, reject) => {
+    let settled = false;
+    const closeSession = async () => {
+      await watcher.close();
+      if (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING) {
+        socket.close();
+      }
+    };
+    const finish = async () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      process3.off("SIGINT", onSignal);
+      process3.off("SIGTERM", onSignal);
+      await closeSession();
+      resolve();
+    };
+    const onSignal = () => {
+      void finish();
+    };
+    socket.on("error", async (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      process3.off("SIGINT", onSignal);
+      process3.off("SIGTERM", onSignal);
+      await closeSession();
+      reject(error);
+    });
+    socket.on("close", () => {
+      void finish();
+    });
+    process3.on("SIGINT", onSignal);
+    process3.on("SIGTERM", onSignal);
+  });
+}
+
+// src/transcripts/reader.ts
+import { promises as fs3 } from "fs";
+import os from "os";
+import path5 from "path";
+var TranscriptSourceNames = ["codex", "claude"];
+async function listTranscriptRecords(options) {
+  const files = await discoverTranscriptFiles(options.source);
+  const records = await Promise.all(files.slice(0, options.limit).map(readTranscriptRecord));
+  return records;
+}
+async function readTranscriptEntries(options) {
+  const file = await resolveTranscriptFile(options.source, options.target);
+  const entries = await readEntriesFromFile(file, options.includeInternal);
+  return entries.slice(Math.max(0, entries.length - options.limit));
+}
+async function grepTranscriptEntries(options) {
+  const files = await discoverTranscriptFiles(options.source);
+  const normalizedQuery = options.query.toLowerCase();
+  const matches = [];
+  for (const file of files.slice(0, options.fileLimit)) {
+    const entries = await readEntriesFromFile(file, options.includeInternal);
+    for (const entry of entries) {
+      if (entry.text.toLowerCase().includes(normalizedQuery)) {
+        matches.push(entry);
+      }
+      if (matches.length >= options.limit) {
+        return matches;
+      }
+    }
+  }
+  return matches;
+}
+async function discoverTranscriptFiles(source) {
+  const sources = source === "all" ? TranscriptSourceNames : [source];
+  const records = await Promise.all(sources.flatMap((sourceName) => sourceRoots(sourceName)));
+  return records.flat().sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+function sourceRoots(source) {
+  if (source === "codex") {
+    return [
+      discoverJsonlFiles("codex", expandHome("~/.codex/sessions")),
+      discoverJsonlFiles("codex", expandHome("~/.codex/archived_sessions"))
+    ];
+  }
+  return [
+    discoverJsonlFiles("claude", expandHome("~/.claude/projects")),
+    discoverJsonlFiles("claude", expandHome("~/.claude/history.jsonl"))
+  ];
+}
+async function discoverJsonlFiles(source, rootPath) {
+  const stat = await statIfExists(rootPath);
+  if (!stat) {
+    return [];
+  }
+  if (stat.isFile()) {
+    return [await recordFromPath(source, rootPath, stat.mtime)];
+  }
+  const records = [];
+  const entries = await fs3.readdir(rootPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const entryPath = path5.join(rootPath, entry.name);
+    if (entry.isDirectory()) {
+      records.push(...await discoverJsonlFiles(source, entryPath));
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+      const entryStat = await fs3.stat(entryPath);
+      records.push(await recordFromPath(source, entryPath, entryStat.mtime));
+    }
+  }
+  return records;
+}
+async function recordFromPath(source, filePath, mtime) {
+  return {
+    source,
+    filePath,
+    updatedAt: mtime.toISOString()
+  };
+}
+async function readTranscriptRecord(record) {
+  const metadata = await readMetadataFromFile(record.source, record.filePath);
+  return {
+    ...record,
+    ...metadata
+  };
+}
+async function readMetadataFromFile(source, filePath) {
+  const lines = await readJsonlLines(filePath, 80);
+  for (const line of lines) {
+    const parsed = parseJsonObject(line);
+    if (!parsed) {
+      continue;
+    }
+    if (source === "codex") {
+      const payload = asObject(parsed.payload);
+      if (parsed.type === "session_meta" && payload) {
+        return {
+          cwd: readString2(payload.cwd),
+          sessionId: readString2(payload.session_id) ?? readString2(payload.id),
+          title: readString2(payload.cwd)
+        };
+      }
+    }
+    if (source === "claude") {
+      const message = asObject(parsed.message);
+      const role = readString2(message?.role) ?? readString2(parsed.type);
+      const content = message ? extractContentText(message.content) : readString2(parsed.content);
+      if (content && (role === "user" || role === "assistant")) {
+        return {
+          cwd: readString2(parsed.cwd) ?? readString2(parsed.project),
+          sessionId: readString2(parsed.sessionId),
+          title: truncateSingleLine(content, 120)
+        };
+      }
+    }
+  }
+  return {
+    sessionId: path5.basename(filePath, ".jsonl")
+  };
+}
+async function resolveTranscriptFile(source, target) {
+  const expandedTarget = expandHome(target);
+  const directStat = await statIfExists(expandedTarget);
+  if (directStat?.isFile()) {
+    return recordFromPath(detectSourceFromPath(expandedTarget), expandedTarget, directStat.mtime);
+  }
+  const files = await discoverTranscriptFiles(source);
+  const normalizedTarget = target.toLowerCase();
+  const match = files.find((file) => {
+    return file.filePath.toLowerCase().includes(normalizedTarget) || file.sessionId?.toLowerCase().includes(normalizedTarget);
+  });
+  if (!match) {
+    throw new Error(`No transcript matched "${target}". Run cngkit transcripts list first.`);
+  }
+  return match;
+}
+async function readEntriesFromFile(record, includeInternal) {
+  const content = await fs3.readFile(record.filePath, "utf8");
+  const entries = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) {
+      continue;
+    }
+    const parsed = parseJsonObject(line);
+    if (!parsed) {
+      continue;
+    }
+    const entry = record.source === "codex" ? parseCodexEntry(record, parsed, includeInternal) : parseClaudeEntry(record, parsed, includeInternal);
+    if (entry) {
+      entries.push(entry);
+    }
+  }
+  return entries;
+}
+function parseCodexEntry(record, parsed, includeInternal) {
+  const payload = asObject(parsed.payload);
+  if (!payload || parsed.type !== "response_item") {
+    return void 0;
+  }
+  const role = readString2(payload.role);
+  if (!role || !includeInternal && role !== "user" && role !== "assistant") {
+    return void 0;
+  }
+  const text = extractContentText(payload.content);
+  if (!text) {
+    return void 0;
+  }
+  return {
+    source: record.source,
+    filePath: record.filePath,
+    timestamp: readString2(parsed.timestamp),
+    role,
+    text
+  };
+}
+function parseClaudeEntry(record, parsed, includeInternal) {
+  const message = asObject(parsed.message);
+  const role = readString2(message?.role) ?? readString2(parsed.type);
+  if (!role || !includeInternal && role !== "user" && role !== "assistant") {
+    return void 0;
+  }
+  const text = message ? extractContentText(message.content) : readString2(parsed.content);
+  if (!text) {
+    return void 0;
+  }
+  return {
+    source: record.source,
+    filePath: record.filePath,
+    timestamp: readString2(parsed.timestamp),
+    role,
+    text
+  };
+}
+function extractContentText(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const parts = value.flatMap((item) => {
+    if (typeof item === "string") {
+      return [item];
+    }
+    const objectItem = asObject(item);
+    if (!objectItem) {
+      return [];
+    }
+    return [readString2(objectItem.text), readString2(objectItem.content)].filter(
+      (part) => Boolean(part)
+    );
+  });
+  return parts.length > 0 ? parts.join("\n") : void 0;
+}
+async function readJsonlLines(filePath, limit) {
+  const content = await fs3.readFile(filePath, "utf8");
+  return content.split("\n").filter(Boolean).slice(0, limit);
+}
+async function statIfExists(filePath) {
+  try {
+    return await fs3.stat(filePath);
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+}
+function parseJsonObject(line) {
+  try {
+    const parsed = JSON.parse(line);
+    return asObject(parsed);
+  } catch {
+    return void 0;
+  }
+}
+function asObject(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return void 0;
+}
+function readString2(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+function expandHome(value) {
+  if (value === "~") {
+    return os.homedir();
+  }
+  if (value.startsWith("~/")) {
+    return path5.join(os.homedir(), value.slice(2));
+  }
+  return value;
+}
+function detectSourceFromPath(filePath) {
+  return filePath.includes(`${path5.sep}.claude${path5.sep}`) ? "claude" : "codex";
+}
+function truncateSingleLine(value, maxLength) {
+  const line = value.replace(/\s+/g, " ").trim();
+  return line.length > maxLength ? `${line.slice(0, maxLength - 1)}...` : line;
+}
+
+// src/command-actions.ts
+async function runLoginCommand(options, output) {
+  const loginUrl = new URL("/login", resolveApiBaseUrl(options));
+  const loginUrlString = loginUrl.toString();
+  output.info(`Opening ${loginUrlString}`);
+  const didOpenBrowser = await openBrowserUrl(loginUrlString);
+  if (!didOpenBrowser) {
+    output.info(`No browser opener found. Open this URL manually: ${loginUrlString}`);
+  }
+}
+async function runShareCommand(roomCode, options, output) {
+  const syncRoomCode = roomCode ?? createRoomCode();
+  output.info(`Share code: ${syncRoomCode}`);
+  await printBackendStatus(options, output);
+  await runSyncSession("share", syncRoomCode, options, output);
+}
+async function runJoinCommand(roomCode, options, output) {
+  if (!roomCode) {
+    throw new Error("Missing room code. Usage: cngkit coderoom join <room-code>");
+  }
+  await printBackendStatus(options, output);
+  await runSyncSession("join", roomCode, options, output);
+}
+async function runScrubCommand(targetPath, options, output, dependencies) {
+  const scrubTargetPath = targetPath ?? ".";
+  const scanFilesystem = dependencies?.scanFilesystem ?? ((scanTargetPath) => scanFilesystemWithTruffleHog(scanTargetPath, {
+    cwd: process4.cwd()
+  }));
+  const findings = await scanFilesystem(scrubTargetPath);
+  if (findings.length === 0) {
+    output.info("No secrets found.");
+    return;
+  }
+  output.info(formatScrubReport(findings));
+  if (!options.yes) {
+    if (options.mask) {
+      throw new Error("Inline scrubbing rewrites files. Re-run with --yes to continue.");
+    }
+    output.info("Report only. Re-run with --yes to scrub files inline.");
+    return;
+  }
+  const result = await scrubFindingsInline(scrubTargetPath, findings);
+  output.info(
+    `Masked ${result.replacements} secret${result.replacements === 1 ? "" : "s"} in ${result.filesChanged} file${result.filesChanged === 1 ? "" : "s"}.`
+  );
+  if (result.skippedFindings > 0) {
+    output.info(`Skipped ${result.skippedFindings} finding(s) outside the scrub root.`);
+  }
+}
+async function runTranscriptCommand(args, options, output) {
+  const [action = "list", ...actionArgs] = args ?? [];
+  const source = normalizeTranscriptSource(options.source);
+  const limit = coerceLimit(options.limit, action === "list" ? 12 : 80, 500);
+  const includeInternal = options.includeInternal === true;
+  switch (action) {
+    case "help":
+      output.info(formatCngkitHelp("transcripts"));
+      return;
+    case "list": {
+      const records = await listTranscriptRecords({ source, limit });
+      if (options.json) {
+        output.info(formatJson({ records }));
+        return;
+      }
+      output.info(formatTranscriptRecords(records));
+      return;
+    }
+    case "read": {
+      const target = actionArgs[0];
+      if (!target) {
+        throw new Error("Missing transcript target. Usage: cngkit transcripts read <path-or-id>");
+      }
+      const entries = await readTranscriptEntries({
+        source,
+        target,
+        limit,
+        includeInternal
+      });
+      if (options.json) {
+        output.info(formatJson({ entries }));
+        return;
+      }
+      output.info(formatTranscriptEntries(entries));
+      return;
+    }
+    case "grep": {
+      const query = optionalJoinedArgument(actionArgs);
+      if (!query) {
+        throw new Error("Missing query. Usage: cngkit transcripts grep <query>");
+      }
+      const entries = await grepTranscriptEntries({
+        source,
+        query,
+        limit,
+        fileLimit: coerceLimit(options.fileLimit, 60, 5e3),
+        includeInternal
+      });
+      if (options.json) {
+        output.info(formatJson({ entries }));
+        return;
+      }
+      output.info(formatTranscriptEntries(entries));
+      return;
+    }
+    default:
+      throw new Error("Unknown transcripts command. Usage: cngkit transcripts <list|read|grep>");
+  }
+}
+async function runKnowStatusCommand(options, output, dependencies) {
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const response = await api.getCatalog();
+  if (options.json) {
+    output.info(formatJson(response.data));
+    return;
+  }
+  const latestRun = response.data.latestRun;
+  const lines = [
+    `Catalog: ${response.data.name}`,
+    `Files: ${response.data.files}`,
+    `Blobs: ${response.data.blobs}`,
+    `Vectorize: ${response.data.vectorize.index} (${response.data.vectorize.binding})`
+  ];
+  if (latestRun) {
+    lines.push(`Latest run: ${latestRun.status} (${latestRun.id})`);
+    if (latestRun.updated_at) {
+      lines.push(`Updated: ${latestRun.updated_at}`);
+    }
+  } else {
+    lines.push("Latest run: none");
+  }
+  output.info(lines.join("\n"));
+}
+async function runKnowAudiencesCommand(options, output, dependencies) {
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const response = await api.listAudiences();
+  if (options.json) {
+    output.info(formatJson(response.data));
+    return;
+  }
+  const lines = response.data.audiences.flatMap((audience) => [
+    `${audience.id} - ${audience.label}`,
+    `  ${singleLine(audience.help)}`
+  ]);
+  output.info(lines.length > 0 ? lines.join("\n") : "No audiences available.");
+}
+async function runKnowSearchCommand(query, options, output, dependencies) {
+  if (!query) {
+    throw new Error("Missing search query. Usage: cngkit knowledges search <query>");
+  }
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const response = await api.search(query, coerceLimit(options.limit, 5));
+  if (options.json) {
+    output.info(formatJson(response.data));
+    return;
+  }
+  const lines = response.data.results.flatMap((result, index) => [
+    `${index + 1}. ${result.title} (${result.subskillName})`,
+    `   score ${result.score.toFixed(3)} | ${result.path}`,
+    `   ${singleLine(result.description || result.contentPreview)}`
+  ]);
+  output.info(lines.length > 0 ? lines.join("\n") : `No results for "${query}".`);
+}
+async function runKnowListCommand(query, options, output, dependencies) {
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const response = await api.listSubskills();
+  const limit = coerceLimit(options.limit, 25);
+  const normalizedQuery = query?.toLowerCase();
+  const subskills = response.data.subskills.filter((subskill) => {
+    if (!normalizedQuery) {
+      return true;
+    }
+    return [subskill.name, subskill.title, subskill.description, subskill.type].join(" ").toLowerCase().includes(normalizedQuery);
+  }).slice(0, limit);
+  if (options.json) {
+    output.info(formatJson({ subskills, total: subskills.length }));
+    return;
+  }
+  const lines = subskills.flatMap((subskill) => [
+    `${subskill.name} [${subskill.type}]`,
+    `  ${subskill.title} | files ${subskill.fileCount} | rating ${subskill.rating}`,
+    `  ${singleLine(subskill.description)}`
+  ]);
+  output.info(lines.length > 0 ? lines.join("\n") : "No matching subskills.");
+}
+async function runKnowFilesCommand(query, options, output, dependencies) {
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const response = await api.listFiles({
+    query,
+    audience: normalizeAudienceId(options.audience),
+    limit: coerceLimit(options.limit, 25)
+  });
+  if (options.json) {
+    output.info(formatJson(response.data));
+    return;
+  }
+  const lines = response.data.files.map((file) => {
+    const title = file.display_title ?? file.title ?? file.subskill_name ?? "Untitled";
+    return `${file.path}
+  ${title}`;
+  });
+  output.info(lines.length > 0 ? lines.join("\n") : "No matching files.");
+}
+async function runKnowReadCommand(filePath, options, output, dependencies) {
+  if (!filePath) {
+    throw new Error("Missing file_path. Usage: cngkit knowledges read <file_path>");
+  }
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const response = await api.read({
+    filePath: normalizeCatalogPath(filePath),
+    offset: coerceOptionalNumber(options.offset),
+    limit: coerceLimit(options.limit, 200, 2e3)
+  });
+  if (options.json) {
+    output.info(formatJson(response.data));
+    return;
+  }
+  output.info(response.data.content);
+  if (response.data.truncated) {
+    output.info(
+      `[truncated: showing ${response.data.limit} lines from offset ${response.data.offset} of ${response.data.total_lines}]`
+    );
+  }
+}
+async function runKnowGrepCommand(pattern, options, output, dependencies) {
+  if (!pattern) {
+    throw new Error("Missing pattern. Usage: cngkit knowledges grep <pattern>");
+  }
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const limit = options.limit !== void 0 ? coerceOptionalNumber(options.limit) : void 0;
+  const response = await api.grep({
+    pattern,
+    path: normalizeCatalogPath(options.path ?? "/"),
+    include: options.include ?? "*",
+    mode: normalizeGrepMode(options.outputMode),
+    context: coerceLimit(options.context, 0, 20),
+    ignoreCase: options.caseInsensitive === true
+  });
+  if (options.json) {
+    output.info(formatJson(response.data));
+    return;
+  }
+  if (response.data.mode === "files_with_matches") {
+    const files = limit ? response.data.files.slice(0, limit) : response.data.files;
+    output.info(
+      files.length > 0 ? files.join("\n") : `No files matched "${pattern}".`
+    );
+    return;
+  }
+  if (response.data.mode === "count") {
+    const counts = limit ? response.data.counts.slice(0, limit) : response.data.counts;
+    const lines2 = counts.map((count) => `${count.file_path}: ${count.match_count}`);
+    output.info(lines2.length > 0 ? lines2.join("\n") : `No matches for "${pattern}".`);
+    return;
+  }
+  const matches = limit ? response.data.matches.slice(0, limit) : response.data.matches;
+  const lines = matches.flatMap((match) => [
+    `${match.file_path}:${match.line_number}`,
+    ...match.context_before.map((line) => `  ${line}`),
+    `> ${match.line}`,
+    ...match.context_after.map((line) => `  ${line}`)
+  ]);
+  output.info(lines.length > 0 ? lines.join("\n") : `No matches for "${pattern}".`);
+}
+async function runKnowGlobCommand(pattern, options, output, dependencies) {
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const limit = options.limit !== void 0 ? coerceOptionalNumber(options.limit) : void 0;
+  const response = await api.glob({
+    pattern: pattern ?? "**/*.md",
+    path: normalizeCatalogPath(options.path ?? "/")
+  });
+  if (options.json) {
+    output.info(formatJson(response.data));
+    return;
+  }
+  const files = limit ? response.data.files.slice(0, limit) : response.data.files;
+  const wasClientTruncated = limit ? response.data.files.length > limit : false;
+  output.info(files.length > 0 ? files.join("\n") : "No matching files.");
+  if (response.data.truncated || wasClientTruncated) {
+    output.info(`[truncated: ${response.data.total_files} total files]`);
+  }
+}
+async function printBackendStatus(options, output) {
+  const health = await readBackendHealth(options);
+  output.info(health.ok ? `API: ${health.service} ready` : `API: unavailable (${health.message})`);
+}
+async function runSyncSession(role, roomCode, options, output) {
+  await startSyncSession({
+    apiBaseUrl: resolveApiBaseUrl(options),
+    roomCode,
+    role,
+    cwd: process4.cwd(),
+    output
+  });
+}
+function formatScrubReport(findings) {
+  const lines = [`Found ${findings.length} possible secret${findings.length === 1 ? "" : "s"}:`];
+  for (const finding of findings) {
+    const location = finding.line ? `${finding.filePath}:${finding.line}` : finding.filePath;
+    const status = finding.verified ? "verified" : "unverified";
+    lines.push(`- ${location} ${finding.detectorName} ${status}`);
+  }
+  return lines.join("\n");
+}
+function formatTranscriptRecords(records) {
+  if (records.length === 0) {
+    return "No transcript files found.";
+  }
+  return records.map((record, index) => {
+    const title = record.title ? `
+  ${singleLine(record.title)}` : "";
+    const cwd = record.cwd ? `
+  cwd ${record.cwd}` : "";
+    const session = record.sessionId ? `
+  session ${record.sessionId}` : "";
+    return `${index + 1}. ${record.source} ${record.updatedAt}
+  ${record.filePath}${session}${cwd}${title}`;
+  }).join("\n");
+}
+function formatTranscriptEntries(entries) {
+  if (entries.length === 0) {
+    return "No transcript entries found.";
+  }
+  return entries.map((entry) => {
+    const when = entry.timestamp ? ` ${entry.timestamp}` : "";
+    return `[${entry.source}] ${entry.role}${when}
+${entry.text.trim()}`;
+  }).join("\n\n");
+}
+function createKnowledgesApi(options) {
+  const client = createCngApiClient(options);
+  return {
+    getCatalog: () => client.harnessKnowledges.getHarnessKnowledgesCatalog(),
+    listAudiences: () => client.harnessKnowledges.listHarnessKnowledgesAudiences(),
+    search: (query, limit) => client.harnessKnowledges.searchHarnessKnowledges({
+      q: query,
+      limit
+    }),
+    listSubskills: () => client.harnessKnowledges.listHarnessKnowledgesSubskills(),
+    listFiles: ({ query, audience, limit }) => client.harnessKnowledges.listHarnessSubskillAssets({
+      ...query ? { q: query } : {},
+      ...audience ? { audience } : {},
+      limit
+    }),
+    read: ({ filePath, offset, limit }) => client.harnessFilesystem.getHarnessFilesystemRead({
+      file_path: filePath,
+      offset,
+      limit
+    }),
+    grep: ({ pattern, path: path6, include, mode, context, ignoreCase }) => client.harnessFilesystem.getHarnessFilesystemGrep({
+      pattern,
+      path: path6,
+      include,
+      output_mode: mode,
+      context,
+      case_insensitive: ignoreCase ? "true" : void 0
+    }),
+    glob: ({ pattern, path: path6 }) => client.harnessFilesystem.getHarnessFilesystemGlob({
+      pattern,
+      path: path6
+    })
+  };
+}
+function coerceLimit(value, defaultValue, maxValue = 100) {
+  const normalizedValue = coerceOptionalNumber(value);
+  if (normalizedValue === void 0 || Number.isNaN(normalizedValue)) {
+    return defaultValue;
+  }
+  return Math.max(defaultValue === 0 ? 0 : 1, Math.min(maxValue, Math.trunc(normalizedValue)));
+}
+function coerceOptionalNumber(value) {
+  if (value === void 0 || value === "") {
+    return void 0;
+  }
+  return Number(value);
+}
+function normalizeAudienceId(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  switch (value) {
+    case "all":
+    case "operators":
+    case "builders":
+    case "researchers":
+    case "agent-makers":
+      return value;
+    default:
+      throw new Error(
+        `Unknown audience "${value}". Run cngkit knowledges audiences to see supported values.`
+      );
+  }
+}
+function normalizeGrepMode(value) {
+  if (value === void 0) {
+    return "content";
+  }
+  switch (value) {
+    case "content":
+    case "files_with_matches":
+    case "count":
+      return value;
+    default:
+      throw new Error("Unknown grep mode. Use one of: content, files_with_matches, count.");
+  }
+}
+function normalizeTranscriptSource(value) {
+  if (value === void 0) {
+    return "all";
+  }
+  switch (value) {
+    case "all":
+    case "codex":
+    case "claude":
+      return value;
+    default:
+      throw new Error("Unknown transcript source. Use one of: all, codex, claude.");
+  }
+}
+function singleLine(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function formatJson(value) {
+  return JSON.stringify(value, null, 2);
+}
+function optionalJoinedArgument(values) {
+  return values.length > 0 ? values.join(" ") : void 0;
+}
+function normalizeCatalogPath(value) {
+  const trimmed = value.trim();
+  if (trimmed === "/" || trimmed === "") {
+    return "skills";
+  }
+  const relativePath = trimmed.replace(/^\/+/, "");
+  if (relativePath.startsWith("skills/knowledges/")) {
+    return relativePath;
+  }
+  const [firstSegment, ...restSegments] = relativePath.split("/");
+  if (!firstSegment || restSegments.length === 0) {
+    return relativePath;
+  }
+  switch (firstSegment) {
+    case "concepts":
+    case "domains":
+    case "formats":
+    case "languages":
+    case "libraries":
+    case "patterns":
+    case "platforms":
+    case "procedures":
+    case "protocols":
+    case "tools":
+      return `skills/knowledges/subskills/${firstSegment}/${restSegments.join("/")}`;
+    default:
+      return relativePath;
+  }
+}
+
+export {
+  runLoginCommand,
+  runShareCommand,
+  runJoinCommand,
+  runScrubCommand,
+  runTranscriptCommand,
+  runKnowStatusCommand,
+  runKnowAudiencesCommand,
+  runKnowSearchCommand,
+  runKnowListCommand,
+  runKnowFilesCommand,
+  runKnowReadCommand,
+  runKnowGrepCommand,
+  runKnowGlobCommand
+};
+//# sourceMappingURL=chunk-HBBUFPJG.js.map