clawdex-mobile 3.0.0 → 5.0.0

package/scripts/setup-wizard.sh

@@ -28,16 +28,7 @@ NETWORK_MODE=""
 TAILSCALE_IP=""
 BRIDGE_HOST=""
 BRIDGE_PORT=""
-EXPO_MODE="mobile"
 AUTO_START="true"
-TARGET_PLATFORM="mobile"
-BRIDGE_PID=""
-EXPO_PID=""
-BRIDGE_LOG="$ROOT_DIR/.bridge.log"
-EXPO_LOG="$ROOT_DIR/.expo.log"
-BRIDGE_PID_FILE="$ROOT_DIR/.bridge.pid"
-EXPO_PID_FILE="$ROOT_DIR/.expo.pid"
-KEEP_SERVICES_RUNNING="false"
 SECURE_ENV_FILE="$ROOT_DIR/.env.secure"
 MENU_RESULT=""
 SECTION_COUNT=0
@@ -45,8 +36,6 @@ RAIL_GLYPH="${DIM}│${RESET}"
 RAIL_BRANCH="${DIM}├─${RESET}"
 RAIL_CHILD="${DIM}│${RESET}"
 OS_NAME="$(uname -s)"
-EXPO_STOP_PATTERN="$ROOT_DIR/.*/expo start|$ROOT_DIR/node_modules/.bin/expo start"
-BRIDGE_STOP_PATTERN="$ROOT_DIR/services/rust-bridge|codex-rust-bridge|@codex/rust-bridge"
 
 rail_echo() { printf "%s %s\n" "$RAIL_GLYPH" "$1"; }
 rail_blank() { printf "%s\n" "$RAIL_GLYPH"; }
@@ -81,46 +70,6 @@ run_quiet_command() {
   return 1
 }
 
-list_matching_pids() {
-  local pattern="$1"
-  pgrep -f "$pattern" 2>/dev/null || true
-}
-
-stop_process_group_by_pattern() {
-  local label="$1"
-  local pattern="$2"
-  local pids=""
-  local remaining=""
-  local pid=""
-
-  pids="$(list_matching_pids "$pattern")"
-  if [[ -z "$pids" ]]; then
-    return 0
-  fi
-
-  info "Stopping $label process group: $pids"
-  while IFS= read -r pid; do
-    [[ -z "$pid" ]] && continue
-    kill -TERM "$pid" >/dev/null 2>&1 || true
-  done <<<"$pids"
-
-  sleep 1
-
-  while IFS= read -r pid; do
-    [[ -z "$pid" ]] && continue
-    if kill -0 "$pid" >/dev/null 2>&1; then
-      remaining+="$pid "
-      kill -KILL "$pid" >/dev/null 2>&1 || true
-    fi
-  done <<<"$pids"
-
-  if [[ -n "${remaining// }" ]]; then
-    warn "Force-stopped $label processes: $remaining"
-  fi
-
-  return 0
-}
-
 print_usage() {
   cat <<EOF
 Usage: $(basename "$0") [options]
@@ -823,11 +772,22 @@ ensure_core_tools() {
     fail "openssl is required."
     exit 1
   fi
+}
 
+has_packaged_bridge_binary() {
+  node "$SCRIPT_DIR/bridge-binary.js" has-current-packaged >/dev/null 2>&1
+}
+
+ensure_local_rust_build_toolchain() {
   if ! ensure_or_install_command "cc" "C compiler/linker (cc)" install_c_toolchain_cli "Y"; then
     fail "C compiler/linker is required for Rust crate builds."
     exit 1
   fi
+
+  if ! ensure_or_install_command "cargo" "Rust/Cargo toolchain" install_rust_toolchain "Y"; then
+    fail "Rust/Cargo is required for the rust bridge."
+    exit 1
+  fi
 }
 
 ensure_codex_cli() {
@@ -1192,190 +1152,6 @@ confirm_phone_network_ready() {
   esac
 }
 
-has_mobile_react_native_runtime() {
-  local root_touchable="$ROOT_DIR/node_modules/react-native/Libraries/Components/Touchable/BoundingDimensions.js"
-  local workspace_touchable="$ROOT_DIR/apps/mobile/node_modules/react-native/Libraries/Components/Touchable/BoundingDimensions.js"
-  local root_devtools="$ROOT_DIR/node_modules/react-native/src/private/devsupport/rndevtools/specs/NativeReactDevToolsRuntimeSettingsModule.js"
-  local workspace_devtools="$ROOT_DIR/apps/mobile/node_modules/react-native/src/private/devsupport/rndevtools/specs/NativeReactDevToolsRuntimeSettingsModule.js"
-
-  local touchable_ok="false"
-  local devtools_ok="false"
-
-  if [[ -f "$root_touchable" ]] || [[ -f "$workspace_touchable" ]]; then
-    touchable_ok="true"
-  fi
-  if [[ -f "$root_devtools" ]] || [[ -f "$workspace_devtools" ]]; then
-    devtools_ok="true"
-  fi
-
-  [[ "$touchable_ok" == "true" ]] && [[ "$devtools_ok" == "true" ]]
-}
-
-repair_mobile_runtime_dependencies() {
-  info "Repairing mobile runtime dependencies (React Native + Expo toolchain)..."
-  run_quiet_command "React Native dependency repair" bash -lc "cd \"$ROOT_DIR\" && npm install --include=dev --force && npm install --include=dev --force -w apps/mobile && npm dedupe"
-}
-
-install_project_dependencies() {
-  local should_install="false"
-  local need_install="false"
-
-  if [[ ! -d "$ROOT_DIR/node_modules" ]] || [[ ! -d "$ROOT_DIR/node_modules/@codex" ]]; then
-    need_install="true"
-  fi
-
-  if [[ "$need_install" == "true" ]]; then
-    if confirm_prompt "Install project npm dependencies now?" "Y"; then
-      should_install="true"
-    else
-      if [[ "$AUTO_START" == "true" ]]; then
-        abort_wizard "Dependencies are required before starting the bridge."
-      fi
-    fi
-  else
-    if [[ "$FLOW" == "manual" ]] && confirm_prompt "Refresh npm dependencies now?" "N"; then
-      should_install="true"
-    fi
-  fi
-
-  if [[ "$should_install" == "true" ]]; then
-    info "Installing npm dependencies (including dev tooling; this can take a few minutes)..."
-    run_quiet_command "Project dependency install" bash -lc "cd \"$ROOT_DIR\" && npm install --include=dev && npm dedupe"
-    ok "Dependencies installed."
-  fi
-}
-
-cleanup_bridge() {
-  if [[ "$KEEP_SERVICES_RUNNING" == "true" ]]; then
-    return
-  fi
-
-  stop_process_group_by_pattern "Expo" "$EXPO_STOP_PATTERN"
-  stop_process_group_by_pattern "Rust bridge" "$BRIDGE_STOP_PATTERN"
-
-  rm -f "$BRIDGE_PID_FILE" "$EXPO_PID_FILE"
-}
-
-wait_for_bridge_health() {
-  local host="$1"
-  local port="$2"
-  local max_wait_secs="${BRIDGE_HEALTH_WAIT_SECS:-300}"
-  local elapsed=0
-
-  if ! command -v curl >/dev/null 2>&1; then
-    return 0
-  fi
-
-  while true; do
-    if curl --max-time 1 -fsS "http://$host:$port/health" >/dev/null 2>&1; then
-      return 0
-    fi
-
-    if [[ -n "$BRIDGE_PID" ]] && ! kill -0 "$BRIDGE_PID" >/dev/null 2>&1; then
-      return 1
-    fi
-
-    sleep 1
-    elapsed=$((elapsed + 1))
-    if (( elapsed % 5 == 0 )); then
-      info "Waiting for bridge health... ${elapsed}s elapsed"
-    fi
-
-    if (( elapsed >= max_wait_secs )); then
-      return 2
-    fi
-  done
-}
-
-stream_expo_output_until_enter() {
-  local tail_pid=""
-  local _user_input=""
-  local waited=0
-  local max_wait_secs="${EXPO_OUTPUT_WAIT_SECS:-90}"
-  local -a spinner_frames=("-" "\\" "|" "/")
-  local frame="-"
-
-  rail_echo "Expo output is live below."
-  rail_echo "Press Enter to exit onboarding and keep Expo + bridge running (Ctrl+D also detaches)."
-  echo ""
-
-  if [[ ! -s "$EXPO_LOG" ]]; then
-    while true; do
-      if [[ -s "$EXPO_LOG" ]]; then
-        printf "\r\033[2K%s Expo output started.\n" "$RAIL_GLYPH"
-        break
-      fi
-
-      if [[ -n "$EXPO_PID" ]] && ! kill -0 "$EXPO_PID" >/dev/null 2>&1; then
-        printf "\r\033[2K%s Expo process exited before output appeared.\n" "$RAIL_GLYPH"
-        return 1
-      fi
-
-      if (( waited >= max_wait_secs )); then
-        printf "\r\033[2K%s Still waiting for Expo output...\n" "$RAIL_GLYPH"
-        break
-      fi
-
-      frame="${spinner_frames[$((waited % ${#spinner_frames[@]}))]}"
-      printf "\r\033[2K%s Waiting for Expo output %s %ss" "$RAIL_GLYPH" "$frame" "$waited"
-      sleep 1
-      waited=$((waited + 1))
-    done
-  fi
-
-  tail -n +1 -f "$EXPO_LOG" &
-  tail_pid="$!"
-  if ! IFS= read -r _user_input 2>/dev/null; then
-    rail_echo "Input stream closed; detaching onboarding."
-  fi
-  kill -TERM "$tail_pid" >/dev/null 2>&1 || true
-  wait "$tail_pid" 2>/dev/null || true
-  return 0
-}
-
-start_expo_process_background() {
-  local log_file="$1"
-
-  if command -v script >/dev/null 2>&1; then
-    if [[ "$OS_NAME" == "Darwin" ]]; then
-      # Feed script from a never-ending pipe to avoid EOF-triggered Expo shutdown.
-      nohup bash -lc "cd \"$ROOT_DIR\" && tail -f /dev/null | script -q \"$log_file\" npm run \"$EXPO_MODE\"" >/dev/null 2>&1 &
-      EXPO_PID="$!"
-      return 0
-    fi
-
-    # util-linux script uses -c for command mode.
-    nohup bash -lc "cd \"$ROOT_DIR\" && tail -f /dev/null | script -q -f -c \"npm run $EXPO_MODE\" \"$log_file\"" >/dev/null 2>&1 &
-    EXPO_PID="$!"
-    return 0
-  fi
-
-  nohup bash -lc "cd \"$ROOT_DIR\" && npm run \"$EXPO_MODE\"" >"$log_file" 2>&1 </dev/null &
-  EXPO_PID="$!"
-}
-
-start_expo_background() {
-  info "Starting Expo ($EXPO_MODE) in background..."
-  : >"$EXPO_LOG"
-  start_expo_process_background "$EXPO_LOG"
-  echo "$EXPO_PID" > "$EXPO_PID_FILE"
-
-  sleep 1
-  if ! kill -0 "$EXPO_PID" >/dev/null 2>&1; then
-    fail "Expo failed to start. Recent logs:"
-    tail -n 80 "$EXPO_LOG" || true
-    exit 1
-  fi
-
-  KEEP_SERVICES_RUNNING="true"
-  ok "Bridge + Expo are running in background."
-  rail_echo "Bridge logs: $BRIDGE_LOG"
-  rail_echo "Expo logs: $EXPO_LOG"
-  rail_echo "To stop later:"
-  rail_echo "pkill -TERM -f '$EXPO_STOP_PATTERN'; pkill -TERM -f '$BRIDGE_STOP_PATTERN'"
-  stream_expo_output_until_enter
-}
-
 start_bridge_foreground() {
   rail_echo "Starting bridge in foreground."
   rail_echo "Press Ctrl+C to stop the bridge."
@@ -1406,12 +1182,13 @@ choose_flow
 
 section "Prerequisites"
 ensure_core_tools
-if ! ensure_or_install_command "cargo" "Rust/Cargo toolchain" install_rust_toolchain "Y"; then
-  fail "Rust/Cargo is required for the rust bridge."
-  exit 1
+if has_packaged_bridge_binary; then
+  ok "Found packaged Rust bridge binary for this host."
+else
+  info "No packaged bridge binary found for this host. Falling back to local Rust build."
+  ensure_local_rust_build_toolchain
 fi
 ensure_codex_cli
-install_project_dependencies
 
 section "Config handling"
 choose_config_action
@@ -1517,6 +1294,6 @@ fi
 
 section "Next steps"
 rail_echo "1) cd $ROOT_DIR && npm run secure:bridge"
-rail_echo "2) Open the iOS app and use onboarding to connect (mode + URL + token QR)."
+rail_echo "2) Open the mobile app and use onboarding to connect (URL + token QR)."
 rail_blank
 rail_echo "${DIM}You can rerun this anytime: npm run setup:wizard${RESET}"

package/scripts/start-bridge-secure.js

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+"use strict";
+
+const { spawn, spawnSync } = require("node:child_process");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const {
+  builtBinaryPath,
+  ensureExecutable,
+  packagedBinaryPath,
+  resolveRuntimeTarget,
+} = require("./bridge-binary");
+
+function resolveRootDir() {
+  let rootDir = process.env.INIT_CWD ? path.resolve(process.env.INIT_CWD) : path.resolve(__dirname, "..");
+  if (!fs.existsSync(path.join(rootDir, "package.json"))) {
+    rootDir = path.resolve(__dirname, "..");
+  }
+  return rootDir;
+}
+
+function readEnvFile(filePath) {
+  const contents = fs.readFileSync(filePath, "utf8");
+  const nextEnv = {};
+
+  for (const rawLine of contents.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+
+    const match = line.match(/^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+    if (!match) {
+      continue;
+    }
+
+    const [, key, rawValue] = match;
+    let value = rawValue;
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    nextEnv[key] = value;
+  }
+
+  return nextEnv;
+}
+
+function commandExists(command) {
+  const checker = process.platform === "win32" ? "where" : "which";
+  const result = spawnSync(checker, [command], { stdio: "ignore" });
+  return result.status === 0;
+}
+
+function walkFiles(directory) {
+  const entries = fs.readdirSync(directory, { withFileTypes: true });
+  const files = [];
+
+  for (const entry of entries) {
+    const entryPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...walkFiles(entryPath));
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push(entryPath);
+    }
+  }
+
+  return files;
+}
+
+function isBuiltBinaryFresh(rootDir, binaryPath) {
+  if (!fs.existsSync(binaryPath)) {
+    return false;
+  }
+
+  const binaryMtime = fs.statSync(binaryPath).mtimeMs;
+  const watchPaths = [
+    path.join(rootDir, "services", "rust-bridge", "Cargo.toml"),
+    path.join(rootDir, "services", "rust-bridge", "Cargo.lock"),
+  ];
+  const sourceDir = path.join(rootDir, "services", "rust-bridge", "src");
+
+  if (fs.existsSync(sourceDir)) {
+    watchPaths.push(...walkFiles(sourceDir));
+  }
+
+  return watchPaths.every((watchPath) => {
+    if (!fs.existsSync(watchPath)) {
+      return true;
+    }
+    return fs.statSync(watchPath).mtimeMs <= binaryMtime;
+  });
+}
+
+function printMissingCompilerHint() {
+  if (process.platform === "win32") {
+    console.error("Install Visual Studio Build Tools (Desktop development with C++) and Rust, then retry.");
+    return;
+  }
+  if (commandExists("apt-get")) {
+    console.error("Install on Ubuntu/Debian: sudo apt-get update && sudo apt-get install -y build-essential");
+    return;
+  }
+  if (commandExists("dnf")) {
+    console.error("Install on Fedora/RHEL: sudo dnf install -y gcc gcc-c++ make");
+    return;
+  }
+  if (commandExists("yum")) {
+    console.error("Install on CentOS/RHEL: sudo yum install -y gcc gcc-c++ make");
+    return;
+  }
+  if (commandExists("apk")) {
+    console.error("Install on Alpine: sudo apk add build-base");
+    return;
+  }
+  if (commandExists("xcode-select")) {
+    console.error("Install on macOS: xcode-select --install");
+  }
+}
+
+function spawnAndRelay(command, args, options) {
+  const child = spawn(command, args, {
+    stdio: "inherit",
+    ...options,
+  });
+
+  child.on("error", (error) => {
+    console.error(`error: failed to start ${command}: ${error.message}`);
+    process.exit(1);
+  });
+
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code ?? 0);
+  });
+}
+
+function buildBridgeFromSource(rootDir, env) {
+  const cargoCmd = "cargo";
+  const args = ["build", "--release", "--locked"];
+  const result = spawnSync(cargoCmd, args, {
+    cwd: path.join(rootDir, "services", "rust-bridge"),
+    env,
+    stdio: "inherit",
+  });
+
+  if (result.error) {
+    console.error(`error: failed to run cargo build: ${result.error.message}`);
+    process.exit(1);
+  }
+
+  if ((result.status ?? 1) !== 0) {
+    process.exit(result.status ?? 1);
+  }
+}
+
+function start() {
+  const rootDir = resolveRootDir();
+  const secureEnvFile = path.join(rootDir, ".env.secure");
+  if (!fs.existsSync(secureEnvFile)) {
+    console.error(`error: ${secureEnvFile} not found. Run: npm run secure:setup`);
+    process.exit(1);
+  }
+
+  const fileEnv = readEnvFile(secureEnvFile);
+  const env = { ...fileEnv, ...process.env };
+  const devMode = process.argv.includes("--dev") || env.BRIDGE_RUN_MODE === "dev";
+  const forceSourceBuild = env.CLAWDEX_BRIDGE_FORCE_SOURCE_BUILD === "true";
+
+  if (devMode) {
+    if (!commandExists("cargo")) {
+      console.error("error: missing Rust/Cargo toolchain for dev bridge mode.");
+      process.exit(1);
+    }
+
+    spawnAndRelay("cargo", ["run"], {
+      cwd: path.join(rootDir, "services", "rust-bridge"),
+      env,
+    });
+    return;
+  }
+
+  const overrideBinary = env.CLAWDEX_BRIDGE_BINARY ? path.resolve(env.CLAWDEX_BRIDGE_BINARY) : "";
+  if (overrideBinary) {
+    if (!fs.existsSync(overrideBinary)) {
+      console.error(`error: CLAWDEX_BRIDGE_BINARY not found at ${overrideBinary}`);
+      process.exit(1);
+    }
+    ensureExecutable(overrideBinary);
+    spawnAndRelay(overrideBinary, [], { cwd: rootDir, env });
+    return;
+  }
+
+  const packagedBinary = packagedBinaryPath(rootDir, resolveRuntimeTarget());
+  if (!forceSourceBuild && packagedBinary && fs.existsSync(packagedBinary)) {
+    ensureExecutable(packagedBinary);
+    spawnAndRelay(packagedBinary, [], { cwd: rootDir, env });
+    return;
+  }
+
+  const builtBinary = builtBinaryPath(rootDir, os.platform());
+  if (isBuiltBinaryFresh(rootDir, builtBinary)) {
+    ensureExecutable(builtBinary);
+    spawnAndRelay(builtBinary, [], { cwd: rootDir, env });
+    return;
+  }
+
+  if (!commandExists("cargo")) {
+    console.error("error: no packaged bridge binary was found for this host, and cargo is not installed.");
+    console.error("Reinstall a published clawdex-mobile package with bundled bridge binaries, or install Rust and retry.");
+    process.exit(1);
+  }
+
+  if (process.platform !== "win32" && !commandExists("cc")) {
+    console.error("error: missing system C compiler/linker ('cc'). Rust bridge cannot compile without it.");
+    printMissingCompilerHint();
+    process.exit(1);
+  }
+
+  buildBridgeFromSource(rootDir, env);
+
+  if (!fs.existsSync(builtBinary)) {
+    console.error(`error: expected built bridge binary at ${builtBinary}, but it was not created.`);
+    process.exit(1);
+  }
+
+  ensureExecutable(builtBinary);
+  spawnAndRelay(builtBinary, [], { cwd: rootDir, env });
+}
+
+start();

package/scripts/start-bridge-secure.sh

@@ -2,43 +2,4 @@
 set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -L)"
-ROOT_DIR="${INIT_CWD:-$(cd "$SCRIPT_DIR/.." && pwd -L)}"
-if [[ ! -f "$ROOT_DIR/package.json" ]]; then
-  ROOT_DIR="$(cd "$SCRIPT_DIR/.." && pwd -L)"
-fi
-SECURE_ENV_FILE="$ROOT_DIR/.env.secure"
-
-if [[ ! -f "$SECURE_ENV_FILE" ]]; then
-  echo "error: $SECURE_ENV_FILE not found. Run: npm run secure:setup" >&2
-  exit 1
-fi
-
-if ! command -v cc >/dev/null 2>&1; then
-  echo "error: missing system C compiler/linker ('cc'). Rust bridge cannot compile without it." >&2
-  if command -v apt-get >/dev/null 2>&1; then
-    echo "Install on Ubuntu/Debian: sudo apt-get update && sudo apt-get install -y build-essential" >&2
-  elif command -v dnf >/dev/null 2>&1; then
-    echo "Install on Fedora/RHEL: sudo dnf install -y gcc gcc-c++ make" >&2
-  elif command -v yum >/dev/null 2>&1; then
-    echo "Install on CentOS/RHEL: sudo yum install -y gcc gcc-c++ make" >&2
-  elif command -v apk >/dev/null 2>&1; then
-    echo "Install on Alpine: sudo apk add build-base" >&2
-  elif command -v xcode-select >/dev/null 2>&1; then
-    echo "Install on macOS: xcode-select --install" >&2
-  fi
-  exit 1
-fi
-
-set -a
-# shellcheck disable=SC1090
-source "$SECURE_ENV_FILE"
-set +a
-
-BRIDGE_RUN_MODE="${BRIDGE_RUN_MODE:-release}"
-
-cd "$ROOT_DIR"
-if [[ "$BRIDGE_RUN_MODE" == "dev" ]]; then
-  exec npm run -w @codex/rust-bridge dev
-fi
-
-exec npm run -w @codex/rust-bridge start
+exec node "$SCRIPT_DIR/start-bridge-secure.js" "$@"

package/services/rust-bridge/Cargo.lock

@@ -149,7 +149,7 @@ dependencies = [
 
 [[package]]
 name = "codex-rust-bridge"
-version = "3.0.0"
+version = "5.0.0"
 dependencies = [
  "axum",
  "base64",

package/services/rust-bridge/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "codex-rust-bridge"
-version = "3.0.0"
+version = "5.0.0"
 edition = "2021"
 
 [dependencies]

package/services/rust-bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codex/rust-bridge",
-  "version": "3.0.0",
+  "version": "5.0.0",
   "private": true,
   "scripts": {
     "dev": "cargo run",

package/services/rust-bridge/src/main.rs

@@ -1907,6 +1907,7 @@ struct WorkspaceListRequest {
 struct WorkspaceSummary {
     path: String,
     chat_count: usize,
+    updated_at: Option<u64>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -2806,7 +2807,16 @@ async fn list_workspace_roots(
 
     let mut workspaces = workspaces_by_path
         .into_iter()
-        .map(|(path, (chat_count, updated_at))| (WorkspaceSummary { path, chat_count }, updated_at))
+        .map(|(path, (chat_count, updated_at))| {
+            (
+                WorkspaceSummary {
+                    path,
+                    chat_count,
+                    updated_at: (updated_at > 0).then_some(updated_at),
+                },
+                updated_at,
+            )
+        })
         .collect::<Vec<_>>();
 
     workspaces.sort_by(|(left, left_updated_at), (right, right_updated_at)| {