cngkit 1.1.6 → 1.1.7

package/dist/{chunk-Z3J7PPZB.js → chunk-QEZQGKFX.js}

@@ -1,18 +1,10 @@
 import {
-  createPeerId,
-  createRoomCode,
   resolveApiBaseUrl
-} from "./chunk-F6YQGKLK.js";
-import {
-  formatCngkitHelp
-} from "./chunk-SSRUN6G5.js";
+} from "./chunk-EQEIX7N5.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);
@@ -1821,7 +1813,7 @@ var CngApiEnvironment = {
 };
 
 // ../../packages/client/src/generated/errors/handleNonStatusCodeError.ts
-function handleNonStatusCodeError(error, rawResponse, method, path6) {
+function handleNonStatusCodeError(error, rawResponse, method, path) {
   switch (error.reason) {
     case "non-json":
       throw new CngApiError({
@@ -1835,7 +1827,7 @@ function handleNonStatusCodeError(error, rawResponse, method, path6) {
         rawResponse
       });
     case "timeout":
-      throw new CngApiTimeoutError(`Timeout exceeded when calling ${method} ${path6}.`, {
+      throw new CngApiTimeoutError(`Timeout exceeded when calling ${method} ${path}.`, {
         cause: error.cause
       });
     case "unknown":
@@ -1987,10 +1979,10 @@ var HarnessFilesystemClient = class {
     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 { pattern, path, include, output_mode: outputMode, context, case_insensitive: caseInsensitive } = request;
     const _queryParams = {
       pattern,
-      path: path6,
+      path,
       include,
       output_mode: outputMode != null ? outputMode : void 0,
       context,
@@ -2043,10 +2035,10 @@ var HarnessFilesystemClient = class {
     return HttpResponsePromise.fromPromise(this.__getHarnessFilesystemGlob(request, requestOptions));
   }
   async __getHarnessFilesystemGlob(request, requestOptions) {
-    const { pattern, path: path6 } = request;
+    const { pattern, path } = request;
     const _queryParams = {
       pattern,
-      path: path6
+      path
     };
     const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
     const _response = await fetcher({
@@ -2159,9 +2151,9 @@ var HarnessInternalKnowledgesClient = class {
     return HttpResponsePromise.fromPromise(this.__getHarnessSubskillAssetRawFile(request, requestOptions));
   }
   async __getHarnessSubskillAssetRawFile(request, requestOptions) {
-    const { path: path6, sha256 } = request;
+    const { path, sha256 } = request;
     const _queryParams = {
-      path: path6,
+      path,
       sha256
     };
     const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
@@ -3211,7 +3203,7 @@ var logging;
   logging2.ConsoleLogger = ConsoleLogger;
 })(logging || (logging = {}));
 
-// src/api.ts
+// src/shared/api-client.ts
 function createCngApiClient(options) {
   return new CngApiClient({
     baseUrl: resolveApiBaseUrl(options),
@@ -3235,1351 +3227,8 @@ async function readBackendHealth(options) {
   }
 }
 
-// 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) {
-    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.length > 0 ? `/${restSegments.join("/")}` : ""}`;
-    default:
-      return relativePath;
-  }
-}
-
 export {
-  runLoginCommand,
-  runShareCommand,
-  runJoinCommand,
-  runScrubCommand,
-  runTranscriptCommand,
-  runKnowStatusCommand,
-  runKnowAudiencesCommand,
-  runKnowSearchCommand,
-  runKnowListCommand,
-  runKnowFilesCommand,
-  runKnowReadCommand,
-  runKnowGrepCommand,
-  runKnowGlobCommand
+  createCngApiClient,
+  readBackendHealth
 };
-//# sourceMappingURL=chunk-Z3J7PPZB.js.map
+//# sourceMappingURL=chunk-QEZQGKFX.js.map