@deepdream314/remodex 1.3.8

package/bin/phodex.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// FILE: phodex.js
+// Purpose: Backward-compatible wrapper that forwards legacy `phodex up` usage to `remodex up`.
+// Layer: CLI binary
+// Exports: none
+// Depends on: ./remodex
+
+const { main } = require("./remodex");
+
+void main();

package/bin/remodex.js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+// FILE: remodex.js
+// Purpose: CLI surface for foreground bridge runs, pairing reset, thread resume, and macOS service control.
+// Layer: CLI binary
+// Exports: none
+// Depends on: ../src
+
+const {
+  getMacOSBridgeServiceStatus,
+  printMacOSBridgePairingQr,
+  printMacOSBridgeServiceStatus,
+  readBridgeConfig,
+  resetMacOSBridgePairing,
+  runMacOSBridgeService,
+  startBridge,
+  startMacOSBridgeService,
+  stopMacOSBridgeService,
+  resetBridgePairing,
+  openLastActiveThread,
+  watchThreadRollout,
+} = require("../src");
+const { version } = require("../package.json");
+
+const defaultDeps = {
+  getMacOSBridgeServiceStatus,
+  printMacOSBridgePairingQr,
+  printMacOSBridgeServiceStatus,
+  readBridgeConfig,
+  resetMacOSBridgePairing,
+  runMacOSBridgeService,
+  startBridge,
+  startMacOSBridgeService,
+  stopMacOSBridgeService,
+  resetBridgePairing,
+  openLastActiveThread,
+  watchThreadRollout,
+};
+
+if (require.main === module) {
+  void main();
+}
+
+// ─── ENTRY POINT ─────────────────────────────────────────────
+
+async function main({
+  argv = process.argv,
+  platform = process.platform,
+  consoleImpl = console,
+  exitImpl = process.exit,
+  deps = defaultDeps,
+} = {}) {
+  const { command, jsonOutput, watchThreadId } = parseCliArgs(argv.slice(2));
+
+  if (isVersionCommand(command)) {
+    emitVersion({ jsonOutput, consoleImpl });
+    return;
+  }
+
+  if (command === "up") {
+    if (platform === "darwin") {
+      const result = await deps.startMacOSBridgeService({
+        waitForPairing: true,
+      });
+      deps.printMacOSBridgePairingQr({
+        pairingSession: result.pairingSession,
+      });
+      return;
+    }
+
+    deps.startBridge();
+    return;
+  }
+
+  if (command === "run") {
+    deps.startBridge();
+    return;
+  }
+
+  if (command === "run-service") {
+    deps.runMacOSBridgeService();
+    return;
+  }
+
+  if (command === "start") {
+    assertMacOSCommand(command, {
+      platform,
+      consoleImpl,
+      exitImpl,
+    });
+    deps.readBridgeConfig();
+    const result = await deps.startMacOSBridgeService({
+      waitForPairing: false,
+    });
+    emitResult({
+      payload: {
+        ok: true,
+        currentVersion: version,
+        plistPath: result?.plistPath,
+        pairingSession: result?.pairingSession,
+      },
+      message: "[remodex] macOS bridge service is running.",
+      jsonOutput,
+      consoleImpl,
+    });
+    return;
+  }
+
+  if (command === "restart") {
+    assertMacOSCommand(command, {
+      platform,
+      consoleImpl,
+      exitImpl,
+    });
+    deps.readBridgeConfig();
+    const result = await deps.startMacOSBridgeService({
+      waitForPairing: false,
+    });
+    emitResult({
+      payload: {
+        ok: true,
+        currentVersion: version,
+        plistPath: result?.plistPath,
+        pairingSession: result?.pairingSession,
+      },
+      message: "[remodex] macOS bridge service restarted.",
+      jsonOutput,
+      consoleImpl,
+    });
+    return;
+  }
+
+  if (command === "stop") {
+    assertMacOSCommand(command, {
+      platform,
+      consoleImpl,
+      exitImpl,
+    });
+    deps.stopMacOSBridgeService();
+    emitResult({
+      payload: {
+        ok: true,
+        currentVersion: version,
+      },
+      message: "[remodex] macOS bridge service stopped.",
+      jsonOutput,
+      consoleImpl,
+    });
+    return;
+  }
+
+  if (command === "status") {
+    assertMacOSCommand(command, {
+      platform,
+      consoleImpl,
+      exitImpl,
+    });
+    if (jsonOutput) {
+      emitJson({
+        ...deps.getMacOSBridgeServiceStatus(),
+        currentVersion: version,
+      });
+      return;
+    }
+    deps.printMacOSBridgeServiceStatus();
+    return;
+  }
+
+  if (command === "reset-pairing") {
+    try {
+      if (platform === "darwin") {
+        deps.resetMacOSBridgePairing();
+        emitResult({
+          payload: {
+            ok: true,
+            currentVersion: version,
+            platform: "darwin",
+          },
+          message: "[remodex] Stopped the macOS bridge service and cleared the saved pairing state. Run `remodex up` to pair again.",
+          jsonOutput,
+          consoleImpl,
+        });
+      } else {
+        deps.resetBridgePairing();
+        emitResult({
+          payload: {
+            ok: true,
+            currentVersion: version,
+            platform,
+          },
+          message: "[remodex] Cleared the saved pairing state. Run `remodex up` to pair again.",
+          jsonOutput,
+          consoleImpl,
+        });
+      }
+    } catch (error) {
+      consoleImpl.error(`[remodex] ${(error && error.message) || "Failed to clear the saved pairing state."}`);
+      exitImpl(1);
+    }
+    return;
+  }
+
+  if (command === "resume") {
+    try {
+      const state = deps.openLastActiveThread();
+      emitResult({
+        payload: {
+          ok: true,
+          currentVersion: version,
+          threadId: state.threadId,
+          source: state.source || "unknown",
+        },
+        message: `[remodex] Opened last active thread: ${state.threadId} (${state.source || "unknown"})`,
+        jsonOutput,
+        consoleImpl,
+      });
+    } catch (error) {
+      consoleImpl.error(`[remodex] ${(error && error.message) || "Failed to reopen the last thread."}`);
+      exitImpl(1);
+    }
+    return;
+  }
+
+  if (command === "watch") {
+    try {
+      deps.watchThreadRollout(watchThreadId);
+    } catch (error) {
+      consoleImpl.error(`[remodex] ${(error && error.message) || "Failed to watch the thread rollout."}`);
+      exitImpl(1);
+    }
+    return;
+  }
+
+  consoleImpl.error(`Unknown command: ${command}`);
+  consoleImpl.error(
+    "Usage: remodex up | remodex run | remodex start | remodex restart | remodex stop | remodex status | "
+    + "remodex reset-pairing | remodex resume | remodex watch [threadId] | remodex --version | "
+    + "append --json to start/restart/stop/status/reset-pairing/resume for machine-readable output"
+  );
+  exitImpl(1);
+}
+
+function parseCliArgs(rawArgs) {
+  const positionals = [];
+  let jsonOutput = false;
+
+  for (const arg of rawArgs) {
+    if (arg === "--json") {
+      jsonOutput = true;
+      continue;
+    }
+
+    positionals.push(arg);
+  }
+
+  return {
+    command: positionals[0] || "up",
+    jsonOutput,
+    watchThreadId: positionals[1] || "",
+  };
+}
+
+function emitVersion({
+  jsonOutput = false,
+  consoleImpl = console,
+} = {}) {
+  if (jsonOutput) {
+    emitJson({
+      currentVersion: version,
+    });
+    return;
+  }
+
+  consoleImpl.log(version);
+}
+
+function emitResult({
+  payload,
+  message,
+  jsonOutput = false,
+  consoleImpl = console,
+} = {}) {
+  if (jsonOutput) {
+    emitJson(payload);
+    return;
+  }
+
+  consoleImpl.log(message);
+}
+
+function emitJson(payload) {
+  process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+}
+
+function assertMacOSCommand(name, {
+  platform = process.platform,
+  consoleImpl = console,
+  exitImpl = process.exit,
+} = {}) {
+  if (platform === "darwin") {
+    return;
+  }
+
+  consoleImpl.error(`[remodex] \`${name}\` is only available on macOS. Use \`remodex up\` or \`remodex run\` for the foreground bridge on this OS.`);
+  exitImpl(1);
+}
+
+function isVersionCommand(value) {
+  return value === "-v" || value === "--v" || value === "-V" || value === "--version" || value === "version";
+}
+
+module.exports = {
+  isVersionCommand,
+  main,
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@deepdream314/remodex",
+  "version": "1.3.8",
+  "description": "Local bridge between Codex and the Remodex mobile app. Run `remodex up` to start.",
+  "main": "src/index.js",
+  "bin": {
+    "remodex": "./bin/remodex.js"
+  },
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "scripts": {
+    "start": "node ./bin/remodex.js up",
+    "test": "node --test ./test/*.test.js",
+    "prepack": "node ./scripts/prepare-private-defaults.js",
+    "postpack": "node ./scripts/cleanup-private-defaults.js"
+  },
+  "keywords": [
+    "remodex",
+    "codex",
+    "bridge",
+    "cli"
+  ],
+  "author": "Emanuele Di Pietro",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "qrcode-terminal": "^0.12.0",
+    "ws": "^8.19.0"
+  }
+}

package/src/account-status.js

@@ -0,0 +1,144 @@
+// FILE: account-status.js
+// Purpose: Converts raw codex account/auth responses into a sanitized status payload for the phone UI.
+// Layer: CLI helper
+// Exports: composeAccountStatus, composeSanitizedAuthStatusFromSettledResults, redactAuthStatus
+// Depends on: none
+
+const { version: bridgePackageVersion = "" } = require("../package.json");
+
+// ─── Status composition ─────────────────────────────────────
+
+function composeAccountStatus({
+  accountRead = null,
+  authStatus = null,
+  loginInFlight = false,
+  bridgeVersionInfo = null,
+  transportMode = null,
+} = {}) {
+  const account = accountRead?.account || null;
+  const authToken = normalizeString(authStatus?.authToken);
+  const hasAccountLogin = hasExplicitAccountLogin(account);
+  const authMethod = firstNonEmpty([
+    normalizeString(authStatus?.authMethod),
+    normalizeString(account?.type),
+  ]) || null;
+  const tokenReady = Boolean(authToken);
+  const requiresOpenaiAuth = Boolean(accountRead?.requiresOpenaiAuth || authStatus?.requiresOpenaiAuth);
+  const hasPriorLoginContext = hasAccountLogin || Boolean(authMethod);
+  const needsReauth = !loginInFlight && requiresOpenaiAuth && hasPriorLoginContext;
+  const isAuthenticated = !needsReauth && (tokenReady || hasAccountLogin);
+  const status = isAuthenticated
+    ? "authenticated"
+    : (loginInFlight ? "pending_login" : (needsReauth ? "expired" : "not_logged_in"));
+
+  return {
+    status,
+    authMethod,
+    email: normalizeString(account?.email) || null,
+    planType: normalizeString(account?.planType) || null,
+    loginInFlight: Boolean(loginInFlight),
+    needsReauth,
+    tokenReady,
+    expiresAt: null,
+    requiresOpenaiAuth,
+    bridgeVersion: firstNonEmpty([
+      normalizeString(bridgeVersionInfo?.bridgeVersion),
+      normalizeString(bridgePackageVersion),
+    ]) || null,
+    bridgeLatestVersion: normalizeString(bridgeVersionInfo?.bridgeLatestVersion) || null,
+    codexTransportMode: normalizeString(transportMode) || null,
+  };
+}
+
+// Removes any token-bearing fields before the bridge sends auth state to the phone.
+function redactAuthStatus(authStatus = null, extras = {}) {
+  const composed = composeAccountStatus({
+    accountRead: extras.accountRead || null,
+    authStatus,
+    loginInFlight: Boolean(extras.loginInFlight),
+    bridgeVersionInfo: extras.bridgeVersionInfo || null,
+    transportMode: extras.transportMode || null,
+  });
+
+  return {
+    authMethod: composed.authMethod,
+    status: composed.status,
+    email: composed.email,
+    planType: composed.planType,
+    loginInFlight: composed.loginInFlight,
+    needsReauth: composed.needsReauth,
+    tokenReady: composed.tokenReady,
+    expiresAt: composed.expiresAt,
+    bridgeVersion: composed.bridgeVersion,
+    bridgeLatestVersion: composed.bridgeLatestVersion,
+    codexTransportMode: composed.codexTransportMode,
+  };
+}
+
+// ─── Settled snapshot helpers ───────────────────────────────
+
+// 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.
+function composeSanitizedAuthStatusFromSettledResults({
+  accountReadResult = null,
+  authStatusResult = null,
+  loginInFlight = false,
+  bridgeVersionInfo = null,
+  transportMode = null,
+} = {}) {
+  const accountRead = accountReadResult?.status === "fulfilled" ? accountReadResult.value : null;
+  const authStatus = authStatusResult?.status === "fulfilled" ? authStatusResult.value : null;
+
+  if (!accountRead && !authStatus) {
+    const error = new Error("Unable to read ChatGPT account status from the bridge.");
+    error.errorCode = "auth_status_unavailable";
+    throw error;
+  }
+
+  return redactAuthStatus(authStatus, {
+    accountRead,
+    loginInFlight: Boolean(loginInFlight),
+    bridgeVersionInfo,
+    transportMode,
+  });
+}
+
+// Treat explicit account signals as authenticated when the token read is temporarily unavailable.
+function hasExplicitAccountLogin(account) {
+  if (!account || typeof account !== "object") {
+    return false;
+  }
+
+  if (parseBoolean(account.loggedIn) || parseBoolean(account.logged_in) || parseBoolean(account.isLoggedIn)) {
+    return true;
+  }
+
+  return Boolean(normalizeString(account.email));
+}
+
+// Normalizes empty strings and picks the first meaningful value from a short list.
+function firstNonEmpty(values) {
+  for (const value of values) {
+    const normalized = normalizeString(value);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  return "";
+}
+
+// Keeps auth/account fields compact and consistent in the status snapshot.
+function normalizeString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function parseBoolean(value) {
+  return value === true;
+}
+
+module.exports = {
+  composeAccountStatus,
+  composeSanitizedAuthStatusFromSettledResults,
+  redactAuthStatus,
+};