forge-remote 0.1.28 → 0.1.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-remote",
-  "version": "0.1.28",
+  "version": "0.1.29",
   "description": "Desktop relay for Forge Remote — monitor and control Claude Code sessions from your phone",
   "type": "module",
   "license": "UNLICENSED",

package/src/build-manager.js

@@ -0,0 +1,586 @@
+// Forge Remote Relay — Build & Deploy Manager
+// Copyright (c) 2025-2026 Iron Forge Apps
+// Created by Daniel Wendel, CEO/Founder of Iron Forge Apps
+
+import { execSync, spawn } from "child_process";
+import path from "node:path";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import * as log from "./logger.js";
+
+// ---------------------------------------------------------------------------
+// Project Detection
+// ---------------------------------------------------------------------------
+
+/**
+ * Detect project type from the project directory.
+ * Returns: { type, framework, buildCommands, outputPaths }
+ */
+export function detectProjectType(projectPath) {
+  // Check for Flutter / Dart
+  const pubspecPath = path.join(projectPath, "pubspec.yaml");
+  if (existsSync(pubspecPath)) {
+    const pubspec = readFileSync(pubspecPath, "utf-8");
+    if (pubspec.includes("flutter:")) {
+      return {
+        type: "mobile",
+        framework: "flutter",
+        buildCommands: {
+          android: "flutter build apk --release",
+          ios: "flutter build ipa --release",
+          web: "flutter build web --release",
+        },
+        outputPaths: {
+          android: "build/app/outputs/flutter-apk/app-release.apk",
+          ios: "build/ios/ipa/*.ipa",
+          web: "build/web",
+        },
+      };
+    }
+    return {
+      type: "dart",
+      framework: "dart",
+      buildCommands: { default: "dart compile exe" },
+      outputPaths: {},
+    };
+  }
+
+  // Check for package.json (Node / React / Next / Vue / etc.)
+  const pkgPath = path.join(projectPath, "package.json");
+  if (existsSync(pkgPath)) {
+    let pkg;
+    try {
+      pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    } catch {
+      return {
+        type: "web",
+        framework: "node",
+        buildCommands: { web: "npm run build" },
+        outputPaths: { web: "dist" },
+      };
+    }
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+    if (deps["next"]) {
+      return {
+        type: "web",
+        framework: "nextjs",
+        buildCommands: { web: "npm run build" },
+        outputPaths: { web: ".next" },
+      };
+    }
+    if (deps["react-scripts"] || deps["react"]) {
+      return {
+        type: "web",
+        framework: "react",
+        buildCommands: { web: "npm run build" },
+        outputPaths: { web: "build" },
+      };
+    }
+    if (deps["vue"]) {
+      return {
+        type: "web",
+        framework: "vue",
+        buildCommands: { web: "npm run build" },
+        outputPaths: { web: "dist" },
+      };
+    }
+    if (deps["@angular/core"]) {
+      return {
+        type: "web",
+        framework: "angular",
+        buildCommands: { web: "npm run build" },
+        outputPaths: { web: "dist" },
+      };
+    }
+    if (deps["svelte"] || deps["@sveltejs/kit"]) {
+      return {
+        type: "web",
+        framework: "svelte",
+        buildCommands: { web: "npm run build" },
+        outputPaths: { web: "build" },
+      };
+    }
+    // Generic Node project
+    return {
+      type: "web",
+      framework: "node",
+      buildCommands: { web: "npm run build" },
+      outputPaths: { web: "dist" },
+    };
+  }
+
+  // Check for Cargo.toml (Rust)
+  if (existsSync(path.join(projectPath, "Cargo.toml"))) {
+    return {
+      type: "binary",
+      framework: "rust",
+      buildCommands: { default: "cargo build --release" },
+      outputPaths: { default: "target/release" },
+    };
+  }
+
+  // Check for go.mod (Go)
+  if (existsSync(path.join(projectPath, "go.mod"))) {
+    return {
+      type: "binary",
+      framework: "go",
+      buildCommands: { default: "go build -o ./build/" },
+      outputPaths: { default: "build" },
+    };
+  }
+
+  // Check for index.html (static site)
+  if (existsSync(path.join(projectPath, "index.html"))) {
+    return {
+      type: "web",
+      framework: "static",
+      buildCommands: {},
+      outputPaths: { web: "." },
+    };
+  }
+
+  return {
+    type: "unknown",
+    framework: "unknown",
+    buildCommands: {},
+    outputPaths: {},
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Build Runner
+// ---------------------------------------------------------------------------
+
+/**
+ * Run a build command and stream output.
+ * @param {string} projectPath — absolute path to the project root
+ * @param {string} platform — "web", "android", "ios", or "default"
+ * @param {(line: string, stream: "stdout"|"stderr") => void} [onOutput] — callback for each output line
+ * @returns {Promise<{ success: boolean, output: string, duration: number, outputPath: string|null, framework: string, platform: string }>}
+ */
+export async function runBuild(projectPath, platform, onOutput) {
+  const projectInfo = detectProjectType(projectPath);
+  const buildCmd =
+    projectInfo.buildCommands[platform] ||
+    projectInfo.buildCommands.web ||
+    projectInfo.buildCommands.default;
+
+  if (!buildCmd) {
+    throw new Error(
+      `No build command for platform "${platform}" in ${projectInfo.framework} project`,
+    );
+  }
+
+  log.info(
+    `Starting ${projectInfo.framework} build for platform "${platform}": ${buildCmd}`,
+  );
+
+  const startTime = Date.now();
+  const outputLines = [];
+
+  return new Promise((resolve, reject) => {
+    const [cmd, ...args] = buildCmd.split(" ");
+    const proc = spawn(cmd, args, {
+      cwd: projectPath,
+      shell: true,
+      env: { ...process.env },
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    proc.stdout.on("data", (data) => {
+      const text = data.toString();
+      for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed) {
+          outputLines.push(trimmed);
+          if (onOutput) onOutput(trimmed, "stdout");
+        }
+      }
+    });
+
+    proc.stderr.on("data", (data) => {
+      const text = data.toString();
+      for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed) {
+          outputLines.push(trimmed);
+          if (onOutput) onOutput(trimmed, "stderr");
+        }
+      }
+    });
+
+    proc.on("close", (code) => {
+      const duration = Math.round((Date.now() - startTime) / 1000);
+      const outputPath =
+        projectInfo.outputPaths[platform] ||
+        projectInfo.outputPaths.web ||
+        projectInfo.outputPaths.default ||
+        null;
+
+      if (code === 0) {
+        log.info(`Build succeeded in ${duration}s`);
+        resolve({
+          success: true,
+          output: outputLines.join("\n"),
+          duration,
+          outputPath: outputPath ? path.resolve(projectPath, outputPath) : null,
+          framework: projectInfo.framework,
+          platform,
+        });
+      } else {
+        const tail = outputLines.slice(-15).join("\n");
+        log.error(`Build failed (exit code ${code})`);
+        reject(new Error(`Build failed (exit code ${code})\n${tail}`));
+      }
+    });
+
+    proc.on("error", (err) => {
+      log.error(`Build process error: ${err.message}`);
+      reject(new Error(`Build process error: ${err.message}`));
+    });
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Firebase Hosting Deploy
+// ---------------------------------------------------------------------------
+
+/**
+ * Deploy to Firebase Hosting.
+ * @param {string} projectPath — project root (must contain firebase.json)
+ * @param {string} [outputDir] — build output directory (unused if firebase.json is configured)
+ * @param {{ projectId?: string, channelId?: string }} [options]
+ * @returns {Promise<{ url: string|null, output: string, projectId?: string }>}
+ */
+export async function deployToFirebaseHosting(
+  projectPath,
+  outputDir,
+  options = {},
+) {
+  const { projectId, channelId } = options;
+
+  assertCliAvailable("firebase");
+
+  // Preview channel deploy vs. live deploy
+  let cmd;
+  if (channelId) {
+    cmd = `firebase hosting:channel:deploy ${channelId} --only hosting`;
+  } else {
+    cmd = `firebase deploy --only hosting`;
+  }
+
+  if (projectId) {
+    cmd += ` --project ${projectId}`;
+  }
+
+  log.info(`Deploying to Firebase Hosting: ${cmd}`);
+
+  const result = execSync(cmd, {
+    cwd: projectPath,
+    timeout: 120_000,
+    encoding: "utf-8",
+    env: { ...process.env },
+  });
+
+  // Parse the hosting URL from output
+  const channelUrlMatch = result.match(/Channel URL: (https?:\/\/[^\s]+)/);
+  const urlMatch = result.match(/Hosting URL: (https?:\/\/[^\s]+)/);
+  const url = channelUrlMatch?.[1] || urlMatch?.[1] || null;
+
+  log.info(`Firebase Hosting deployed${url ? `: ${url}` : ""}`);
+  return { url, output: result, projectId };
+}
+
+// ---------------------------------------------------------------------------
+// Firebase App Distribution
+// ---------------------------------------------------------------------------
+
+/**
+ * Deploy to Firebase App Distribution.
+ * @param {string} projectPath — project root
+ * @param {string} buildPath — path to the APK/IPA file
+ * @param {{ projectId?: string, groups?: string, testers?: string, releaseNotes?: string }} [options]
+ * @returns {Promise<{ output: string }>}
+ */
+export async function deployToAppDistribution(
+  projectPath,
+  buildPath,
+  options = {},
+) {
+  const { projectId, groups, testers, releaseNotes } = options;
+
+  assertCliAvailable("firebase");
+
+  let cmd = `firebase appdistribution:distribute "${buildPath}"`;
+
+  if (projectId) cmd += ` --project ${projectId}`;
+  if (groups) cmd += ` --groups "${groups}"`;
+  if (testers) cmd += ` --testers "${testers}"`;
+  if (releaseNotes) {
+    const escaped = releaseNotes.replace(/"/g, '\\"');
+    cmd += ` --release-notes "${escaped}"`;
+  }
+
+  log.info(`Distributing build via App Distribution: ${buildPath}`);
+
+  const result = execSync(cmd, {
+    cwd: projectPath,
+    timeout: 300_000, // 5 min for large APKs/IPAs
+    encoding: "utf-8",
+    env: { ...process.env },
+  });
+
+  log.info("App Distribution upload complete");
+  return { output: result };
+}
+
+// ---------------------------------------------------------------------------
+// ADB (Android Debug Bridge) Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Check if ADB wireless debugging is available and a device is connected.
+ * @returns {{ connected: boolean, deviceId: string|null, deviceName: string|null }}
+ */
+export function checkAdbDevice() {
+  try {
+    const result = execSync("adb devices -l", {
+      timeout: 5_000,
+      encoding: "utf-8",
+    });
+    const lines = result
+      .split("\n")
+      .filter((l) => l.includes("device") && !l.startsWith("List"));
+    if (lines.length > 0) {
+      const parts = lines[0].split(/\s+/);
+      const deviceId = parts[0];
+      const modelMatch = lines[0].match(/model:(\S+)/);
+      return {
+        connected: true,
+        deviceId,
+        deviceName: modelMatch?.[1] || deviceId,
+      };
+    }
+  } catch {
+    /* ADB not installed or timed out */
+  }
+  return { connected: false, deviceId: null, deviceName: null };
+}
+
+/**
+ * Install APK directly to a connected Android device via ADB.
+ * @param {string} apkPath — path to the .apk file
+ * @param {string} [deviceId] — specific device serial (optional)
+ * @returns {{ output: string }}
+ */
+export function installViaAdb(apkPath, deviceId) {
+  assertCliAvailable("adb");
+
+  const cmd = deviceId
+    ? `adb -s ${deviceId} install -r "${apkPath}"`
+    : `adb install -r "${apkPath}"`;
+
+  log.info(`Installing APK via ADB: ${apkPath}`);
+
+  const result = execSync(cmd, {
+    timeout: 120_000,
+    encoding: "utf-8",
+  });
+
+  log.info("ADB install complete");
+  return { output: result };
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Assert that a CLI tool is available on the PATH.
+ * Throws a user-friendly error if not found.
+ */
+// ---------------------------------------------------------------------------
+// Deploy Readiness Check & Setup
+// ---------------------------------------------------------------------------
+
+/**
+ * Check if Firebase CLI is installed and authenticated.
+ * Check if the project has firebase.json and .firebaserc.
+ * Returns a readiness report.
+ */
+export function checkDeployReadiness(projectPath) {
+  const report = {
+    firebaseCli: { installed: false, version: null },
+    firebaseAuth: { loggedIn: false, account: null },
+    firebaseConfig: {
+      hasFirebaseJson: false,
+      hasFirebaserc: false,
+      projectId: null,
+    },
+    hosting: { configured: false, publicDir: null },
+    appDistribution: { available: false },
+    issues: [],
+    ready: false,
+  };
+
+  // Check Firebase CLI
+  try {
+    const version = execSync("firebase --version", {
+      timeout: 5000,
+      encoding: "utf-8",
+    }).trim();
+    report.firebaseCli = { installed: true, version };
+  } catch {
+    report.issues.push({
+      code: "NO_CLI",
+      message: "Firebase CLI not installed",
+      fix: "npm install -g firebase-tools",
+    });
+  }
+
+  // Check Firebase auth
+  if (report.firebaseCli.installed) {
+    try {
+      const result = execSync("firebase login:list", {
+        timeout: 10000,
+        encoding: "utf-8",
+      });
+      const accounts = result.match(/[\w.-]+@[\w.-]+/g);
+      if (accounts && accounts.length > 0) {
+        report.firebaseAuth = { loggedIn: true, account: accounts[0] };
+      } else {
+        report.issues.push({
+          code: "NOT_LOGGED_IN",
+          message: "Not logged in to Firebase",
+          fix: "firebase login",
+        });
+      }
+    } catch {
+      report.issues.push({
+        code: "NOT_LOGGED_IN",
+        message: "Not logged in to Firebase",
+        fix: "firebase login",
+      });
+    }
+  }
+
+  // Check firebase.json
+  const firebaseJsonPath = path.join(projectPath, "firebase.json");
+  if (existsSync(firebaseJsonPath)) {
+    report.firebaseConfig.hasFirebaseJson = true;
+    try {
+      const config = JSON.parse(readFileSync(firebaseJsonPath, "utf-8"));
+      if (config.hosting) {
+        report.hosting = {
+          configured: true,
+          publicDir: config.hosting.public || config.hosting[0]?.public || null,
+        };
+      }
+    } catch {
+      /* malformed firebase.json */
+    }
+  } else {
+    report.issues.push({
+      code: "NO_FIREBASE_JSON",
+      message: "No firebase.json found in project",
+      fix: "Will be created during setup",
+    });
+  }
+
+  // Check .firebaserc
+  const firebasercPath = path.join(projectPath, ".firebaserc");
+  if (existsSync(firebasercPath)) {
+    report.firebaseConfig.hasFirebaserc = true;
+    try {
+      const rc = JSON.parse(readFileSync(firebasercPath, "utf-8"));
+      report.firebaseConfig.projectId = rc.projects?.default || null;
+    } catch {
+      /* malformed .firebaserc */
+    }
+  }
+
+  report.ready =
+    report.firebaseCli.installed &&
+    report.firebaseAuth.loggedIn &&
+    report.firebaseConfig.hasFirebaseJson &&
+    report.hosting.configured;
+
+  return report;
+}
+
+/**
+ * List Firebase projects available to the user.
+ */
+export function listFirebaseProjects() {
+  try {
+    const result = execSync("firebase projects:list --json", {
+      timeout: 30000,
+      encoding: "utf-8",
+    });
+    const data = JSON.parse(result);
+    if (data.status === "success" && Array.isArray(data.result)) {
+      return data.result.map((p) => ({
+        projectId: p.projectId,
+        displayName: p.displayName,
+        projectNumber: p.projectNumber,
+      }));
+    }
+  } catch {
+    /* firebase CLI not available or not logged in */
+  }
+  return [];
+}
+
+/**
+ * Initialize Firebase Hosting for a project.
+ * Creates firebase.json and .firebaserc.
+ */
+export function initFirebaseHosting(projectPath, projectId, publicDir) {
+  // Write .firebaserc
+  const firebasercPath = path.join(projectPath, ".firebaserc");
+  const rc = { projects: { default: projectId } };
+  writeFileSync(firebasercPath, JSON.stringify(rc, null, 2));
+
+  // Write firebase.json
+  const firebaseJsonPath = path.join(projectPath, "firebase.json");
+  const config = {
+    hosting: {
+      public: publicDir,
+      ignore: ["firebase.json", "**/.*", "**/node_modules/**"],
+      rewrites: [{ source: "**", destination: "/index.html" }],
+    },
+  };
+  writeFileSync(firebaseJsonPath, JSON.stringify(config, null, 2));
+
+  return { firebaseJsonPath, firebasercPath };
+}
+
+/**
+ * Run firebase login in the background (opens browser on desktop).
+ */
+export function startFirebaseLogin() {
+  const proc = spawn("firebase", ["login", "--no-localhost"], {
+    shell: true,
+    stdio: ["pipe", "pipe", "pipe"],
+    detached: true,
+  });
+  proc.unref();
+  return { pid: proc.pid };
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function assertCliAvailable(cliName) {
+  try {
+    execSync(`which ${cliName}`, { stdio: "pipe" });
+  } catch {
+    const hints = {
+      firebase:
+        "Firebase CLI not found. Install it: npm install -g firebase-tools",
+      adb: "ADB not found. Install Android SDK platform-tools.",
+    };
+    throw new Error(hints[cliName] || `${cliName} CLI not found on PATH`);
+  }
+}

package/src/session-manager.js

@@ -30,6 +30,18 @@ import {
   getGitLog,
   createPullRequest,
 } from "./git-manager.js";
+import {
+  detectProjectType,
+  runBuild,
+  deployToFirebaseHosting,
+  deployToAppDistribution,
+  checkAdbDevice,
+  installViaAdb,
+  checkDeployReadiness,
+  listFirebaseProjects,
+  initFirebaseHosting,
+  startFirebaseLogin,
+} from "./build-manager.js";
 
 // ---------------------------------------------------------------------------
 // Resolve the user's shell environment so spawned processes inherit PATH,
@@ -460,6 +472,16 @@ const VALID_SESSION_COMMANDS = new Set([
   "git_commit",
   "git_push",
   "create_pr",
+  "detect_project",
+  "build_project",
+  "deploy_hosting",
+  "deploy_app_dist",
+  "check_adb",
+  "install_adb",
+  "check_deploy_ready",
+  "list_firebase_projects",
+  "init_firebase_hosting",
+  "start_firebase_login",
 ]);
 
 async function handleSessionCommand(sessionId, commandDoc) {
@@ -660,6 +682,323 @@ async function handleSessionCommand(sessionId, commandDoc) {
         await cmdRef.update({ result: prResult });
         break;
       }
+
+      // ---------------------------------------------------------------
+      // Build & Deploy commands
+      // ---------------------------------------------------------------
+
+      case "detect_project": {
+        log.command("detect_project", sessionId.slice(0, 8));
+        const sess = activeSessions.get(sessionId);
+        if (!sess) throw new Error("Session not found");
+        const projectInfo = detectProjectType(sess.projectPath);
+        await db
+          .collection("sessions")
+          .doc(sessionId)
+          .collection("buildData")
+          .doc("projectInfo")
+          .set({
+            ...projectInfo,
+            detectedAt: FieldValue.serverTimestamp(),
+          });
+        break;
+      }
+
+      case "build_project": {
+        const platform = data.payload?.platform || "web";
+        log.command("build_project", `${sessionId.slice(0, 8)} [${platform}]`);
+        const sess = activeSessions.get(sessionId);
+        if (!sess) throw new Error("Session not found");
+
+        // Create a build record with status: building
+        const buildRef = db
+          .collection("sessions")
+          .doc(sessionId)
+          .collection("builds")
+          .doc();
+        await buildRef.set({
+          platform,
+          status: "building",
+          startedAt: FieldValue.serverTimestamp(),
+          projectPath: sess.projectPath,
+        });
+
+        try {
+          const result = await runBuild(
+            sess.projectPath,
+            platform,
+            (line, _stream) => {
+              // Stream latest output line to Firestore (best-effort)
+              buildRef
+                .update({
+                  lastOutput: line,
+                  lastActivity: FieldValue.serverTimestamp(),
+                })
+                .catch(() => {});
+            },
+          );
+
+          await buildRef.update({
+            status: "success",
+            duration: result.duration,
+            outputPath: result.outputPath,
+            framework: result.framework,
+            completedAt: FieldValue.serverTimestamp(),
+          });
+
+          // Notify mobile app
+          if (sess.desktopId) {
+            notifySessionComplete(sess.desktopId, sessionId, {
+              projectName: sess.projectName || "Unknown",
+              customTitle: "Build Complete",
+              customBody: `${result.framework} ${platform} build succeeded (${result.duration}s)`,
+            }).catch(() => {});
+          }
+        } catch (err) {
+          await buildRef.update({
+            status: "failed",
+            error: err.message,
+            completedAt: FieldValue.serverTimestamp(),
+          });
+          throw err; // Re-throw so the outer handler marks the command as failed
+        }
+        break;
+      }
+
+      case "deploy_hosting": {
+        log.command("deploy_hosting", sessionId.slice(0, 8));
+        const sess = activeSessions.get(sessionId);
+        if (!sess) throw new Error("Session not found");
+
+        const deployRef = db
+          .collection("sessions")
+          .doc(sessionId)
+          .collection("deploys")
+          .doc();
+        await deployRef.set({
+          type: "hosting",
+          status: "deploying",
+          startedAt: FieldValue.serverTimestamp(),
+        });
+
+        try {
+          const channelId = data.payload?.channelId || `preview-${Date.now()}`;
+          const projectId = data.payload?.projectId;
+          const outputDir = data.payload?.outputDir;
+
+          const result = await deployToFirebaseHosting(
+            sess.projectPath,
+            outputDir,
+            { projectId, channelId },
+          );
+
+          await deployRef.update({
+            status: "success",
+            url: result.url,
+            channelId,
+            completedAt: FieldValue.serverTimestamp(),
+          });
+
+          if (sess.desktopId) {
+            notifySessionComplete(sess.desktopId, sessionId, {
+              projectName: sess.projectName || "Unknown",
+              customTitle: "Deploy Complete",
+              customBody: result.url
+                ? `Live at: ${result.url}`
+                : "Firebase Hosting deployed",
+            }).catch(() => {});
+          }
+        } catch (err) {
+          await deployRef.update({
+            status: "failed",
+            error: err.message,
+            completedAt: FieldValue.serverTimestamp(),
+          });
+          throw err;
+        }
+        break;
+      }
+
+      case "deploy_app_dist": {
+        log.command("deploy_app_dist", sessionId.slice(0, 8));
+        const sess = activeSessions.get(sessionId);
+        if (!sess) throw new Error("Session not found");
+
+        const deployRef = db
+          .collection("sessions")
+          .doc(sessionId)
+          .collection("deploys")
+          .doc();
+        await deployRef.set({
+          type: "app_distribution",
+          status: "deploying",
+          startedAt: FieldValue.serverTimestamp(),
+        });
+
+        try {
+          const buildPath = data.payload?.buildPath;
+          if (!buildPath) throw new Error("buildPath is required");
+
+          const projectId = data.payload?.projectId;
+          const groups = data.payload?.groups;
+          const testers = data.payload?.testers;
+          const releaseNotes = data.payload?.releaseNotes;
+
+          await deployToAppDistribution(sess.projectPath, buildPath, {
+            projectId,
+            groups,
+            testers,
+            releaseNotes,
+          });
+
+          await deployRef.update({
+            status: "success",
+            completedAt: FieldValue.serverTimestamp(),
+          });
+
+          if (sess.desktopId) {
+            notifySessionComplete(sess.desktopId, sessionId, {
+              projectName: sess.projectName || "Unknown",
+              customTitle: "App Distributed",
+              customBody: "New build available for testers",
+            }).catch(() => {});
+          }
+        } catch (err) {
+          await deployRef.update({
+            status: "failed",
+            error: err.message,
+            completedAt: FieldValue.serverTimestamp(),
+          });
+          throw err;
+        }
+        break;
+      }
+
+      case "check_adb": {
+        log.command("check_adb", sessionId.slice(0, 8));
+        const device = checkAdbDevice();
+        await db
+          .collection("sessions")
+          .doc(sessionId)
+          .collection("buildData")
+          .doc("adbStatus")
+          .set({
+            ...device,
+            checkedAt: FieldValue.serverTimestamp(),
+          });
+        break;
+      }
+
+      case "install_adb": {
+        log.command("install_adb", sessionId.slice(0, 8));
+        const apkPath = data.payload?.apkPath;
+        const deviceId = data.payload?.deviceId;
+        if (!apkPath) throw new Error("apkPath is required");
+
+        try {
+          installViaAdb(apkPath, deviceId);
+          await db
+            .collection("sessions")
+            .doc(sessionId)
+            .collection("buildData")
+            .doc("adbInstall")
+            .set({
+              status: "success",
+              apkPath,
+              installedAt: FieldValue.serverTimestamp(),
+            });
+        } catch (err) {
+          await db
+            .collection("sessions")
+            .doc(sessionId)
+            .collection("buildData")
+            .doc("adbInstall")
+            .set({
+              status: "failed",
+              error: err.message,
+              apkPath,
+              attemptedAt: FieldValue.serverTimestamp(),
+            });
+          throw err;
+        }
+        break;
+      }
+
+      // ---------------------------------------------------------------
+      // Deploy Readiness & Setup commands
+      // ---------------------------------------------------------------
+
+      case "check_deploy_ready": {
+        log.command("check_deploy_ready", sessionId.slice(0, 8));
+        const sess = activeSessions.get(sessionId);
+        if (!sess) throw new Error("Session not found");
+        const report = checkDeployReadiness(sess.projectPath);
+        await db
+          .collection("sessions")
+          .doc(sessionId)
+          .collection("buildData")
+          .doc("deployReadiness")
+          .set({
+            ...report,
+            checkedAt: FieldValue.serverTimestamp(),
+          });
+        break;
+      }
+
+      case "list_firebase_projects": {
+        log.command("list_firebase_projects", sessionId.slice(0, 8));
+        const projects = listFirebaseProjects();
+        await db
+          .collection("sessions")
+          .doc(sessionId)
+          .collection("buildData")
+          .doc("firebaseProjects")
+          .set({
+            projects,
+            fetchedAt: FieldValue.serverTimestamp(),
+          });
+        break;
+      }
+
+      case "init_firebase_hosting": {
+        log.command("init_firebase_hosting", sessionId.slice(0, 8));
+        const sess = activeSessions.get(sessionId);
+        if (!sess) throw new Error("Session not found");
+        const projectId = data.payload?.projectId;
+        const publicDir = data.payload?.publicDir || "build/web";
+        if (!projectId) throw new Error("projectId is required");
+
+        initFirebaseHosting(sess.projectPath, projectId, publicDir);
+        await db
+          .collection("sessions")
+          .doc(sessionId)
+          .collection("buildData")
+          .doc("deployReadiness")
+          .update({
+            "firebaseConfig.hasFirebaseJson": true,
+            "firebaseConfig.hasFirebaserc": true,
+            "firebaseConfig.projectId": projectId,
+            "hosting.configured": true,
+            "hosting.publicDir": publicDir,
+            ready: true,
+          });
+        break;
+      }
+
+      case "start_firebase_login": {
+        log.command("start_firebase_login", sessionId.slice(0, 8));
+        startFirebaseLogin();
+        await db
+          .collection("sessions")
+          .doc(sessionId)
+          .collection("buildData")
+          .doc("deployReadiness")
+          .update({
+            loginStarted: true,
+            loginStartedAt: FieldValue.serverTimestamp(),
+          });
+        break;
+      }
     }
     await cmdRef.update({ status: "completed" });
   } catch (e) {