remote-codex 0.11.7 → 0.11.9

package/apps/supervisor-api/dist/{chunk-ZWZQVPDT.js → chunk-NWZLUCQV.js}

@@ -83,6 +83,8 @@ var envSchema = z.object({
   REMOTE_CODEX_MODE: z.enum(["local", "server", "relay"]).optional(),
   HOST: z.string().min(1).optional(),
   PORT: z.coerce.number().int().positive().optional(),
+  REMOTE_CODEX_RELAY_SUPERVISOR_HOST: z.string().min(1).optional(),
+  REMOTE_CODEX_RELAY_SUPERVISOR_PORT: z.coerce.number().int().positive().optional(),
   LOG_LEVEL: z.enum(["trace", "debug", "info", "warn", "error", "fatal"]).optional(),
   DISABLE_REQUEST_LOGGING: z.string().optional(),
   REMOTE_CODEX_MANAGEMENT_ROUTES_ENABLED: z.string().optional(),
@@ -131,6 +133,10 @@ function normalizeOptionalEnv(env) {
     ...env,
     WORKSPACE_ROOT: optionalNonEmpty(env.WORKSPACE_ROOT),
     DATABASE_URL: optionalNonEmpty(env.DATABASE_URL),
+    HOST: optionalNonEmpty(env.HOST),
+    PORT: optionalNonEmpty(env.PORT),
+    REMOTE_CODEX_RELAY_SUPERVISOR_HOST: optionalNonEmpty(env.REMOTE_CODEX_RELAY_SUPERVISOR_HOST),
+    REMOTE_CODEX_RELAY_SUPERVISOR_PORT: optionalNonEmpty(env.REMOTE_CODEX_RELAY_SUPERVISOR_PORT),
     REMOTE_CODEX_ADMIN_USERNAME: optionalNonEmpty(env.REMOTE_CODEX_ADMIN_USERNAME),
     REMOTE_CODEX_ADMIN_PASSWORD: optionalNonEmpty(env.REMOTE_CODEX_ADMIN_PASSWORD),
     REMOTE_CODEX_SESSION_SECRET: optionalNonEmpty(env.REMOTE_CODEX_SESSION_SECRET),
@@ -181,9 +187,9 @@ function loadRuntimeConfig(env = process.env) {
     runtimeRole,
     sandboxId: parsed.REMOTE_CODEX_SANDBOX_ID ?? null,
     userId: parsed.REMOTE_CODEX_USER_ID ?? null,
-    host: parsed.HOST ?? (runtimeRole === "worker" ? "0.0.0.0" : "127.0.0.1"),
+    host: parsed.REMOTE_CODEX_RELAY_SUPERVISOR_HOST ?? parsed.HOST ?? (runtimeRole === "worker" ? "0.0.0.0" : "127.0.0.1"),
     mode,
-    port: parsed.PORT ?? 8787,
+    port: parsed.REMOTE_CODEX_RELAY_SUPERVISOR_PORT ?? parsed.PORT ?? 8787,
     logLevel: parsed.LOG_LEVEL ?? (nodeEnv === "production" ? "warn" : "info"),
     disableRequestLogging,
     managementRoutesEnabled: parseBoolean(
@@ -9497,6 +9503,9 @@ var LocalCodexSessionStore = class {
     };
   }
   async findImportSession(sessionId, input) {
+    if (input.provider && input.provider !== "codex") {
+      return null;
+    }
     const localSession = await this.findSession(sessionId);
     if (!localSession) {
       return null;
@@ -18298,11 +18307,36 @@ var ThreadSessionCoordinator = class {
   async findLocalFallbackSession(providerSessionId) {
     return this.localSessionLookup.findSession(providerSessionId);
   }
-  async resolveLocalImportSession(sessionId) {
-    return this.localSessionLookup.findImportSession(sessionId, {
-      fastMode: this.performanceModeSettings.readFastMode()
+  async resolveLocalImportSession(input) {
+    const provider = normalizeAgentBackendId(input.provider) ?? "codex";
+    if (provider !== "codex") {
+      return this.resolveRuntimeImportSession(provider, input.sessionId);
+    }
+    return this.localSessionLookup.findImportSession(input.sessionId, {
+      fastMode: this.performanceModeSettings.readFastMode(),
+      provider
     });
   }
+  async resolveRuntimeImportSession(provider, sessionId) {
+    try {
+      const session = await this.providerRuntime.runtimeForProvider(provider).readSession(sessionId);
+      if (!session.cwd) {
+        return null;
+      }
+      return {
+        provider,
+        source: "supervisor",
+        sessionId,
+        cwd: session.cwd,
+        title: session.title?.trim() || session.preview?.trim() || "Untitled imported session",
+        model: null,
+        summaryText: session.preview,
+        fastMode: this.providerRuntime.runtimeSupportsFastMode(provider) ? this.performanceModeSettings.readFastMode() : false
+      };
+    } catch {
+      return null;
+    }
+  }
   async readRemoteSession(input) {
     const runtime = this.providerRuntime.runtimeForProvider(input.provider);
     try {
@@ -20190,25 +20224,27 @@ var ThreadImportCoordinator = class {
   db;
   sessionCoordinator;
   workspaceRoot;
-  async importLocalCodexThread(sessionId) {
-    const normalizedSessionId = sessionId.trim();
+  async importLocalThread(input) {
+    const normalizedSessionId = input.sessionId.trim();
     if (!normalizedSessionId) {
       throw new HttpError(400, {
         code: "bad_request",
         message: "Session id is required."
       });
     }
+    const provider = normalizeAgentBackendId(input.provider ?? "codex") ?? "codex";
     const existingThread = getThreadRecordByProviderSessionId(
       this.db,
-      "codex",
+      provider,
       normalizedSessionId
     );
     if (existingThread) {
       return existingThread.id;
     }
-    const importSession = await this.sessionCoordinator.resolveLocalImportSession(
-      normalizedSessionId
-    );
+    const importSession = await this.sessionCoordinator.resolveLocalImportSession({
+      provider,
+      sessionId: normalizedSessionId
+    });
     if (!importSession) {
       throw new HttpError(404, {
         code: "not_found",
@@ -20709,8 +20745,8 @@ var ThreadService = class {
     const record = getThreadRecordById(this.db, created.id);
     return this.toThreadDto(record, /* @__PURE__ */ new Set([session.response.providerSessionId]));
   }
-  async importThread(sessionId) {
-    const localThreadId = await this.importCoordinator.importLocalCodexThread(sessionId);
+  async importThread(input) {
+    const localThreadId = await this.importCoordinator.importLocalThread(input);
     return this.getThreadDetail(localThreadId);
   }
   async getThreadDetail(localThreadId, options = {}) {
@@ -22597,7 +22633,8 @@ var interruptSchema = z5.object({
   turnId: z5.string().optional()
 });
 var importThreadSchema = z5.object({
-  sessionId: z5.string().min(1)
+  sessionId: z5.string().min(1),
+  provider: agentBackendIdSchema.optional()
 });
 var resumeThreadSchema = z5.object({
   model: z5.string().min(1).optional(),
@@ -22827,7 +22864,11 @@ async function registerThreadRoutes(app) {
   });
   app.post("/api/threads/import", async (request) => {
     const body = importThreadSchema.parse(request.body);
-    return app.services.threadService.importThread(body.sessionId);
+    const input = {
+      sessionId: body.sessionId,
+      ...body.provider ? { provider: body.provider } : {}
+    };
+    return app.services.threadService.importThread(input);
   });
   app.get("/api/threads/:id", async (request) => {
     const params = z5.object({ id: z5.string().uuid() }).parse(request.params);