replicas-engine 0.1.1036 → 0.1.1038

package/dist/src/post-tool-pr-hook.js

@@ -3,13 +3,13 @@ import { createRequire as __createRequire } from 'node:module';
 const require = __createRequire(import.meta.url);
 import {
   publishedPullRequestUrls
-} from "./chunk-3OBN7KPB.js";
+} from "./chunk-MUS3ULTT.js";
 import {
   isRecord
 } from "./chunk-UZSNFLDQ.js";
 import {
   shouldRefreshPullRequests
-} from "./chunk-OPJ5KAGY.js";
+} from "./chunk-MALHGZWB.js";
 import "./chunk-VEQXQN22.js";
 
 // src/services/post-tool-pr-notifier.ts

package/dist/src/subagent-mcp.js

@@ -9,7 +9,7 @@ import {
   spawnSubagentRequestSchema,
   subagentResponseSchema,
   waitSubagentRequestSchema
-} from "./chunk-OPJ5KAGY.js";
+} from "./chunk-MALHGZWB.js";
 import "./chunk-VEQXQN22.js";
 
 // src/subagent-mcp.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.1036",
+  "version": "0.1.1038",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",

package/dist/src/chunk-EDNMHUVD.js

@@ -1,527 +0,0 @@
-#!/usr/bin/env node
-import { createRequire as __createRequire } from 'node:module';
-const require = __createRequire(import.meta.url);
-import {
-  ENGINE_ENV,
-  monolithRequest,
-  setAgentCredentialSnapshot
-} from "./chunk-2RHUTB67.js";
-import {
-  AppServerProcess,
-  buildCodexAgentEnv
-} from "./chunk-AP442WDC.js";
-import {
-  SUBPROCESS_MAX_BUFFER,
-  execFileAsync
-} from "./chunk-KVJYQOUT.js";
-import {
-  isRecord
-} from "./chunk-UZSNFLDQ.js";
-import {
-  CODEX_AUTH_ENV_KEYS,
-  CODEX_AUTH_ENV_KEYS_BY_METHOD,
-  codexAuthEnvFromResponse,
-  createErrorResult,
-  createSuccessResult,
-  isSameCredential,
-  listOllamaModels,
-  listOpenAICompatibleModels,
-  readOllamaAuthEnv,
-  resolveOpenAICompatibleModelsUrl
-} from "./chunk-OPJ5KAGY.js";
-
-// src/managers/codex-token-manager.ts
-import { promises as fs } from "fs";
-import path from "path";
-
-// src/managers/auth-env-transition.ts
-function applyAuthEnvTransition(params) {
-  const prevOwned = new Set(params.authKeysByMethod[params.prevMethod]);
-  for (const key of params.authKeys) {
-    const value = params.newEnvVars[key];
-    if (value !== void 0) {
-      for (const env of params.envs) {
-        env[key] = value;
-      }
-    } else if (prevOwned.has(key)) {
-      for (const env of params.envs) {
-        delete env[key];
-      }
-    }
-  }
-}
-
-// src/services/credential-fallbacks.ts
-var fallbacksByAgent = /* @__PURE__ */ new Map();
-var exhaustedByAgent = /* @__PURE__ */ new Map();
-function clearCredentialFallbacks(provider) {
-  fallbacksByAgent.delete(provider);
-  exhaustedByAgent.delete(provider);
-}
-function recordCredentialFallback(notice) {
-  fallbacksByAgent.set(notice.provider, notice);
-}
-function listCredentialFallbacks() {
-  return [...fallbacksByAgent.values()].filter((notice) => {
-    const live = ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS[notice.provider];
-    if (!live) return false;
-    return notice.status === "switched" ? live.method === notice.candidateMethod && live.scope === notice.candidateScope : live.method === notice.exhaustedMethod && live.scope === notice.exhaustedScope;
-  });
-}
-function listExhaustedCredentials(provider) {
-  return [...exhaustedByAgent.get(provider)?.values() ?? []];
-}
-function routineRefreshRequest(provider) {
-  const live = ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS[provider];
-  const excludeCredentials = listExhaustedCredentials(provider).filter((spent) => !live || !isSameCredential(spent, live));
-  return {
-    ...excludeCredentials.length > 0 ? { excludeCredentials } : {},
-    ...live ? { currentCredential: live } : {}
-  };
-}
-function recordExhaustedCredential(provider, credential) {
-  const spent = exhaustedByAgent.get(provider) ?? /* @__PURE__ */ new Map();
-  spent.set(`${credential.method}|${credential.scope}|${credential.credentialId ?? ""}`, credential);
-  exhaustedByAgent.set(provider, spent);
-}
-
-// src/managers/base-refresh-manager.ts
-function credentialSwapError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  return createErrorResult({
-    message,
-    code: message.includes('"code":"no_credentials"') ? "no_credentials" : "refresh_failed"
-  });
-}
-function refreshDelayMs(expiresAtMs, maxMs = 5 * 60 * 1e3) {
-  const ttlMs = expiresAtMs - Date.now();
-  return Number.isFinite(ttlMs) ? Math.max(1e3, Math.min(maxMs, Math.floor(ttlMs * 0.8))) : maxMs;
-}
-var BaseRefreshManager = class {
-  constructor(managerName, intervalMs = 15 * 60 * 1e3) {
-    this.managerName = managerName;
-    this.intervalMs = intervalMs;
-    this.health = {
-      isRunning: false,
-      intervalMs: this.intervalMs,
-      lastAttemptAt: null,
-      lastSuccessAt: null,
-      lastErrorAt: null,
-      lastErrorMessage: null
-    };
-  }
-  managerName;
-  intervalMs;
-  credentialGeneration = 0;
-  credentialUpdate = Promise.resolve();
-  intervalHandle = null;
-  pendingRefresh = null;
-  health;
-  async start(skipInitialRefresh = false) {
-    if (this.intervalHandle) {
-      return;
-    }
-    const skipReason = this.getSkipReason();
-    if (skipReason) {
-      console.log(`[${this.managerName}] Skipping: ${skipReason}`);
-      return;
-    }
-    console.log(`[${this.managerName}] Starting token refresh service`);
-    this.health.isRunning = true;
-    const config = this.getRuntimeConfig();
-    if (config && !skipInitialRefresh) {
-      this.health.lastAttemptAt = (/* @__PURE__ */ new Date()).toISOString();
-      for (let attempt = 1; attempt <= 3; attempt++) {
-        try {
-          await this.doRefresh(config);
-          this.health.lastSuccessAt = (/* @__PURE__ */ new Date()).toISOString();
-          this.health.lastErrorAt = null;
-          this.health.lastErrorMessage = null;
-          break;
-        } catch (error) {
-          const message = error instanceof Error ? error.message : "Unknown error";
-          this.health.lastErrorAt = (/* @__PURE__ */ new Date()).toISOString();
-          this.health.lastErrorMessage = message;
-          if (attempt < 3) {
-            console.warn(`[${this.managerName}] Initial refresh attempt ${attempt} failed, retrying in 2s...`);
-            await new Promise((resolve) => setTimeout(resolve, 2e3));
-          } else {
-            console.error(`[${this.managerName}] Initial refresh failed after 3 attempts:`, error);
-          }
-        }
-      }
-    }
-    this.scheduleNextRefresh();
-  }
-  async swapCredentials(params) {
-    if (!this.getRuntimeConfig()) {
-      return createErrorResult({ message: `${this.managerName} has no runtime config`, code: "not_configured" });
-    }
-    try {
-      console.log(`[${this.managerName}] Fetching fresh credentials from monolith (${params.failureKind})...`);
-      const excludeCredentials = listExhaustedCredentials(params.provider);
-      await params.refresh({
-        ...excludeCredentials.length > 0 ? { excludeCredentials } : {},
-        ...params.allowedMethods ? { allowedMethods: [...params.allowedMethods] } : {}
-      });
-      if (params.isOauthNow()) {
-        this.start().catch((error) => {
-          console.error(`[${this.managerName}] Failed to restart OAuth refresh service after fallback:`, error);
-        });
-      }
-      return createSuccessResult();
-    } catch (error) {
-      console.error(`[${this.managerName}] Failed to fetch fresh credentials:`, error);
-      return credentialSwapError(error);
-    }
-  }
-  async stop() {
-    if (this.intervalHandle) clearTimeout(this.intervalHandle);
-    this.intervalHandle = null;
-    this.health.isRunning = false;
-    await this.pendingRefresh;
-    console.log(`[${this.managerName}] Stopped`);
-  }
-  getHealthStatus() {
-    return { ...this.health };
-  }
-  getSkipReason() {
-    return null;
-  }
-  getNextRefreshDelayMs() {
-    return this.intervalMs;
-  }
-  applyCredentialUpdate(generation, apply) {
-    const update = this.credentialUpdate.then(async () => {
-      if (generation !== this.credentialGeneration) throw new Error("Credential changed during refresh; retry with the current credential.");
-      await apply();
-    });
-    this.credentialUpdate = update.catch(() => {
-    });
-    return update;
-  }
-  getRuntimeConfig() {
-    if (!ENGINE_ENV.REPLICAS_WORKSPACE_ID) {
-      return null;
-    }
-    return {
-      monolithUrl: ENGINE_ENV.REPLICAS_MONOLITH_URL,
-      workspaceId: ENGINE_ENV.REPLICAS_WORKSPACE_ID,
-      engineSecret: ENGINE_ENV.REPLICAS_ENGINE_SECRET
-    };
-  }
-  scheduleNextRefresh() {
-    const delayMs = this.getNextRefreshDelayMs();
-    this.health.intervalMs = delayMs;
-    this.intervalHandle = setTimeout(async () => {
-      this.pendingRefresh = this.refreshOnce();
-      await this.pendingRefresh;
-      if (this.intervalHandle) this.scheduleNextRefresh();
-    }, delayMs);
-    console.log(`[${this.managerName}] Token refresh scheduled in ${Math.round(delayMs / 1e3)} seconds`);
-  }
-  async refreshOnce(force = false) {
-    if (!force && this.getSkipReason()) {
-      return createSuccessResult();
-    }
-    const config = this.getRuntimeConfig();
-    if (!config) return createSuccessResult();
-    this.health.lastAttemptAt = (/* @__PURE__ */ new Date()).toISOString();
-    try {
-      await this.doRefresh(config);
-      this.health.lastSuccessAt = (/* @__PURE__ */ new Date()).toISOString();
-      this.health.lastErrorAt = null;
-      this.health.lastErrorMessage = null;
-      return createSuccessResult();
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      this.health.lastErrorAt = (/* @__PURE__ */ new Date()).toISOString();
-      this.health.lastErrorMessage = message;
-      console.error(`[${this.managerName}] Failed to refresh credentials:`, error);
-      return createErrorResult({ message });
-    }
-  }
-};
-
-// src/managers/codex-token-manager.ts
-var CodexAspAuthMethodChangedError = class extends Error {
-  name = "CodexAspAuthMethodChangedError";
-};
-var CodexTokenManager = class extends BaseRefreshManager {
-  constructor() {
-    super("CodexTokenManager");
-  }
-  getSkipReason() {
-    if (!ENGINE_ENV.REPLICAS_CODEX_AUTH_METHOD && ENGINE_ENV.OPENAI_API_KEY) {
-      return "OPENAI_API_KEY is set";
-    }
-    return null;
-  }
-  async doRefresh(_config) {
-    await this.refreshWithRequest(routineRefreshRequest("codex"), true);
-  }
-  async switchCredentials(data) {
-    await this.applyCredentialUpdate(++this.credentialGeneration, async () => {
-      await this.applyCredentialsResponse(data);
-      setAgentCredentialSnapshot("codex", data);
-      const { restartCodexAspHostIfRunning: restartCodexAspHostIfRunning2 } = await import("./asp-host-4JQWKA47.js");
-      await restartCodexAspHostIfRunning2();
-    });
-    await this.start(true);
-  }
-  async refreshWithRequest(request, restartOnChange = false) {
-    const generation = this.credentialGeneration;
-    const previousEnv = CODEX_AUTH_ENV_KEYS.map((key) => process.env[key]);
-    console.log("[CodexTokenManager] Refreshing Codex credentials...");
-    const response = await monolithRequest("/v1/engine/codex/refresh-credentials", {
-      body: { supportsOpenAICompatibleAuth: true, ...request }
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`Credentials refresh failed: ${response.status} ${errorText}`);
-    }
-    const data = await response.json();
-    await this.applyCredentialUpdate(generation, async () => {
-      const accountChanged = ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS.codex?.credentialId !== data.credentialId;
-      await this.applyCredentialsResponse(data);
-      if (restartOnChange && (accountChanged || CODEX_AUTH_ENV_KEYS.some((key, index) => process.env[key] !== previousEnv[index]))) {
-        const { restartCodexAspHostIfRunning: restartCodexAspHostIfRunning2 } = await import("./asp-host-4JQWKA47.js");
-        await restartCodexAspHostIfRunning2();
-      }
-      setAgentCredentialSnapshot("codex", data);
-    });
-    console.log(`[CodexTokenManager] Credentials refreshed (method=${data.type})`);
-    return data;
-  }
-  async prepareAspOauthOptions() {
-    if (ENGINE_ENV.REPLICAS_CODEX_AUTH_METHOD !== "oauth") return {};
-    const response = await this.refreshWithRequest(routineRefreshRequest("codex"));
-    if (response.type !== "oauth") return {};
-    const login = this.buildAspOauthLogin(response);
-    let credential = login.credential;
-    return {
-      chatgptAuthTokens: login.tokens,
-      refreshChatgptAuthTokens: async (params) => {
-        const refreshed = await this.refreshAspOauthCredentials(
-          credential,
-          `Codex ASP requested an external token refresh (${params.reason})`
-        );
-        if (!refreshed.ok) {
-          if (refreshed.error.code === "method_changed") {
-            throw new CodexAspAuthMethodChangedError(refreshed.error.message);
-          }
-          throw new Error(refreshed.error.message);
-        }
-        credential = refreshed.data.credential;
-        return refreshed.data.tokens;
-      }
-    };
-  }
-  async refreshAspOauthCredentials(failedCredential, failureReason) {
-    try {
-      const response = await this.refreshWithRequest({
-        failedMethod: "oauth",
-        ...failedCredential?.method === "oauth" ? { failedCredential } : {},
-        failureKind: "rejected",
-        failureReason
-      });
-      if (response.type !== "oauth") {
-        return createErrorResult({
-          message: `${failureReason}; credentials changed to ${response.type}, so the app server must restart`,
-          code: "method_changed"
-        });
-      }
-      return createSuccessResult(this.buildAspOauthLogin(response));
-    } catch (error) {
-      return credentialSwapError(error);
-    }
-  }
-  async fetchFreshCredentials(failureReason, failureKind = "rejected", failedCredential = ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS.codex, allowedMethods) {
-    const failedMethod = failedCredential?.method === "ollama" || failedCredential?.method === "oauth" || failedCredential?.method === "api_key" || failedCredential?.method === "openai-compatible" || failedCredential?.method === "foundry" ? failedCredential.method : ENGINE_ENV.REPLICAS_CODEX_AUTH_METHOD;
-    return this.swapCredentials({
-      provider: "codex",
-      failureKind,
-      allowedMethods,
-      refresh: async (exclusions) => {
-        await this.refreshWithRequest(
-          failedMethod === "ollama" || failedMethod === "oauth" || failedMethod === "api_key" || failedMethod === "openai-compatible" || failedMethod === "foundry" ? {
-            failedMethod,
-            ...failedCredential?.method === failedMethod ? { failedCredential } : {},
-            failureReason,
-            failureKind,
-            ...exclusions
-          } : exclusions
-        );
-      },
-      isOauthNow: () => ENGINE_ENV.REPLICAS_CODEX_AUTH_METHOD === "oauth"
-    });
-  }
-  async applyCredentialsResponse(response) {
-    await this.removeOauthCredentialsFile();
-    const envVars = codexAuthEnvFromResponse(response);
-    applyAuthEnvTransition({
-      prevMethod: ENGINE_ENV.REPLICAS_CODEX_AUTH_METHOD ?? "none",
-      authKeys: CODEX_AUTH_ENV_KEYS,
-      authKeysByMethod: CODEX_AUTH_ENV_KEYS_BY_METHOD,
-      newEnvVars: envVars,
-      envs: [ENGINE_ENV, process.env]
-    });
-    if (response.type === "api_key") {
-      for (const key of CODEX_AUTH_ENV_KEYS_BY_METHOD.api_key) {
-        if (envVars[key] !== void 0) continue;
-        delete ENGINE_ENV[key];
-        delete process.env[key];
-      }
-    }
-  }
-  buildAspOauthLogin(response) {
-    const credential = ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS.codex;
-    return {
-      tokens: {
-        accessToken: response.accessToken,
-        chatgptAccountId: response.accountId,
-        chatgptPlanType: null
-      },
-      ...credential?.method === "oauth" ? { credential } : {}
-    };
-  }
-  async removeOauthCredentialsFile() {
-    const authPath = path.join(ENGINE_ENV.HOME_DIR, ".codex", "auth.json");
-    try {
-      await fs.unlink(authPath);
-    } catch (error) {
-      if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
-    }
-  }
-};
-var codexTokenManager = new CodexTokenManager();
-
-// src/managers/codex-asp/openai-compatible-model-catalog.ts
-import { writeFile } from "fs/promises";
-import { tmpdir } from "os";
-import { join } from "path";
-var CATALOG_TTL_MS = 6e4;
-var CODEX_MODEL_CATALOG_PATH = join(tmpdir(), "replicas-openai-compatible-model-catalog.json");
-var cachedCatalog = null;
-async function writeCodexModelCatalog(modelsUrl) {
-  const ollama = ENGINE_ENV.REPLICAS_CODEX_AUTH_METHOD === "ollama" ? readOllamaAuthEnv("codex", process.env) : null;
-  const [models, { stdout }] = await Promise.all([
-    ollama ? listOllamaModels(ollama) : listOpenAICompatibleModels({
-      apiKey: ENGINE_ENV.OPENAI_API_KEY,
-      authorizationHeader: ENGINE_ENV.CODEX_OPENAI_AUTHORIZATION_HEADER,
-      baseUrl: ENGINE_ENV.CODEX_OPENAI_BASE_URL ?? "",
-      modelsUrl
-    }),
-    execFileAsync("codex", ["debug", "models"], { maxBuffer: SUBPROCESS_MAX_BUFFER })
-  ]);
-  const payload = JSON.parse(stdout);
-  const template = isRecord(payload) && Array.isArray(payload.models) ? payload.models.find((model) => isRecord(model) && model.slug === "gpt-5.2") ?? payload.models.find(isRecord) : null;
-  if (!isRecord(template)) throw new Error("Codex did not return a model catalog template");
-  await writeFile(CODEX_MODEL_CATALOG_PATH, JSON.stringify({
-    models: models.flatMap((model) => model.contextWindow ? [{
-      ...template,
-      ...ollama ? { apply_patch_tool_type: null, support_verbosity: false, supports_search_tool: false, input_modalities: ["text"] } : {},
-      slug: model.id,
-      display_name: model.displayName,
-      description: model.description ?? model.displayName,
-      context_window: model.contextWindow,
-      max_context_window: model.contextWindow,
-      effective_context_window_percent: 100,
-      auto_compact_token_limit: Math.floor(model.contextWindow * 0.9)
-    }] : [])
-  }));
-  return [
-    `model_catalog_json=${JSON.stringify(CODEX_MODEL_CATALOG_PATH)}`,
-    "features.remote_models=false"
-  ];
-}
-async function getOpenAICompatibleCodexModelCatalogConfig() {
-  if (ENGINE_ENV.REPLICAS_CODEX_AUTH_METHOD !== "openai-compatible" && ENGINE_ENV.REPLICAS_CODEX_AUTH_METHOD !== "ollama" || !ENGINE_ENV.CODEX_OPENAI_BASE_URL) return [];
-  const modelsUrl = resolveOpenAICompatibleModelsUrl({
-    baseUrl: ENGINE_ENV.CODEX_OPENAI_BASE_URL,
-    modelsUrl: ENGINE_ENV.CODEX_OPENAI_MODELS_URL ?? ""
-  });
-  const key = `${modelsUrl}:${JSON.stringify(ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS.codex ?? null)}`;
-  if (!cachedCatalog || cachedCatalog.key !== key || cachedCatalog.expiresAt <= Date.now()) {
-    cachedCatalog = {
-      key,
-      expiresAt: Date.now() + CATALOG_TTL_MS,
-      config: writeCodexModelCatalog(modelsUrl).catch((error) => {
-        console.warn("[CodexAspManager] Failed to prepare OpenAI-compatible model catalog:", error);
-        return [];
-      })
-    };
-  }
-  return cachedCatalog.config;
-}
-
-// src/managers/codex-asp/asp-host.ts
-var hostPromise = null;
-var activeProcess = null;
-var restartPromise = null;
-async function getCodexAspHost() {
-  if (restartPromise) {
-    await restartPromise;
-  }
-  hostPromise ??= (async () => {
-    try {
-      const oauthOptions = await codexTokenManager.prepareAspOauthOptions();
-      const process2 = new AppServerProcess({
-        cwd: ENGINE_ENV.WORKSPACE_ROOT,
-        env: buildCodexAgentEnv(),
-        configOverrides: await getOpenAICompatibleCodexModelCatalogConfig(),
-        ...oauthOptions
-      });
-      const { client } = await process2.start();
-      activeProcess = process2;
-      process2.on("exit", () => {
-        if (activeProcess === process2) {
-          activeProcess = null;
-        }
-        hostPromise = null;
-      });
-      return { client };
-    } catch (error) {
-      hostPromise = null;
-      throw error;
-    }
-  })();
-  return hostPromise;
-}
-async function restartCodexAspHost() {
-  if (restartPromise) {
-    return restartPromise;
-  }
-  restartPromise = (async () => {
-    const process2 = activeProcess;
-    hostPromise = null;
-    activeProcess = null;
-    if (process2) {
-      await process2.stop();
-    }
-  })();
-  try {
-    await restartPromise;
-  } finally {
-    restartPromise = null;
-  }
-}
-async function restartCodexAspHostIfRunning() {
-  if (activeProcess) await restartCodexAspHost();
-}
-
-export {
-  clearCredentialFallbacks,
-  recordCredentialFallback,
-  listCredentialFallbacks,
-  routineRefreshRequest,
-  recordExhaustedCredential,
-  refreshDelayMs,
-  BaseRefreshManager,
-  applyAuthEnvTransition,
-  getCodexAspHost,
-  restartCodexAspHost,
-  restartCodexAspHostIfRunning,
-  CodexAspAuthMethodChangedError,
-  codexTokenManager
-};