forge-remote 0.1.28 → 0.1.30

package/firestore.rules

@@ -54,12 +54,14 @@ service cloud.firestore {
                     && request.resource.data.keys().hasAll(['ownerUid', 'desktopId', 'status']);
       allow update: if isSignedIn()
                     && isValidSize();
+      allow delete: if isSignedIn();
 
       // ---- Messages (subcollection) ----
       match /messages/{messageId} {
         allow read: if isSignedIn();
         allow create: if isSignedIn()
-                      && request.resource.data.size() < 500000; // 500KB max per message
+                      && request.resource.data.size() < 500000;
+        allow delete: if isSignedIn();
       }
 
       // ---- Commands (subcollection) ----
@@ -67,22 +69,49 @@ service cloud.firestore {
         allow read: if isSignedIn();
         allow create: if isSignedIn();
         allow update: if isSignedIn();
+        allow delete: if isSignedIn();
       }
 
       // ---- Permissions (subcollection) ----
       match /permissions/{permId} {
         allow read: if isSignedIn();
         allow update: if isSignedIn();
+        allow delete: if isSignedIn();
       }
 
       // ---- Tool calls (subcollection) ----
       match /toolCalls/{toolCallId} {
         allow read: if isSignedIn();
+        allow delete: if isSignedIn();
       }
 
       // ---- Git data (subcollection) ----
       match /gitData/{docId} {
         allow read: if isSignedIn();
+        allow delete: if isSignedIn();
+      }
+
+      // ---- Builds (subcollection) ----
+      match /builds/{buildId} {
+        allow read: if isSignedIn();
+        allow delete: if isSignedIn();
+      }
+
+      // ---- Deploys (subcollection) ----
+      match /deploys/{deployId} {
+        allow read: if isSignedIn();
+        allow delete: if isSignedIn();
+      }
+
+      // ---- Build data (subcollection — project info, ADB status, deploy readiness) ----
+      match /buildData/{docId} {
+        allow read: if isSignedIn();
+      }
+
+      // ---- Session summary (subcollection) ----
+      match /summary/{docId} {
+        allow read: if isSignedIn();
+        allow delete: if isSignedIn();
       }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-remote",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "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,744 @@
+// 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,
+  readdirSync,
+  statSync,
+} from "node:fs";
+import * as log from "./logger.js";
+
+/**
+ * Resolve a path that may contain glob patterns (e.g., *.ipa) to an actual file.
+ * Returns the resolved absolute path, or the original if no glob.
+ */
+function resolveGlobPath(basePath, filePath) {
+  const fullPath = path.isAbsolute(filePath)
+    ? filePath
+    : path.join(basePath, filePath);
+
+  if (!fullPath.includes("*")) {
+    return fullPath;
+  }
+
+  // Manual glob resolution for simple *.ext patterns
+  const dir = path.dirname(fullPath);
+  const pattern = path.basename(fullPath);
+
+  if (!existsSync(dir)) return fullPath;
+
+  const ext = pattern.replace("*", "");
+  try {
+    const files = readdirSync(dir).filter((f) => f.endsWith(ext));
+    if (files.length > 0) {
+      // Return the most recently modified file
+      const resolved = files
+        .map((f) => {
+          const p = path.join(dir, f);
+          return { name: f, path: p, mtime: statSync(p).mtimeMs };
+        })
+        .sort((a, b) => b.mtime - a.mtime)[0];
+      return resolved.path;
+    }
+  } catch {}
+
+  return fullPath;
+}
+
+// ---------------------------------------------------------------------------
+// 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) => {
+    // Use login shell with full Xcode environment for iOS builds.
+    const shell = process.env.SHELL || "/bin/zsh";
+    const buildEnv = {
+      ...process.env,
+      // Ensure Xcode tools are available
+      DEVELOPER_DIR:
+        process.env.DEVELOPER_DIR ||
+        "/Applications/Xcode.app/Contents/Developer",
+    };
+    // For iOS builds, run flutter clean first to avoid stale storyboard caches
+    const fullCmd =
+      platform === "ios"
+        ? `flutter clean > /dev/null 2>&1; ${buildCmd}`
+        : buildCmd;
+    const proc = spawn(shell, ["-l", "-c", fullCmd], {
+      cwd: projectPath,
+      env: buildEnv,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    // Timeout: 10 minutes max for any build
+    const buildTimeout = setTimeout(() => {
+      log.warn(`Build timed out after 10 minutes: ${buildCmd}`);
+      try {
+        proc.kill("SIGTERM");
+      } catch {}
+      setTimeout(() => {
+        try {
+          proc.kill("SIGKILL");
+        } catch {}
+      }, 5000);
+      reject(new Error(`Build timed out after 10 minutes`));
+    }, 600000);
+
+    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("error", (err) => {
+      clearTimeout(buildTimeout);
+      reject(new Error(`Build process error: ${err.message}`));
+    });
+
+    proc.on("close", (code) => {
+      clearTimeout(buildTimeout);
+      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, appId, groups, testers, releaseNotes } = options;
+
+  assertCliAvailable("firebase");
+
+  // Resolve glob patterns (e.g., build/ios/ipa/*.ipa → actual filename)
+  const resolvedPath = resolveGlobPath(projectPath, buildPath);
+  if (!existsSync(resolvedPath)) {
+    throw new Error(`Build artifact not found: ${resolvedPath}`);
+  }
+  log.info(`Resolved build path: ${resolvedPath}`);
+
+  // Auto-detect Firebase App ID if not provided
+  let detectedAppId = appId;
+  if (!detectedAppId) {
+    // Try GoogleService-Info.plist (iOS)
+    if (resolvedPath.endsWith(".ipa")) {
+      const plistPath = path.join(
+        projectPath,
+        "ios/Runner/GoogleService-Info.plist",
+      );
+      if (existsSync(plistPath)) {
+        try {
+          const plist = readFileSync(plistPath, "utf-8");
+          const match = plist.match(
+            /<key>GOOGLE_APP_ID<\/key>\s*<string>([^<]+)<\/string>/,
+          );
+          if (match) detectedAppId = match[1];
+        } catch {}
+      }
+    }
+    // Try google-services.json (Android)
+    if (resolvedPath.endsWith(".apk") || resolvedPath.endsWith(".aab")) {
+      const jsonPath = path.join(
+        projectPath,
+        "android/app/google-services.json",
+      );
+      if (existsSync(jsonPath)) {
+        try {
+          const gs = JSON.parse(readFileSync(jsonPath, "utf-8"));
+          detectedAppId = gs.client?.[0]?.client_info?.mobilesdk_app_id;
+        } catch {}
+      }
+    }
+  }
+
+  if (!detectedAppId) {
+    throw new Error(
+      "Firebase App ID not found. Add GoogleService-Info.plist (iOS) or google-services.json (Android) to the project, or pass appId in the command payload.",
+    );
+  }
+
+  log.info(`Using Firebase App ID: ${detectedAppId}`);
+  let cmd = `firebase appdistribution:distribute "${resolvedPath}" --app "${detectedAppId}"`;
+
+  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}"`;
+  }
+
+  // Auto-add the device owner as a tester if no testers/groups specified
+  if (!groups && !testers) {
+    // Try to get the Firebase auth email
+    try {
+      const authEmail = execSync("firebase login:list 2>/dev/null", {
+        timeout: 5000,
+        encoding: "utf-8",
+      });
+      const emailMatch = authEmail.match(/[\w.-]+@[\w.-]+\.\w+/);
+      if (emailMatch) {
+        cmd += ` --testers "${emailMatch[0]}"`;
+        log.info(`Auto-adding tester: ${emailMatch[0]}`);
+      }
+    } catch {}
+  }
+
+  log.info(`Distributing build via App Distribution: ${resolvedPath}`);
+
+  const result = execSync(cmd, {
+    cwd: projectPath,
+    timeout: 300_000,
+    encoding: "utf-8",
+    env: { ...process.env },
+  });
+
+  // Try to extract the testing URI from the output
+  // Firebase CLI outputs: "View this release in the Firebase console: <url>"
+  const consoleUrlMatch = result.match(
+    /(?:View this release.*?|Firebase console.*?)(https:\/\/console\.firebase\.google\.com[^\s]+)/i,
+  );
+  // Also look for the tester download link
+  const testerUrlMatch = result.match(
+    /(https:\/\/appdistribution\.firebase\.google\.com[^\s]+)/i,
+  );
+  // Firebase App Tester — the user needs to open the App Tester app
+  // on their device to download. The console URL lets them manage releases.
+  const appTesterUrl = "https://appdistribution.firebase.google.com/testerapps";
+
+  log.info("App Distribution upload complete");
+  return {
+    output: result,
+    consoleUrl: consoleUrlMatch?.[1] || null,
+    testerUrl: testerUrlMatch?.[1] || null,
+    appTesterUrl,
+    appId: detectedAppId,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// 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,
@@ -435,13 +447,22 @@ function watchSessionCommands(sessionId) {
   activeSessions.set(`cmd-watcher-${sessionId}`, true);
 
   const db = getDb();
+  console.log(
+    `[DEBUG] watchSessionCommands: watching session ${sessionId.slice(0, 8)}`,
+  );
   db.collection("sessions")
     .doc(sessionId)
     .collection("commands")
     .where("status", "==", "pending")
     .onSnapshot((snap) => {
+      console.log(
+        `[DEBUG] commands snapshot for ${sessionId.slice(0, 8)}: ${snap.docChanges().length} changes`,
+      );
       for (const change of snap.docChanges()) {
         if (change.type === "added") {
+          console.log(
+            `[DEBUG] pending command: ${change.doc.data().type} for ${sessionId.slice(0, 8)}`,
+          );
           handleSessionCommand(sessionId, change.doc);
         }
       }
@@ -460,6 +481,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) {
@@ -470,6 +501,10 @@ async function handleSessionCommand(sessionId, commandDoc) {
   const data = commandDoc.data();
   if (data.status !== "pending") return;
 
+  console.log(
+    `[DEBUG] handleSessionCommand: type=${data.type} session=${sessionId.slice(0, 8)} cmdId=${commandDoc.id.slice(0, 8)}`,
+  );
+
   const db = getDb();
   const cmdRef = db
     .collection("sessions")
@@ -511,6 +546,21 @@ async function handleSessionCommand(sessionId, commandDoc) {
 
   await cmdRef.update({ status: "processing" });
 
+  // Helper: get session info from activeSessions or fall back to Firestore.
+  // Needed for build/deploy/git commands that can run on non-relay sessions.
+  async function getSessionInfo() {
+    const local = activeSessions.get(sessionId);
+    if (local) return local;
+    const doc = await db.collection("sessions").doc(sessionId).get();
+    if (!doc.exists) throw new Error("Session not found");
+    const d = doc.data();
+    return {
+      projectPath: d.projectPath,
+      projectName: d.projectName,
+      desktopId: d.desktopId,
+    };
+  }
+
   try {
     switch (data.type) {
       case "send_prompt":
@@ -660,6 +710,335 @@ 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 = await getSessionInfo();
+        console.log(
+          `[DEBUG] detect_project: projectPath="${sess.projectPath}"`,
+        );
+        const projectInfo = detectProjectType(sess.projectPath);
+        console.log(
+          `[DEBUG] detect_project: result=`,
+          JSON.stringify(projectInfo),
+        );
+        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 = await getSessionInfo();
+
+        // 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) => {
+              // Log build output to relay console
+              const prefix = stream === "stderr" ? "⚠" : "▸";
+              console.log(`  ${prefix} [build] ${line}`);
+              // 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 = await getSessionInfo();
+
+        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 = await getSessionInfo();
+
+        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;
+
+          const distResult = await deployToAppDistribution(
+            sess.projectPath,
+            buildPath,
+            {
+              projectId,
+              groups,
+              testers,
+              releaseNotes,
+            },
+          );
+
+          await deployRef.update({
+            status: "success",
+            consoleUrl: distResult.consoleUrl || null,
+            testerUrl: distResult.testerUrl || null,
+            appTesterUrl: distResult.appTesterUrl || null,
+            appId: distResult.appId || null,
+            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 = await getSessionInfo();
+        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 = await getSessionInfo();
+        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) {