@deepdream314/remodex 1.3.8 → 1.3.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepdream314/remodex",
-  "version": "1.3.8",
+  "version": "1.3.10",
   "description": "Local bridge between Codex and the Remodex mobile app. Run `remodex up` to start.",
   "main": "src/index.js",
   "bin": {

package/src/account-status.js

@@ -24,8 +24,11 @@ function composeAccountStatus({
   ]) || null;
   const tokenReady = Boolean(authToken);
   const requiresOpenaiAuth = Boolean(accountRead?.requiresOpenaiAuth || authStatus?.requiresOpenaiAuth);
-  const hasPriorLoginContext = hasAccountLogin || Boolean(authMethod);
-  const needsReauth = !loginInFlight && requiresOpenaiAuth && hasPriorLoginContext;
+  const needsReauth = !loginInFlight
+    && requiresOpenaiAuth
+    && !tokenReady
+    && !hasAccountLogin
+    && Boolean(authMethod);
   const isAuthenticated = !needsReauth && (tokenReady || hasAccountLogin);
   const status = isAuthenticated
     ? "authenticated"
@@ -77,6 +80,44 @@ function redactAuthStatus(authStatus = null, extras = {}) {
 
 // ─── Settled snapshot helpers ───────────────────────────────
 
+function applyLocalAuthFallbackToSettledAuthStatus(
+  authStatusResult = null,
+  localAuthResult = null
+) {
+  const localAuthStatus = localAuthResult?.status === "fulfilled" ? localAuthResult.value : null;
+  if (!localAuthStatus?.token || !localAuthStatus?.isChatGPT) {
+    return authStatusResult;
+  }
+
+  if (authStatusResult?.status === "fulfilled") {
+    const authStatus = authStatusResult.value;
+    if (normalizeString(authStatus?.authToken)) {
+      return authStatusResult;
+    }
+
+    return {
+      status: "fulfilled",
+      value: {
+        ...authStatus,
+        authMethod: normalizeString(localAuthStatus.authMethod)
+          || normalizeString(authStatus?.authMethod)
+          || "chatgpt",
+        authToken: localAuthStatus.token,
+        requiresOpenaiAuth: localAuthStatus.requiresOpenaiAuth ?? authStatus?.requiresOpenaiAuth,
+      },
+    };
+  }
+
+  return {
+    status: "fulfilled",
+    value: {
+      authMethod: normalizeString(localAuthStatus.authMethod) || "chatgpt",
+      authToken: localAuthStatus.token,
+      requiresOpenaiAuth: localAuthStatus.requiresOpenaiAuth,
+    },
+  };
+}
+
 // Collapses settled bridge RPC results into one safe snapshot, even if one side fails.
 // Input: Promise.allSettled-style results → Output: sanitized account status object
 // Throws if both the account read and auth status fail, so the bridge can surface a real error.
@@ -138,6 +179,7 @@ function parseBoolean(value) {
 }
 
 module.exports = {
+  applyLocalAuthFallbackToSettledAuthStatus,
   composeAccountStatus,
   composeSanitizedAuthStatusFromSettledResults,
   redactAuthStatus,

package/src/bridge.js

@@ -22,8 +22,13 @@ const { handleGitRequest } = require("./git-handler");
 const { handleThreadContextRequest } = require("./thread-context-handler");
 const { handleWorkspaceRequest } = require("./workspace-handler");
 const { createNotificationsHandler } = require("./notifications-handler");
-const { createVoiceHandler, resolveVoiceAuth } = require("./voice-handler");
 const {
+  createVoiceHandler,
+  readLocalChatGPTAuthTokenFromDisk,
+  resolveVoiceAuth,
+} = require("./voice-handler");
+const {
+  applyLocalAuthFallbackToSettledAuthStatus,
   composeSanitizedAuthStatusFromSettledResults,
 } = require("./account-status");
 const { createBridgePackageVersionStatusReader } = require("./package-version-status");
@@ -528,7 +533,7 @@ function startBridge({
       case "account/login/openOnMac":
         return openPendingAuthLoginOnMac(params);
       case "voice/resolveAuth":
-        return resolveVoiceAuth(sendCodexRequest);
+        return resolveVoiceAuth(sendCodexRequest, params);
       default:
         throw new Error(`Unsupported bridge-managed account method: ${method}`);
     }
@@ -537,15 +542,16 @@ function startBridge({
   // Combines account/read + getAuthStatus into one safe snapshot for the phone UI.
   // The two RPCs are settled independently so one transient failure does not hide the other.
   async function readSanitizedAuthStatus() {
-    const [accountReadResult, authStatusResult, bridgeVersionInfoResult] = await Promise.allSettled([
+    const [accountReadResult, authStatusResult, bridgeVersionInfoResult, localAuthResult] = await Promise.allSettled([
       sendCodexRequest("account/read", {
         refreshToken: false,
       }),
       sendCodexRequest("getAuthStatus", {
         includeToken: true,
-        refreshToken: true,
+        refreshToken: false,
       }),
       readBridgePackageVersionStatus(),
+      readLocalChatGPTAuthTokenFromDisk(),
     ]);
 
     return composeSanitizedAuthStatusFromSettledResults({
@@ -555,7 +561,7 @@ function startBridge({
           value: normalizeAccountRead(accountReadResult.value),
         }
         : accountReadResult,
-      authStatusResult,
+      authStatusResult: applyLocalAuthFallbackToSettledAuthStatus(authStatusResult, localAuthResult),
       loginInFlight: Boolean(pendingAuthLogin.loginId),
       bridgeVersionInfo: bridgeVersionInfoResult.status === "fulfilled"
         ? bridgeVersionInfoResult.value

package/src/voice-handler.js

@@ -4,6 +4,10 @@
 // Exports: createVoiceHandler
 // Depends on: global fetch/FormData/Blob, local codex app-server auth via sendCodexRequest
 
+const fs = require("fs/promises");
+const os = require("os");
+const path = require("path");
+
 const CHATGPT_TRANSCRIPTIONS_URL = "https://chatgpt.com/backend-api/transcribe";
 const MAX_AUDIO_BYTES = 10 * 1024 * 1024;
 const MAX_DURATION_MS = 60_000;
@@ -13,6 +17,7 @@ function createVoiceHandler({
   fetchImpl = globalThis.fetch,
   FormDataImpl = globalThis.FormData,
   BlobImpl = globalThis.Blob,
+  readLocalAuthToken = readLocalChatGPTAuthTokenFromDisk,
   logPrefix = "[remodex]",
 } = {}) {
   function handleVoiceRequest(rawMessage, sendResponse) {
@@ -36,6 +41,7 @@ function createVoiceHandler({
       fetchImpl,
       FormDataImpl,
       BlobImpl,
+      readLocalAuthToken,
     })
       .then((result) => {
         sendResponse(JSON.stringify({ id, result }));
@@ -67,7 +73,7 @@ function createVoiceHandler({
 // Validates iPhone-owned audio input and proxies it to the official transcription endpoint.
 async function transcribeVoice(
   params,
-  { sendCodexRequest, fetchImpl, FormDataImpl, BlobImpl }
+  { sendCodexRequest, fetchImpl, FormDataImpl, BlobImpl, readLocalAuthToken }
 ) {
   if (typeof sendCodexRequest !== "function") {
     throw voiceError("bridge_not_ready", "Voice transcription is not available right now.");
@@ -99,7 +105,7 @@ async function transcribeVoice(
     throw voiceError("audio_too_large", "Voice messages are limited to 10 MB.");
   }
 
-  const authContext = await loadAuthContext(sendCodexRequest);
+  const authContext = await loadAuthContext(sendCodexRequest, { readLocalAuthToken });
   return requestTranscription({
     authContext,
     audioBuffer,
@@ -108,6 +114,7 @@ async function transcribeVoice(
     FormDataImpl,
     BlobImpl,
     sendCodexRequest,
+    readLocalAuthToken,
   });
 }
 
@@ -119,6 +126,7 @@ async function requestTranscription({
   FormDataImpl,
   BlobImpl,
   sendCodexRequest,
+  readLocalAuthToken,
 }) {
   const makeAttempt = async (activeAuthContext) => {
     const formData = new FormDataImpl();
@@ -137,7 +145,10 @@ async function requestTranscription({
 
   let response = await makeAttempt(authContext);
   if (response.status === 401) {
-    const refreshedAuthContext = await loadAuthContext(sendCodexRequest);
+    const refreshedAuthContext = await loadAuthContext(sendCodexRequest, {
+      forceRefresh: true,
+      readLocalAuthToken,
+    });
     response = await makeAttempt(refreshedAuthContext);
   }
 
@@ -170,16 +181,18 @@ async function requestTranscription({
 }
 
 // Reads the current bridge-owned auth state from the local codex app-server and refreshes if needed.
-async function loadAuthContext(sendCodexRequest) {
-  const authStatus = await sendCodexRequest("getAuthStatus", {
-    includeToken: true,
-    refreshToken: true,
+async function loadAuthContext(
+  sendCodexRequest,
+  {
+    forceRefresh = false,
+    readLocalAuthToken = readLocalChatGPTAuthTokenFromDisk,
+  } = {}
+) {
+  const { authMethod, token, isChatGPT } = await resolveCurrentOrRefreshedAuthStatus(sendCodexRequest, {
+    forceRefresh,
+    readLocalAuthToken,
   });
 
-  const authMethod = readString(authStatus?.authMethod);
-  const token = readString(authStatus?.authToken);
-  const isChatGPT = authMethod === "chatgpt" || authMethod === "chatgptAuthTokens";
-
   if (!token) {
     throw voiceError("not_authenticated", "Sign in with ChatGPT before using voice transcription.");
   }
@@ -284,21 +297,18 @@ function voiceError(errorCode, userMessage) {
 
 // Returns an ephemeral ChatGPT token so the phone can call the transcription API directly.
 // Uses its own token resolution instead of loadAuthContext so errors are specific and actionable.
-async function resolveVoiceAuth(sendCodexRequest) {
-  let authStatus;
-  try {
-    authStatus = await sendCodexRequest("getAuthStatus", {
-      includeToken: true,
-      refreshToken: true,
-    });
-  } catch (err) {
-    console.error(`[remodex] voice/resolveAuth: getAuthStatus RPC failed: ${err.message}`);
-    throw voiceError("auth_unavailable", "Could not read ChatGPT session from the Mac runtime. Is the bridge running?");
-  }
-
-  const authMethod = readString(authStatus?.authMethod);
-  const token = readString(authStatus?.authToken);
-  const isChatGPT = authMethod === "chatgpt" || authMethod === "chatgptAuthTokens";
+async function resolveVoiceAuth(
+  sendCodexRequest,
+  params = null,
+  { readLocalAuthToken = readLocalChatGPTAuthTokenFromDisk } = {}
+) {
+  const forceRefresh = Boolean(params?.forceRefresh);
+  const { authMethod, token, isChatGPT, requiresOpenaiAuth } = await resolveCurrentOrRefreshedAuthStatus(sendCodexRequest, {
+    forceRefresh,
+    readLocalAuthToken,
+    rpcErrorCode: "auth_unavailable",
+    rpcErrorMessage: "Could not read ChatGPT session from the Mac runtime. Is the bridge running?",
+  });
 
   // Check for a usable ChatGPT token first. The runtime may set requiresOpenaiAuth
   // even when a valid ChatGPT session is present (the flag is about the runtime's
@@ -308,14 +318,120 @@ async function resolveVoiceAuth(sendCodexRequest) {
   }
 
   if (!token) {
-    console.error(`[remodex] voice/resolveAuth: no token. authMethod=${authMethod || "none"} requiresOpenaiAuth=${authStatus?.requiresOpenaiAuth}`);
+    console.error(`[remodex] voice/resolveAuth: no token. authMethod=${authMethod || "none"} requiresOpenaiAuth=${requiresOpenaiAuth}`);
     throw voiceError("token_missing", "No ChatGPT session token available. Sign in to ChatGPT on the Mac.");
   }
 
   throw voiceError("not_chatgpt", "Voice transcription requires a ChatGPT account.");
 }
 
+async function resolveCurrentOrRefreshedAuthStatus(
+  sendCodexRequest,
+  {
+    forceRefresh = false,
+    readLocalAuthToken = readLocalChatGPTAuthTokenFromDisk,
+    rpcErrorCode = "not_authenticated",
+    rpcErrorMessage = "Sign in with ChatGPT before using voice transcription.",
+  } = {}
+) {
+  if (forceRefresh) {
+    const refreshedStatus = await readAuthStatus(sendCodexRequest, {
+      refreshToken: true,
+      rpcErrorCode,
+      rpcErrorMessage,
+    });
+    return withLocalAuthFallback(refreshedStatus, readLocalAuthToken);
+  }
+
+  const currentStatus = await withLocalAuthFallback(
+    await readAuthStatus(sendCodexRequest, {
+      refreshToken: false,
+      rpcErrorCode,
+      rpcErrorMessage,
+    }),
+    readLocalAuthToken
+  );
+
+  if (currentStatus.token) {
+    return currentStatus;
+  }
+
+  const refreshedStatus = await readAuthStatus(sendCodexRequest, {
+    refreshToken: true,
+    rpcErrorCode,
+    rpcErrorMessage,
+  });
+
+  return withLocalAuthFallback(refreshedStatus, readLocalAuthToken);
+}
+
+async function withLocalAuthFallback(status, readLocalAuthToken) {
+  if (status?.token || typeof readLocalAuthToken !== "function") {
+    return status;
+  }
+
+  const localAuthStatus = await readLocalAuthToken().catch(() => null);
+  if (!localAuthStatus?.token || !localAuthStatus?.isChatGPT) {
+    return status;
+  }
+
+  return {
+    authMethod: localAuthStatus.authMethod || status.authMethod || "chatgpt",
+    token: localAuthStatus.token,
+    isChatGPT: true,
+    requiresOpenaiAuth: localAuthStatus.requiresOpenaiAuth ?? status.requiresOpenaiAuth,
+  };
+}
+
+async function readLocalChatGPTAuthTokenFromDisk({
+  readFileImpl = fs.readFile,
+  codexHome = process.env.CODEX_HOME || path.join(os.homedir(), ".codex"),
+} = {}) {
+  const authFile = path.join(codexHome, "auth.json");
+  const contents = await readFileImpl(authFile, "utf8");
+  const auth = JSON.parse(contents);
+  const authMethod = readString(auth?.auth_mode);
+  const tokenContainer = auth?.tokens && typeof auth.tokens === "object" ? auth.tokens : auth;
+  const token = readString(tokenContainer?.access_token);
+  const isChatGPT = token != null
+    && authMethod !== "apikey"
+    && authMethod !== "api_key"
+    && authMethod !== "apiKey";
+
+  return {
+    authMethod: authMethod || (isChatGPT ? "chatgpt" : null),
+    token,
+    isChatGPT,
+    requiresOpenaiAuth: isChatGPT,
+  };
+}
+
+async function readAuthStatus(
+  sendCodexRequest,
+  { refreshToken, rpcErrorCode, rpcErrorMessage }
+) {
+  let authStatus;
+  try {
+    authStatus = await sendCodexRequest("getAuthStatus", {
+      includeToken: true,
+      refreshToken,
+    });
+  } catch (err) {
+    throw voiceError(rpcErrorCode, rpcErrorMessage);
+  }
+
+  const authMethod = readString(authStatus?.authMethod);
+  const token = readString(authStatus?.authToken);
+  return {
+    authMethod,
+    token,
+    isChatGPT: authMethod === "chatgpt" || authMethod === "chatgptAuthTokens",
+    requiresOpenaiAuth: Boolean(authStatus?.requiresOpenaiAuth),
+  };
+}
+
 module.exports = {
   createVoiceHandler,
+  readLocalChatGPTAuthTokenFromDisk,
   resolveVoiceAuth,
 };