replicas-engine 0.1.666 → 0.1.669

package/dist/src/chunk-IRM6KMN5.js

@@ -0,0 +1,407 @@
+#!/usr/bin/env node
+import {
+  ENGINE_ENV,
+  setAgentCredentialSnapshot
+} from "./chunk-LO6ISJCF.js";
+import {
+  CODEX_AUTH_ENV_KEYS,
+  CODEX_AUTH_ENV_KEYS_BY_METHOD,
+  codexAuthEnvFromResponse,
+  createErrorResult,
+  createSuccessResult,
+  isRecord,
+  isValidAgentProvider
+} from "./chunk-6JWWD5NM.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 newOwned = new Set(params.authKeysByMethod[params.newMethod]);
+  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) && !newOwned.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 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 recordExhaustedCredential(provider, credential) {
+  const spent = exhaustedByAgent.get(provider) ?? /* @__PURE__ */ new Map();
+  spent.set(`${credential.method}|${credential.scope}`, credential);
+  exhaustedByAgent.set(provider, spent);
+}
+
+// src/managers/base-refresh-manager.ts
+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;
+  intervalHandle = null;
+  health;
+  async start() {
+    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) {
+      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 } : {});
+      if (params.isOauthNow()) {
+        this.start().catch((error) => {
+          console.error(`[${this.managerName}] Failed to restart OAuth refresh service after fallback:`, error);
+        });
+      }
+      return createSuccessResult();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`[${this.managerName}] Failed to fetch fresh credentials:`, error);
+      return createErrorResult({
+        message,
+        code: message.includes('"code":"no_credentials"') ? "no_credentials" : "refresh_failed"
+      });
+    }
+  }
+  stop() {
+    if (!this.intervalHandle) {
+      return;
+    }
+    clearTimeout(this.intervalHandle);
+    this.intervalHandle = null;
+    this.health.isRunning = false;
+    console.log(`[${this.managerName}] Stopped`);
+  }
+  getHealthStatus() {
+    return { ...this.health };
+  }
+  getSkipReason() {
+    return null;
+  }
+  getNextRefreshDelayMs() {
+    return this.intervalMs;
+  }
+  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 () => {
+      await this.refreshOnce();
+      if (this.intervalHandle) this.scheduleNextRefresh();
+    }, delayMs);
+    console.log(`[${this.managerName}] Token refresh scheduled in ${Math.round(delayMs / 1e3)} seconds`);
+  }
+  async refreshOnce() {
+    if (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/services/monolith-service.ts
+async function monolithRequest(path2, init = {}) {
+  if (!ENGINE_ENV.REPLICAS_WORKSPACE_ID) {
+    throw new Error("REPLICAS_WORKSPACE_ID is not set; cannot call monolith");
+  }
+  const headers = {
+    Authorization: `Bearer ${ENGINE_ENV.REPLICAS_ENGINE_SECRET}`,
+    "X-Workspace-Id": ENGINE_ENV.REPLICAS_WORKSPACE_ID
+  };
+  if (!(init.body instanceof FormData)) headers["Content-Type"] = "application/json";
+  return fetch(`${ENGINE_ENV.REPLICAS_MONOLITH_URL}${path2}`, {
+    method: init.method ?? "POST",
+    headers,
+    body: init.body === void 0 ? void 0 : init.body instanceof FormData ? init.body : JSON.stringify(init.body),
+    signal: init.signal
+  });
+}
+var MonolithService = class {
+  async getRelaySubagentProviders() {
+    try {
+      const response = await monolithRequest("/v1/engine/relay-subagent-providers", { method: "GET" });
+      if (!response.ok) {
+        return null;
+      }
+      const body = await response.json();
+      return isRecord(body) && Array.isArray(body.providers) && body.providers.every((provider) => typeof provider === "string" && isValidAgentProvider(provider)) ? body.providers : null;
+    } catch {
+      return null;
+    }
+  }
+  async getOpenRouterModels() {
+    try {
+      const response = await monolithRequest("/v1/engine/openrouter-models", { method: "GET" });
+      if (!response.ok) {
+        return null;
+      }
+      const body = await response.json();
+      return isRecord(body) && Array.isArray(body.models) && body.models.every((model) => typeof model === "string") ? body.models : null;
+    } catch {
+      return null;
+    }
+  }
+  async sendEvent(event) {
+    if (!ENGINE_ENV.REPLICAS_WORKSPACE_ID) {
+      return;
+    }
+    try {
+      const response = await monolithRequest("/v1/engine/webhook", { body: event });
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error(`[MonolithService] Failed to send event: ${response.status} ${errorText}`);
+      }
+    } catch (error) {
+      console.error("[MonolithService] Failed to send event:", error);
+    }
+  }
+};
+var monolithService = new MonolithService();
+
+// src/managers/codex-token-manager.ts
+var CodexAspAuthMethodChangedError = class extends Error {
+};
+var CodexTokenManager = class extends BaseRefreshManager {
+  constructor() {
+    super("CodexTokenManager");
+  }
+  getSkipReason() {
+    if (ENGINE_ENV.REPLICAS_CODEX_AUTH_METHOD === "api_key" || ENGINE_ENV.REPLICAS_CODEX_AUTH_METHOD === "foundry") {
+      return `auth method is ${ENGINE_ENV.REPLICAS_CODEX_AUTH_METHOD}`;
+    }
+    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();
+  }
+  async refreshWithRequest(request) {
+    console.log("[CodexTokenManager] Refreshing Codex credentials...");
+    const response = await monolithRequest("/v1/engine/codex/refresh-credentials", {
+      body: 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.applyCredentialsResponse(data);
+    if (data.scope) {
+      setAgentCredentialSnapshot("codex", {
+        method: data.type,
+        scope: data.scope,
+        ...data.revision ? { revision: data.revision } : {}
+      });
+    }
+    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();
+    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) {
+      const message = error instanceof Error ? error.message : String(error);
+      return createErrorResult({
+        message,
+        code: message.includes('"code":"no_credentials"') ? "no_credentials" : "refresh_failed"
+      });
+    }
+  }
+  async fetchFreshCredentials(failureReason, failureKind = "rejected", failedCredential = ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS.codex) {
+    const failedMethod = failedCredential?.method === "oauth" || failedCredential?.method === "api_key" || failedCredential?.method === "foundry" ? failedCredential.method : ENGINE_ENV.REPLICAS_CODEX_AUTH_METHOD;
+    return this.swapCredentials({
+      provider: "codex",
+      failureKind,
+      refresh: async (exclusions) => {
+        await this.refreshWithRequest(
+          failedMethod === "oauth" || failedMethod === "api_key" || 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",
+      newMethod: envVars.REPLICAS_CODEX_AUTH_METHOD ?? "none",
+      authKeys: CODEX_AUTH_ENV_KEYS,
+      authKeysByMethod: CODEX_AUTH_ENV_KEYS_BY_METHOD,
+      newEnvVars: envVars,
+      envs: [ENGINE_ENV, process.env]
+    });
+  }
+  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();
+
+export {
+  applyAuthEnvTransition,
+  recordCredentialFallback,
+  listCredentialFallbacks,
+  recordExhaustedCredential,
+  BaseRefreshManager,
+  monolithRequest,
+  monolithService,
+  CodexAspAuthMethodChangedError,
+  CodexTokenManager,
+  codexTokenManager
+};

package/dist/src/chunk-LO6ISJCF.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+import {
+  REPLICAS_RUNTIME_ENV_ALIASES,
+  agentCredentialSnapshotSchema,
+  isValidAgentProvider,
+  parsePosixEnvFile,
+  readReplicasRuntimeEnv
+} from "./chunk-6JWWD5NM.js";
+
+// src/engine-env.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+
+// src/runtime-env-loader.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function loadRuntimeEnvFile() {
+  let content;
+  try {
+    content = readFileSync(join(homedir(), ".replicas", "runtime-env.sh"), "utf-8");
+  } catch {
+    return;
+  }
+  for (const [key, value] of Object.entries(parsePosixEnvFile(content))) {
+    process.env[key] = value;
+  }
+}
+
+// src/utils/type-guards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/engine-env.ts
+var SANDBOX_IMAGE_VERSION_FILE = "/usr/local/lib/replicas-sandbox-image-version";
+function readEnv(name) {
+  const value = process.env[name]?.trim();
+  return value ? value : void 0;
+}
+function readSandboxImageVersion() {
+  const environmentVersion = readEnv("REPLICAS_SANDBOX_IMAGE_VERSION");
+  if (environmentVersion) return environmentVersion;
+  try {
+    return readFileSync2(SANDBOX_IMAGE_VERSION_FILE, "utf8").trim() || "development";
+  } catch {
+    return "development";
+  }
+}
+function parsePort(value) {
+  if (!value) {
+    return 3737;
+  }
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error("Invalid engine environment: REPLICAS_ENGINE_PORT must be a positive integer");
+  }
+  return parsed;
+}
+function requireDefined(value, name) {
+  if (value === void 0 || value === null) {
+    throw new Error(`Invalid engine environment: ${name} is required`);
+  }
+  return value;
+}
+function requireValidURL(value, name) {
+  try {
+    new URL(value);
+    return value;
+  } catch {
+    throw new Error(`Invalid engine environment: ${name} must be a valid URL`);
+  }
+}
+function parseClaudeAuthMethod(value) {
+  if (value === "oauth" || value === "api_key" || value === "bedrock" || value === "foundry") {
+    return value;
+  }
+  return void 0;
+}
+function parseCodexAuthMethod(value) {
+  if (value === "oauth" || value === "api_key" || value === "foundry") {
+    return value;
+  }
+  return void 0;
+}
+function parseAgentCredentialSnapshots(value) {
+  if (!value) return {};
+  try {
+    const parsed = JSON.parse(value);
+    if (!isRecord(parsed)) return {};
+    const snapshots = {};
+    for (const [provider, snapshot] of Object.entries(parsed)) {
+      if (!isValidAgentProvider(provider)) continue;
+      const parsedSnapshot = agentCredentialSnapshotSchema.safeParse(snapshot);
+      if (parsedSnapshot.success) snapshots[provider] = parsedSnapshot.data;
+    }
+    return snapshots;
+  } catch {
+    return {};
+  }
+}
+var IS_WARMING_MODE = process.argv.includes("--warming");
+function loadEngineEnv() {
+  loadRuntimeEnvFile();
+  const HOME_DIR = homedir2();
+  const env = {
+    // Defined: always available
+    REPLICAS_ENGINE_SECRET: requireDefined(readEnv("REPLICAS_ENGINE_SECRET"), "REPLICAS_ENGINE_SECRET"),
+    REPLICAS_ENGINE_PORT: parsePort(readEnv("REPLICAS_ENGINE_PORT")),
+    REPLICAS_MONOLITH_URL: requireValidURL(
+      requireDefined(readReplicasRuntimeEnv(readEnv, REPLICAS_RUNTIME_ENV_ALIASES.monolithUrl), "REPLICAS_MONOLITH_URL"),
+      "REPLICAS_MONOLITH_URL"
+    ),
+    HOME_DIR,
+    WORKSPACE_ROOT: join2(HOME_DIR, "workspaces"),
+    REPLICAS_SANDBOX_IMAGE_VERSION: readSandboxImageVersion(),
+    // Runtime: may not be set during warming
+    REPLICAS_WORKSPACE_ID: readReplicasRuntimeEnv(readEnv, REPLICAS_RUNTIME_ENV_ALIASES.workspaceId),
+    REPLICAS_LINEAR_SESSION_ID: readReplicasRuntimeEnv(readEnv, REPLICAS_RUNTIME_ENV_ALIASES.linearSessionId),
+    REPLICAS_LINEAR_ACCESS_TOKEN: readReplicasRuntimeEnv(readEnv, REPLICAS_RUNTIME_ENV_ALIASES.linearAccessToken),
+    REPLICAS_SLACK_BOT_TOKEN: readReplicasRuntimeEnv(readEnv, REPLICAS_RUNTIME_ENV_ALIASES.slackBotToken),
+    REPLICAS_SLACK_CHANNEL_ID: readReplicasRuntimeEnv(readEnv, REPLICAS_RUNTIME_ENV_ALIASES.slackChannelId),
+    REPLICAS_SLACK_THREAD_TS: readReplicasRuntimeEnv(readEnv, REPLICAS_RUNTIME_ENV_ALIASES.slackThreadTs),
+    ANTHROPIC_API_KEY: readEnv("ANTHROPIC_API_KEY"),
+    OPENAI_API_KEY: readEnv("OPENAI_API_KEY"),
+    CURSOR_API_KEY: readEnv("CURSOR_API_KEY"),
+    AI_GATEWAY_API_KEY: readEnv("AI_GATEWAY_API_KEY"),
+    CLAUDE_CODE_USE_BEDROCK: readEnv("CLAUDE_CODE_USE_BEDROCK"),
+    AWS_ACCESS_KEY_ID: readEnv("AWS_ACCESS_KEY_ID"),
+    AWS_SECRET_ACCESS_KEY: readEnv("AWS_SECRET_ACCESS_KEY"),
+    AWS_REGION: readEnv("AWS_REGION"),
+    ANTHROPIC_SMALL_FAST_MODEL_AWS_REGION: readEnv("ANTHROPIC_SMALL_FAST_MODEL_AWS_REGION"),
+    REPLICAS_CLAUDE_AUTH_METHOD: parseClaudeAuthMethod(readEnv("REPLICAS_CLAUDE_AUTH_METHOD")),
+    REPLICAS_CODEX_AUTH_METHOD: parseCodexAuthMethod(readEnv("REPLICAS_CODEX_AUTH_METHOD")),
+    REPLICAS_AGENT_CREDENTIALS: parseAgentCredentialSnapshots(readEnv("REPLICAS_AGENT_CREDENTIALS")),
+    REPLICAS_ENV_SYSTEM_PROMPT: readEnv("REPLICAS_ENV_SYSTEM_PROMPT"),
+    REPLICAS_ENV_START_HOOK: readEnv("REPLICAS_ENV_START_HOOK"),
+    REPLICAS_DISABLE_AUTO_START_HOOKS: readEnv("REPLICAS_DISABLE_AUTO_START_HOOKS")?.toLowerCase() === "true",
+    REPLICAS_ENGINE_DEFER_INITIALIZATION: readEnv("REPLICAS_ENGINE_DEFER_INITIALIZATION")?.toLowerCase() === "true"
+  };
+  if (!IS_WARMING_MODE && !env.REPLICAS_WORKSPACE_ID) {
+    console.error("REPLICAS_WORKSPACE_ID is not set \u2014 this is required in normal (non-warming) mode");
+  }
+  return env;
+}
+var ENGINE_ENV = loadEngineEnv();
+function setAgentCredentialSnapshot(provider, snapshot) {
+  ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS = {
+    ...ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS,
+    [provider]: snapshot
+  };
+  process.env.REPLICAS_AGENT_CREDENTIALS = JSON.stringify(ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS);
+}
+
+export {
+  isRecord,
+  IS_WARMING_MODE,
+  loadEngineEnv,
+  ENGINE_ENV,
+  setAgentCredentialSnapshot
+};

package/dist/src/chunk-XQW4B35Y.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+
+// src/utils/presigned-upload.ts
+import { createReadStream } from "fs";
+import { request as httpRequest } from "http";
+import { request as httpsRequest } from "https";
+async function putPresignedFile(urlValue, filePath, size, contentType) {
+  await new Promise((resolve, reject) => {
+    const url = new URL(urlValue);
+    const request = (url.protocol === "https:" ? httpsRequest : httpRequest)(url, {
+      method: "PUT",
+      headers: {
+        "content-length": String(size),
+        "content-type": contentType
+      }
+    }, (response) => {
+      response.setEncoding("utf8");
+      let body = "";
+      response.on("data", (chunk) => {
+        body += chunk;
+      });
+      response.on("end", () => {
+        const status = response.statusCode ?? 0;
+        if (status >= 200 && status < 300) resolve();
+        else reject(new Error(`upload failed: ${status} ${body}`));
+      });
+      response.on("error", reject);
+    });
+    request.on("error", reject);
+    const file = size > 0 ? createReadStream(filePath, { start: 0, end: size - 1 }) : createReadStream(filePath);
+    file.on("error", (error) => request.destroy(error));
+    file.pipe(request);
+  });
+}
+
+// src/utils/codex-agent-env.ts
+function buildCodexAgentEnv(source = process.env) {
+  const env = Object.fromEntries(
+    Object.entries(source).filter((entry) => typeof entry[1] === "string")
+  );
+  if (env.REPLICAS_CODEX_AUTH_METHOD === "oauth" || env.REPLICAS_CODEX_AUTH_METHOD === "foundry") {
+    delete env.OPENAI_API_KEY;
+  }
+  delete env.GH_TOKEN;
+  delete env.GITHUB_TOKEN;
+  delete env.GH_CONFIG_DIR;
+  return env;
+}
+
+// src/managers/codex-asp/notification-dispatch.ts
+var TURN_STARTED_METHOD = "turn/started";
+var TURN_COMPLETED_METHOD = "turn/completed";
+var TURN_PLAN_UPDATED_METHOD = "turn/plan/updated";
+var THREAD_GOAL_UPDATED_METHOD = "thread/goal/updated";
+var THREAD_GOAL_CLEARED_METHOD = "thread/goal/cleared";
+var ITEM_STARTED_METHOD = "item/started";
+var ITEM_COMPLETED_METHOD = "item/completed";
+var AGENT_MESSAGE_DELTA_METHOD = "item/agentMessage/delta";
+var REASONING_SUMMARY_TEXT_DELTA_METHOD = "item/reasoning/summaryTextDelta";
+var REASONING_TEXT_DELTA_METHOD = "item/reasoning/textDelta";
+var REASONING_SUMMARY_PART_ADDED_METHOD = "item/reasoning/summaryPartAdded";
+var COMMAND_EXECUTION_OUTPUT_DELTA_METHOD = "item/commandExecution/outputDelta";
+var FILE_CHANGE_OUTPUT_DELTA_METHOD = "item/fileChange/outputDelta";
+var ACCOUNT_RATE_LIMITS_UPDATED_METHOD = "account/rateLimits/updated";
+var THREAD_TOKEN_USAGE_UPDATED_METHOD = "thread/tokenUsage/updated";
+var THREAD_COMPACTED_METHOD = "thread/compacted";
+function dispatchAspNotification(notification, handlers) {
+  const handler = handlers[notification.method];
+  if (!handler) return;
+  handler(notification);
+}
+function recoverCompletedTurn(turn, completedItems, agentMessageDeltas) {
+  const items = turn.items.length > 0 ? [...turn.items] : [];
+  const itemIds = new Set(items.map((item) => item.id));
+  for (const item of completedItems) {
+    if (itemIds.has(item.id)) continue;
+    items.push(item);
+    itemIds.add(item.id);
+  }
+  for (const [itemId, text] of agentMessageDeltas) {
+    if (itemIds.has(itemId)) continue;
+    items.push({ type: "agentMessage", id: itemId, text, phase: null, memoryCitation: null });
+  }
+  return items.length > 0 ? { ...turn, items, itemsView: "full" } : turn;
+}
+
+export {
+  putPresignedFile,
+  buildCodexAgentEnv,
+  TURN_STARTED_METHOD,
+  TURN_COMPLETED_METHOD,
+  TURN_PLAN_UPDATED_METHOD,
+  THREAD_GOAL_UPDATED_METHOD,
+  THREAD_GOAL_CLEARED_METHOD,
+  ITEM_STARTED_METHOD,
+  ITEM_COMPLETED_METHOD,
+  AGENT_MESSAGE_DELTA_METHOD,
+  REASONING_SUMMARY_TEXT_DELTA_METHOD,
+  REASONING_TEXT_DELTA_METHOD,
+  REASONING_SUMMARY_PART_ADDED_METHOD,
+  COMMAND_EXECUTION_OUTPUT_DELTA_METHOD,
+  FILE_CHANGE_OUTPUT_DELTA_METHOD,
+  ACCOUNT_RATE_LIMITS_UPDATED_METHOD,
+  THREAD_TOKEN_USAGE_UPDATED_METHOD,
+  THREAD_COMPACTED_METHOD,
+  dispatchAspNotification,
+  recoverCompletedTurn
+};

package/dist/src/codex-token-manager-KL7GDOF4.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import {
+  CodexAspAuthMethodChangedError,
+  CodexTokenManager,
+  codexTokenManager
+} from "./chunk-IRM6KMN5.js";
+import "./chunk-LO6ISJCF.js";
+import "./chunk-6JWWD5NM.js";
+export {
+  CodexAspAuthMethodChangedError,
+  CodexTokenManager,
+  codexTokenManager
+};