codex-configurator 0.2.4 → 0.2.6

package/src/schemaRuntimeSync.js

@@ -0,0 +1,282 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  getReferenceSchemaRevision,
+  setReferenceSchema,
+} from './configReference.js';
+import { logConfiguratorError } from './errorLogger.js';
+
+const CONFIG_SCHEMA_URL = 'https://developers.openai.com/codex/config-schema.json';
+const SCHEMA_CACHE_DIRECTORY_NAME = 'codex-configurator-cache';
+const SCHEMA_CACHE_FILE_NAME = 'config-schema.json';
+const SCHEMA_METADATA_FILE_NAME = 'config-schema.meta.json';
+const FETCH_TIMEOUT_MS = 10000;
+const MAX_SCHEMA_BYTES = 512 * 1024;
+
+const isObject = (value) =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+const normalizeText = (value) => String(value || '').trim();
+
+const resolveCodexDirectory = ({ mainConfigPath = '', homeDir = os.homedir() } = {}) => {
+  const normalizedPath = normalizeText(mainConfigPath);
+  if (!normalizedPath) {
+    return path.join(homeDir, '.codex');
+  }
+
+  return path.dirname(path.resolve(normalizedPath));
+};
+
+export const resolveSchemaCachePaths = ({ mainConfigPath = '', homeDir = os.homedir() } = {}) => {
+  const codexDirectory = resolveCodexDirectory({ mainConfigPath, homeDir });
+  const cacheDirectory = path.join(codexDirectory, SCHEMA_CACHE_DIRECTORY_NAME);
+  return {
+    codexDirectory,
+    cacheDirectory,
+    schemaPath: path.join(cacheDirectory, SCHEMA_CACHE_FILE_NAME),
+    metadataPath: path.join(cacheDirectory, SCHEMA_METADATA_FILE_NAME),
+  };
+};
+
+const readJsonFile = (targetPath) => {
+  try {
+    const payload = fs.readFileSync(targetPath, 'utf8');
+    return JSON.parse(payload);
+  } catch {
+    return null;
+  }
+};
+
+const writeJsonFileAtomic = (targetPath, payload) => {
+  const directoryPath = path.dirname(targetPath);
+  const fileName = path.basename(targetPath);
+  const tempPath = path.join(
+    directoryPath,
+    `.${fileName}.${process.pid}.${Date.now()}.tmp`
+  );
+
+  if (!fs.existsSync(directoryPath)) {
+    fs.mkdirSync(directoryPath, { recursive: true, mode: 0o700 });
+  }
+
+  let fileDescriptor = null;
+
+  try {
+    fileDescriptor = fs.openSync(tempPath, 'wx', 0o600);
+    fs.writeFileSync(fileDescriptor, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+    fs.fsyncSync(fileDescriptor);
+    fs.closeSync(fileDescriptor);
+    fileDescriptor = null;
+    fs.renameSync(tempPath, targetPath);
+  } finally {
+    if (fileDescriptor !== null) {
+      try {
+        fs.closeSync(fileDescriptor);
+      } catch {}
+    }
+
+    if (fs.existsSync(tempPath)) {
+      try {
+        fs.unlinkSync(tempPath);
+      } catch {}
+    }
+  }
+};
+
+const applySchema = (schema) => {
+  const previousRevision = getReferenceSchemaRevision();
+  const ok = setReferenceSchema(schema);
+  if (!ok) {
+    return {
+      ok: false,
+      changed: false,
+    };
+  }
+
+  return {
+    ok: true,
+    changed: previousRevision !== getReferenceSchemaRevision(),
+  };
+};
+
+const buildConditionalHeaders = (metadata = {}) => {
+  const headers = {
+    accept: 'application/json',
+  };
+  const etag = normalizeText(metadata.etag);
+  const lastModified = normalizeText(metadata.lastModified);
+
+  if (etag) {
+    headers['if-none-match'] = etag;
+  }
+
+  if (lastModified) {
+    headers['if-modified-since'] = lastModified;
+  }
+
+  return headers;
+};
+
+const fetchRemoteSchema = async ({
+  fetchImpl = fetch,
+  metadata = {},
+}) => {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+
+  try {
+    const response = await fetchImpl(CONFIG_SCHEMA_URL, {
+      headers: buildConditionalHeaders(metadata),
+      signal: controller.signal,
+    });
+
+    if (response.status === 304) {
+      return {
+        status: 'not-modified',
+      };
+    }
+
+    if (!response.ok) {
+      throw new Error(
+        `Schema request failed (${response.status} ${response.statusText})`
+      );
+    }
+
+    const contentType = normalizeText(response.headers.get('content-type')).toLowerCase();
+    if (!contentType.includes('application/json')) {
+      throw new Error('Schema response content-type is not application/json.');
+    }
+
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (bytes.length > MAX_SCHEMA_BYTES) {
+      throw new Error(
+        `Schema response exceeded max size (${bytes.length} bytes > ${MAX_SCHEMA_BYTES} bytes).`
+      );
+    }
+
+    let parsedSchema = null;
+    try {
+      parsedSchema = JSON.parse(bytes.toString('utf8'));
+    } catch (error) {
+      throw new Error(
+        `Schema response was not valid JSON (${String(error?.message || 'parse failed')}).`
+      );
+    }
+
+    return {
+      status: 'updated',
+      schema: parsedSchema,
+      metadata: {
+        etag: normalizeText(response.headers.get('etag')) || null,
+        lastModified: normalizeText(response.headers.get('last-modified')) || null,
+      },
+    };
+  } finally {
+    clearTimeout(timeoutId);
+  }
+};
+
+export const syncReferenceSchemaAtStartup = async ({
+  mainConfigPath = '',
+  fetchImpl = fetch,
+  onSchemaChange,
+  onStatus,
+} = {}) => {
+  const cachePaths = resolveSchemaCachePaths({ mainConfigPath });
+  const notifySchemaChange = (source) => {
+    if (typeof onSchemaChange === 'function') {
+      onSchemaChange({ source });
+    }
+  };
+  const updateStatus = (value) => {
+    if (typeof onStatus === 'function') {
+      onStatus(String(value || '').trim());
+    }
+  };
+
+  let source = 'bundled';
+  let canReuseCachedValidators = false;
+
+  try {
+    updateStatus('Schema: Loading cache...');
+
+    const cachedSchema = readJsonFile(cachePaths.schemaPath);
+    const metadataPayload = readJsonFile(cachePaths.metadataPath);
+    const cachedMetadata = isObject(metadataPayload) ? metadataPayload : {};
+
+    if (cachedSchema !== null) {
+      const cacheApplyResult = applySchema(cachedSchema);
+      if (cacheApplyResult.ok) {
+        source = 'cache';
+        canReuseCachedValidators = true;
+        if (cacheApplyResult.changed) {
+          notifySchemaChange('cache');
+        }
+      } else {
+        logConfiguratorError('schema.cache.invalid', {
+          schemaPath: cachePaths.schemaPath,
+        });
+      }
+    }
+
+    updateStatus('Schema: Checking upstream...');
+
+    const fetchResult = await fetchRemoteSchema({
+      fetchImpl,
+      metadata: canReuseCachedValidators ? cachedMetadata : {},
+    });
+
+    if (fetchResult.status === 'not-modified') {
+      return {
+        ok: true,
+        updated: false,
+        source,
+      };
+    }
+
+    const remoteApplyResult = applySchema(fetchResult.schema);
+    if (!remoteApplyResult.ok) {
+      throw new Error('Downloaded schema did not pass local validation.');
+    }
+    if (remoteApplyResult.changed) {
+      notifySchemaChange('remote');
+    }
+
+    updateStatus('Schema: Saving cache...');
+
+    const mergedMetadata = {
+      etag: fetchResult.metadata.etag || normalizeText(cachedMetadata.etag) || null,
+      lastModified:
+        fetchResult.metadata.lastModified ||
+        normalizeText(cachedMetadata.lastModified) ||
+        null,
+      updatedAt: new Date().toISOString(),
+      sourceUrl: CONFIG_SCHEMA_URL,
+    };
+
+    writeJsonFileAtomic(cachePaths.schemaPath, fetchResult.schema);
+    writeJsonFileAtomic(cachePaths.metadataPath, mergedMetadata);
+
+    return {
+      ok: true,
+      updated: true,
+      source: 'remote',
+    };
+  } catch (error) {
+    const message = String(error?.message || 'Unknown schema sync error.');
+    logConfiguratorError('schema.sync.failed', {
+      error: message,
+      source,
+      schemaPath: cachePaths.schemaPath,
+      metadataPath: cachePaths.metadataPath,
+    });
+
+    return {
+      ok: false,
+      updated: false,
+      source,
+      error: message,
+    };
+  }
+};