@vedmalex/ai-connect 0.12.0 → 0.13.0

package/dist/bun/registry-fs.js

@@ -1,5 +1,6 @@
 // src/registry/fs.ts
-import { readFile } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import { copyFile, mkdir, readFile, readdir, rename, unlink, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
@@ -711,6 +712,59 @@ function parseRegistry(doc, _opts) {
   return { registry, issues };
 }
 
+// src/registry/save.ts
+function stripRegistrySecrets(registry) {
+  const strippedFields = [];
+  const endpoints = registry.endpoints.map((endpoint, index) => {
+    const auth = endpoint.auth;
+    if (!auth) {
+      return endpoint;
+    }
+    const hasToken = auth.token !== void 0;
+    const hasFallbackTokens = auth.fallbackTokens !== void 0;
+    if (!hasToken && !hasFallbackTokens) {
+      return endpoint;
+    }
+    const { token: _token, fallbackTokens: _fallbackTokens, ...restAuth } = auth;
+    if (hasToken) {
+      strippedFields.push(`endpoints[${index}].auth.token`);
+    }
+    if (hasFallbackTokens) {
+      strippedFields.push(`endpoints[${index}].auth.fallbackTokens`);
+    }
+    const nextEndpoint = { ...endpoint };
+    if (Object.keys(restAuth).length > 0) {
+      nextEndpoint.auth = restAuth;
+    } else {
+      delete nextEndpoint.auth;
+    }
+    return nextEndpoint;
+  });
+  return {
+    registry: { ...registry, endpoints },
+    strippedFields
+  };
+}
+function serializeRegistry(registry) {
+  const ordered = {};
+  if (registry.$schema !== void 0) {
+    ordered.$schema = registry.$schema;
+  }
+  ordered.version = registry.version;
+  if (registry.defaults !== void 0) {
+    ordered.defaults = registry.defaults;
+  }
+  ordered.endpoints = registry.endpoints;
+  if (registry.aliases !== void 0) {
+    ordered.aliases = registry.aliases;
+  }
+  return `${JSON.stringify(ordered, null, 2)}
+`;
+}
+function mergeForSave(existing, incoming) {
+  return mergeRegistries([existing, incoming]).registry;
+}
+
 // src/registry/fs.ts
 function isObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -718,6 +772,9 @@ function isObject3(value) {
 function isEnoent(error) {
   return Boolean(error) && typeof error === "object" && error.code === "ENOENT";
 }
+function isEexist(error) {
+  return Boolean(error) && typeof error === "object" && error.code === "EEXIST";
+}
 function stripBom(text) {
   return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
 }
@@ -858,8 +915,280 @@ async function loadV1Pair(endpointsPath, aliasesPath) {
   const aliasesDoc = aliasesPath ? await readJsonFile(aliasesPath) : void 0;
   return convertV1Registry(endpointsDoc, aliasesDoc);
 }
+function resolveSaveTarget(opts, filename) {
+  const env = opts.env ?? process.env;
+  const cwd = opts.cwd ?? process.cwd();
+  if (opts.path) {
+    return path.resolve(cwd, opts.path);
+  }
+  if (opts.layer === "user") {
+    return path.join(resolveXdgConfigHome(env), "ai-connect", filename);
+  }
+  if (opts.layer === "project") {
+    return path.join(cwd, ".config", "ai-connect", filename);
+  }
+  throw new AiConnectError(
+    "validation_error",
+    "Registry save target is ambiguous: supply either `layer` ('user' | 'project') or an explicit `path`."
+  );
+}
+async function readExistingJson(filePath) {
+  try {
+    return await readJsonFile(filePath);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new AiConnectError(
+        "validation_error",
+        `Existing file at "${filePath}" is not valid JSON (${error.message}); refusing to merge-save over it. The file was not modified.`,
+        { path: filePath }
+      );
+    }
+    throw error;
+  }
+}
+var BACKUP_MAX_ATTEMPTS = 100;
+function escapeRegExpLiteral(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function createNumberedBackup(targetPath) {
+  const dir = path.dirname(targetPath);
+  const ext = path.extname(targetPath);
+  const stem = path.basename(targetPath, ext);
+  const pattern = new RegExp(`^${escapeRegExpLiteral(stem)}\\.(\\d+)${escapeRegExpLiteral(ext)}$`);
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch (error) {
+    if (isEnoent(error)) {
+      entries = [];
+    } else {
+      throw error;
+    }
+  }
+  let maxIndex = -1;
+  for (const entry of entries) {
+    const match = pattern.exec(entry);
+    if (match) {
+      const parsed = Number.parseInt(match[1], 10);
+      if (parsed > maxIndex) {
+        maxIndex = parsed;
+      }
+    }
+  }
+  let nextIndex = maxIndex + 1;
+  for (let attempt = 0; attempt < BACKUP_MAX_ATTEMPTS; attempt++) {
+    const candidate = path.join(dir, `${stem}.${nextIndex}${ext}`);
+    try {
+      await copyFile(targetPath, candidate, fsConstants.COPYFILE_EXCL);
+      return candidate;
+    } catch (error) {
+      if (isEexist(error)) {
+        nextIndex += 1;
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw new AiConnectError(
+    "validation_error",
+    `Could not create a numbered backup for "${targetPath}" after ${BACKUP_MAX_ATTEMPTS} index-collision retries.`,
+    { path: targetPath, attempts: BACKUP_MAX_ATTEMPTS }
+  );
+}
+async function atomicWriteWithBackup(targetPath, data, opts) {
+  const dir = path.dirname(targetPath);
+  await mkdir(dir, { recursive: true });
+  let existingText;
+  try {
+    existingText = await readFile(targetPath, "utf8");
+  } catch (error) {
+    if (!isEnoent(error)) {
+      throw error;
+    }
+  }
+  const targetExists = existingText !== void 0;
+  if (targetExists && existingText === data) {
+    return { created: false, wrote: false };
+  }
+  let backupPath;
+  if (targetExists && opts.backup) {
+    backupPath = await createNumberedBackup(targetPath);
+  }
+  const tmpPath = path.join(
+    dir,
+    `${path.basename(targetPath)}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`
+  );
+  try {
+    await writeFile(tmpPath, data, "utf8");
+    await rename(tmpPath, targetPath);
+  } catch (error) {
+    await unlink(tmpPath).catch(() => {
+    });
+    throw error;
+  }
+  return {
+    created: !targetExists,
+    wrote: true,
+    ...backupPath !== void 0 ? { backupPath } : {}
+  };
+}
+function isNonEmptyStringId(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function buildRawExistingRegistry(doc, targetPath) {
+  if (!isObject3(doc)) {
+    throw new AiConnectError(
+      "validation_error",
+      `Existing file at "${targetPath}" is not a JSON object; refusing to merge-save over it. The file was not modified.`,
+      { path: targetPath }
+    );
+  }
+  const rawEndpoints = Array.isArray(doc.endpoints) ? doc.endpoints : [];
+  rawEndpoints.forEach((entry, index) => {
+    if (!isObject3(entry) || !isNonEmptyStringId(entry.id)) {
+      throw new AiConnectError(
+        "validation_error",
+        `Existing file at "${targetPath}" has an invalid entry at endpoints[${index}] (must be an object with a non-empty string id to be merge-keyed); refusing to merge-save over it. The file was not modified.`,
+        { path: targetPath, index, field: "endpoints" }
+      );
+    }
+  });
+  const rawAliases = Array.isArray(doc.aliases) ? doc.aliases : [];
+  rawAliases.forEach((entry, index) => {
+    if (!isObject3(entry) || !isNonEmptyStringId(entry.id)) {
+      throw new AiConnectError(
+        "validation_error",
+        `Existing file at "${targetPath}" has an invalid entry at aliases[${index}] (must be an object with a non-empty string id to be merge-keyed); refusing to merge-save over it. The file was not modified.`,
+        { path: targetPath, index, field: "aliases" }
+      );
+    }
+  });
+  return {
+    version: 2,
+    ...typeof doc.$schema === "string" ? { $schema: doc.$schema } : {},
+    ...isObject3(doc.defaults) ? { defaults: doc.defaults } : {},
+    endpoints: rawEndpoints,
+    ...rawAliases.length > 0 ? { aliases: rawAliases } : {}
+  };
+}
+async function saveConnectionRegistry(registry, opts = {}) {
+  const env = opts.env ?? process.env;
+  const cwd = opts.cwd ?? process.cwd();
+  const mode = opts.mode ?? "merge";
+  const backup = opts.backup ?? true;
+  const targetPath = resolveSaveTarget({ layer: opts.layer, path: opts.path, cwd, env }, "connections.json");
+  let finalRegistry = registry;
+  if (mode === "merge") {
+    const existingDoc = await readExistingJson(targetPath);
+    if (existingDoc !== void 0) {
+      const detected = detectRegistryVersion(existingDoc);
+      let existingRegistry;
+      if (detected === "v2") {
+        existingRegistry = buildRawExistingRegistry(existingDoc, targetPath);
+      } else if (detected === "v1-endpoints") {
+        const aliasesPath = path.join(path.dirname(targetPath), "rag-aliases.json");
+        const aliasesDoc = await readExistingJson(aliasesPath);
+        existingRegistry = convertV1Registry(existingDoc, aliasesDoc).registry;
+      } else {
+        throw new AiConnectError(
+          "validation_error",
+          `Existing file at "${targetPath}" is not a recognized v2 document or v1-endpoints file (detected: ${detected}); refusing to merge-save over it. The file was not modified.`,
+          { path: targetPath, detected }
+        );
+      }
+      finalRegistry = mergeForSave(existingRegistry, registry);
+    }
+  }
+  const stripped = stripRegistrySecrets(finalRegistry);
+  const data = serializeRegistry(stripped.registry);
+  const writeResult = await atomicWriteWithBackup(targetPath, data, { backup });
+  return {
+    path: targetPath,
+    mode,
+    created: writeResult.created,
+    ...writeResult.backupPath !== void 0 ? { backupPath: writeResult.backupPath } : {},
+    strippedFields: stripped.strippedFields
+  };
+}
+function fragmentToPseudoRegistry(fragment) {
+  return {
+    version: 2,
+    endpoints: fragment.endpoints ?? [],
+    ...fragment.aliases !== void 0 ? { aliases: fragment.aliases } : {},
+    ...fragment.defaults !== void 0 ? { defaults: fragment.defaults } : {}
+  };
+}
+function mergeSecretsFragments(existing, incoming) {
+  const merged = mergeRegistries([
+    fragmentToPseudoRegistry(existing),
+    fragmentToPseudoRegistry(incoming)
+  ]).registry;
+  return {
+    ...merged.endpoints.length > 0 ? { endpoints: merged.endpoints } : {},
+    ...merged.aliases !== void 0 ? { aliases: merged.aliases } : {},
+    ...merged.defaults !== void 0 ? { defaults: merged.defaults } : {}
+  };
+}
+function serializeSecretsFragment(fragment) {
+  const ordered = {};
+  if (fragment.endpoints !== void 0) {
+    ordered.endpoints = fragment.endpoints;
+  }
+  if (fragment.aliases !== void 0) {
+    ordered.aliases = fragment.aliases;
+  }
+  if (fragment.defaults !== void 0) {
+    ordered.defaults = fragment.defaults;
+  }
+  return `${JSON.stringify(ordered, null, 2)}
+`;
+}
+function readRawSecretsFragment(doc) {
+  if (!isObject3(doc)) {
+    return void 0;
+  }
+  const fragment = {};
+  if (Array.isArray(doc.endpoints)) {
+    fragment.endpoints = doc.endpoints;
+  }
+  if (Array.isArray(doc.aliases)) {
+    fragment.aliases = doc.aliases;
+  }
+  if (isObject3(doc.defaults)) {
+    fragment.defaults = doc.defaults;
+  }
+  return fragment;
+}
+async function saveConnectionSecrets(fragment, opts = {}) {
+  const env = opts.env ?? process.env;
+  const cwd = opts.cwd ?? process.cwd();
+  const mode = opts.mode ?? "merge";
+  const backup = opts.backup ?? true;
+  const targetPath = resolveSaveTarget(
+    { layer: opts.layer, path: opts.path, cwd, env },
+    "connections.secrets.json"
+  );
+  let finalFragment = fragment;
+  if (mode === "merge") {
+    const existingDoc = await readExistingJson(targetPath);
+    const existingFragment = readRawSecretsFragment(existingDoc);
+    if (existingFragment) {
+      finalFragment = mergeSecretsFragments(existingFragment, fragment);
+    }
+  }
+  const data = serializeSecretsFragment(finalFragment);
+  const writeResult = await atomicWriteWithBackup(targetPath, data, { backup });
+  return {
+    path: targetPath,
+    mode,
+    created: writeResult.created,
+    ...writeResult.backupPath !== void 0 ? { backupPath: writeResult.backupPath } : {}
+  };
+}
 export {
   loadConnectionRegistry,
-  loadV1Pair
+  loadV1Pair,
+  saveConnectionRegistry,
+  saveConnectionSecrets
 };
 //# sourceMappingURL=registry-fs.js.map