@fractary/codex 0.9.0 → 0.10.0

package/dist/index.cjs

@@ -908,8 +908,40 @@ var ArchiveProjectConfigSchema = zod.z.object({
 var ArchiveConfigSchema = zod.z.object({
   projects: zod.z.record(ArchiveProjectConfigSchema)
 });
+var GitHubAuthConfigSchema = zod.z.object({
+  /** Default token environment variable name (default: GITHUB_TOKEN) */
+  default_token_env: zod.z.string().optional(),
+  /** Fallback to public access if authentication fails */
+  fallback_to_public: zod.z.boolean().optional()
+});
+var AuthConfigSchema = zod.z.object({
+  /** GitHub authentication configuration */
+  github: GitHubAuthConfigSchema.optional()
+});
+var SourceConfigSchema = zod.z.object({
+  /** Source type */
+  type: zod.z.enum(["github", "s3", "http", "local"]),
+  /** Environment variable containing the authentication token */
+  token_env: zod.z.string().optional(),
+  /** Direct token value (not recommended, use token_env instead) */
+  token: zod.z.string().optional(),
+  /** Branch to fetch from (for GitHub sources) */
+  branch: zod.z.string().optional(),
+  /** Base URL (for HTTP sources) */
+  base_url: zod.z.string().optional(),
+  /** Bucket name (for S3 sources) */
+  bucket: zod.z.string().optional(),
+  /** Prefix/path within bucket (for S3 sources) */
+  prefix: zod.z.string().optional()
+});
+var DependencyConfigSchema = zod.z.object({
+  /** Sources within this dependency */
+  sources: zod.z.record(SourceConfigSchema)
+});
 var CodexConfigSchema = zod.z.object({
   organizationSlug: zod.z.string(),
+  /** Project name (optional) */
+  project: zod.z.string().optional(),
   directories: zod.z.object({
     source: zod.z.string().optional(),
     target: zod.z.string().optional(),
@@ -919,7 +951,11 @@ var CodexConfigSchema = zod.z.object({
   // Directional sync configuration
   sync: DirectionalSyncSchema.optional(),
   // Archive configuration
-  archive: ArchiveConfigSchema.optional()
+  archive: ArchiveConfigSchema.optional(),
+  // Authentication configuration
+  auth: AuthConfigSchema.optional(),
+  // Dependencies configuration (external projects)
+  dependencies: zod.z.record(DependencyConfigSchema).optional()
 }).strict();
 var FileSourceSchema = zod.z.object({
   type: zod.z.enum(["s3", "r2", "gcs", "local"]),
@@ -2294,7 +2330,9 @@ var S3ArchiveStorage = class {
 var StorageManager = class {
   providers = /* @__PURE__ */ new Map();
   priority;
+  codexConfig;
   constructor(config = {}) {
+    this.codexConfig = config.codexConfig;
     this.providers.set("local", new LocalStorage(config.local));
     this.providers.set("github", new GitHubStorage(config.github));
     this.providers.set("http", new HttpStorage(config.http));
@@ -2306,6 +2344,48 @@ var StorageManager = class {
     }
     this.priority = config.priority || (config.filePlugin && config.s3Archive ? ["file-plugin", "local", "s3-archive", "github", "http"] : config.filePlugin ? ["file-plugin", "local", "github", "http"] : config.s3Archive ? ["local", "s3-archive", "github", "http"] : ["local", "github", "http"]);
   }
+  /**
+   * Resolve authentication token for a reference
+   *
+   * Looks up dependency-specific authentication or falls back to default
+   */
+  resolveToken(reference) {
+    if (!this.codexConfig) {
+      return void 0;
+    }
+    const dependencyKey = `${reference.org}/${reference.project}`;
+    if (this.codexConfig.dependencies?.[dependencyKey]) {
+      const dependency = this.codexConfig.dependencies[dependencyKey];
+      for (const [, sourceConfig] of Object.entries(dependency.sources)) {
+        if (sourceConfig.type === "github") {
+          if (sourceConfig.token_env) {
+            const token = process.env[sourceConfig.token_env];
+            if (token) {
+              return token;
+            }
+          }
+          if (sourceConfig.token) {
+            return sourceConfig.token;
+          }
+        }
+      }
+    }
+    const defaultTokenEnv = this.codexConfig.auth?.github?.default_token_env || "GITHUB_TOKEN";
+    return process.env[defaultTokenEnv];
+  }
+  /**
+   * Resolve fetch options with authentication
+   *
+   * Merges reference-specific authentication with provided options
+   */
+  resolveFetchOptions(reference, options) {
+    const token = this.resolveToken(reference);
+    return {
+      ...options,
+      token: options?.token || token
+      // Explicit option overrides resolved token
+    };
+  }
   /**
    * Register a custom storage provider
    */
@@ -2346,8 +2426,10 @@ var StorageManager = class {
    * Fetch content for a reference
    *
    * Tries providers in priority order until one succeeds.
+   * Automatically resolves authentication based on dependency configuration.
    */
   async fetch(reference, options) {
+    const resolvedOptions = this.resolveFetchOptions(reference, options);
     const errors = [];
     for (const type of this.priority) {
       const provider = this.providers.get(type);
@@ -2355,7 +2437,7 @@ var StorageManager = class {
         continue;
       }
       try {
-        return await provider.fetch(reference, options);
+        return await provider.fetch(reference, resolvedOptions);
       } catch (error) {
         errors.push(error instanceof Error ? error : new Error(String(error)));
       }
@@ -2376,15 +2458,17 @@ var StorageManager = class {
    * Check if content exists for a reference
    *
    * Returns true if any provider reports the content exists.
+   * Automatically resolves authentication based on dependency configuration.
    */
   async exists(reference, options) {
+    const resolvedOptions = this.resolveFetchOptions(reference, options);
     for (const type of this.priority) {
       const provider = this.providers.get(type);
       if (!provider || !provider.canHandle(reference)) {
         continue;
       }
       try {
-        if (await provider.exists(reference, options)) {
+        if (await provider.exists(reference, resolvedOptions)) {
           return true;
         }
       } catch {
@@ -2404,6 +2488,8 @@ var StorageManager = class {
   }
   /**
    * Fetch multiple references in parallel
+   *
+   * Automatically resolves authentication for each reference based on dependency configuration.
    */
   async fetchMany(references, options) {
     const results = /* @__PURE__ */ new Map();