forge-remote 0.1.0

package/src/logger.js

@@ -0,0 +1,150 @@
+/**
+ * Terminal logger with colors and formatting for the Forge Remote relay.
+ *
+ * Gives the desktop user clear, real-time feedback about what's happening.
+ */
+
+// ANSI color codes.
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const RED = "\x1b[31m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const BLUE = "\x1b[34m";
+const MAGENTA = "\x1b[35m";
+const CYAN = "\x1b[36m";
+const WHITE = "\x1b[37m";
+const BG_GREEN = "\x1b[42m";
+const BG_RED = "\x1b[41m";
+const BG_YELLOW = "\x1b[43m";
+const BG_BLUE = "\x1b[44m";
+
+function timestamp() {
+  return new Date().toLocaleTimeString("en-US", { hour12: false });
+}
+
+/** General info message. */
+export function info(msg) {
+  console.log(`${DIM}${timestamp()}${RESET}  ${BLUE}ℹ${RESET}  ${msg}`);
+}
+
+/** Success message with green checkmark. */
+export function success(msg) {
+  console.log(`${DIM}${timestamp()}${RESET}  ${GREEN}✓${RESET}  ${msg}`);
+}
+
+/** Warning message. */
+export function warn(msg) {
+  console.log(
+    `${DIM}${timestamp()}${RESET}  ${YELLOW}⚠${RESET}  ${YELLOW}${msg}${RESET}`,
+  );
+}
+
+/** Error message. */
+export function error(msg) {
+  console.log(
+    `${DIM}${timestamp()}${RESET}  ${RED}✗${RESET}  ${RED}${msg}${RESET}`,
+  );
+}
+
+/** Session-related event (bold session context). */
+export function session(sessionId, msg) {
+  const short = sessionId.slice(0, 8);
+  console.log(
+    `${DIM}${timestamp()}${RESET}  ${MAGENTA}◆${RESET}  ${DIM}[${short}]${RESET} ${msg}`,
+  );
+}
+
+/** Command received from mobile. */
+export function command(type, detail) {
+  console.log(
+    `${DIM}${timestamp()}${RESET}  ${CYAN}↓${RESET}  ${BOLD}Command:${RESET} ${type}${detail ? ` — ${detail}` : ""}`,
+  );
+}
+
+/** Tool call by Claude. */
+export function toolCall(sessionId, toolName, input) {
+  const short = sessionId.slice(0, 8);
+  const preview =
+    typeof input === "string"
+      ? input.slice(0, 80)
+      : JSON.stringify(input).slice(0, 80);
+  console.log(
+    `${DIM}${timestamp()}${RESET}  ${YELLOW}⚡${RESET} ${DIM}[${short}]${RESET} ${BOLD}${toolName}${RESET} ${DIM}${preview}${RESET}`,
+  );
+}
+
+/** Claude output (truncated preview). */
+export function claudeOutput(sessionId, text) {
+  const short = sessionId.slice(0, 8);
+  const preview = text.replace(/\n/g, " ").slice(0, 100);
+  console.log(
+    `${DIM}${timestamp()}${RESET}  ${GREEN}▸${RESET} ${DIM}[${short}]${RESET} ${preview}${text.length > 100 ? "..." : ""}`,
+  );
+}
+
+/** Session started banner. */
+export function sessionStarted({ sessionId, project, model, prompt }) {
+  const short = sessionId.slice(0, 8);
+  const line = "─".repeat(60);
+  console.log(`\n${CYAN}${line}${RESET}`);
+  console.log(`${CYAN}  ${BOLD}NEW SESSION${RESET} ${DIM}${short}${RESET}`);
+  console.log(`${CYAN}${line}${RESET}`);
+  console.log(`  ${BOLD}Project:${RESET}  ${project}`);
+  console.log(`  ${BOLD}Model:${RESET}    ${model}`);
+  console.log(
+    `  ${BOLD}Prompt:${RESET}   ${(prompt || "").slice(0, 80)}${(prompt || "").length > 80 ? "..." : ""}`,
+  );
+  console.log(`${CYAN}${line}${RESET}\n`);
+}
+
+/** Session ended banner. */
+export function sessionEnded({
+  sessionId,
+  status,
+  duration,
+  toolCalls,
+  messages,
+}) {
+  const short = sessionId.slice(0, 8);
+  const line = "─".repeat(60);
+  const color = status === "completed" ? GREEN : RED;
+  const icon = status === "completed" ? "✓" : "✗";
+  console.log(`\n${color}${line}${RESET}`);
+  console.log(
+    `${color}  ${icon} SESSION ${status.toUpperCase()}${RESET} ${DIM}${short}${RESET}`,
+  );
+  console.log(`${color}${line}${RESET}`);
+  console.log(`  ${BOLD}Duration:${RESET}    ${duration}`);
+  console.log(`  ${BOLD}Tool calls:${RESET}  ${toolCalls}`);
+  console.log(`  ${BOLD}Messages:${RESET}    ${messages}`);
+  console.log(`${color}${line}${RESET}\n`);
+}
+
+/** Relay startup banner. */
+export function banner(hostname, platform, desktopId, projectCount) {
+  const line = "═".repeat(50);
+  console.log(`\n${BOLD}${CYAN}${line}${RESET}`);
+  console.log(`${BOLD}${CYAN}  ⚡ FORGE REMOTE RELAY${RESET}`);
+  console.log(`${BOLD}${CYAN}${line}${RESET}`);
+  console.log(`  ${BOLD}Host:${RESET}      ${hostname}`);
+  console.log(`  ${BOLD}Platform:${RESET}  ${platform}`);
+  console.log(`  ${BOLD}Desktop:${RESET}   ${desktopId}`);
+  console.log(`  ${BOLD}Projects:${RESET}  ${projectCount} found`);
+  console.log(`${BOLD}${CYAN}${line}${RESET}`);
+  console.log(`  ${GREEN}Listening for commands...${RESET}`);
+  console.log(`  ${DIM}Press Ctrl+C to stop${RESET}\n`);
+}
+
+/** Heartbeat tick (only show occasionally to avoid noise). */
+let heartbeatCount = 0;
+export function heartbeat() {
+  heartbeatCount++;
+  // Only log every 10th heartbeat (every 5 minutes).
+  if (heartbeatCount % 10 === 0) {
+    console.log(
+      `${DIM}${timestamp()}  ♥  Heartbeat #${heartbeatCount} — relay still running${RESET}`,
+    );
+  }
+}

package/src/project-scanner.js

@@ -0,0 +1,103 @@
+import { readdirSync, statSync, existsSync } from "fs";
+import { join, basename } from "path";
+import { homedir } from "os";
+
+// Directories to scan (one level deep) for projects.
+const SCAN_DIRS = [
+  join(homedir(), "Documents"),
+  join(homedir(), "Projects"),
+  join(homedir(), "Developer"),
+  join(homedir(), "code"),
+  join(homedir(), "dev"),
+  join(homedir(), "work"),
+  join(homedir(), "src"),
+  join(homedir(), "repos"),
+  join(homedir(), "Desktop"),
+];
+
+// Files that indicate a directory is a project root.
+const PROJECT_MARKERS = [
+  ".git",
+  "package.json",
+  "pubspec.yaml",
+  "Cargo.toml",
+  "go.mod",
+  "pyproject.toml",
+  "requirements.txt",
+  "Gemfile",
+  "pom.xml",
+  "build.gradle",
+  "Makefile",
+  "CMakeLists.txt",
+];
+
+/**
+ * Scan common directories for projects.
+ * Returns an array of { path, name, lastOpened } objects.
+ */
+export async function scanProjects() {
+  const projects = [];
+  const seen = new Set();
+
+  for (const scanDir of SCAN_DIRS) {
+    if (!existsSync(scanDir)) continue;
+
+    try {
+      const entries = readdirSync(scanDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (entry.name.startsWith(".")) continue;
+
+        const dirPath = join(scanDir, entry.name);
+        if (seen.has(dirPath)) continue;
+
+        if (isProject(dirPath)) {
+          seen.add(dirPath);
+          const stat = statSync(dirPath);
+          projects.push({
+            path: dirPath,
+            name: basename(dirPath),
+            lastOpened: stat.mtime.toISOString(),
+          });
+        }
+
+        // Also scan one level deeper for nested project dirs
+        // (e.g. ~/Documents/IronForgeApps/Mobile/ForgeRemote).
+        try {
+          const subEntries = readdirSync(dirPath, { withFileTypes: true });
+          for (const sub of subEntries) {
+            if (!sub.isDirectory() || sub.name.startsWith(".")) continue;
+            const subPath = join(dirPath, sub.name);
+            if (seen.has(subPath)) continue;
+
+            if (isProject(subPath)) {
+              seen.add(subPath);
+              const stat = statSync(subPath);
+              projects.push({
+                path: subPath,
+                name: basename(subPath),
+                lastOpened: stat.mtime.toISOString(),
+              });
+            }
+          }
+        } catch {
+          // Skip subdirs we can't read.
+        }
+      }
+    } catch {
+      // Skip dirs we can't read.
+    }
+  }
+
+  // Sort by lastOpened descending.
+  projects.sort((a, b) => b.lastOpened.localeCompare(a.lastOpened));
+
+  return projects;
+}
+
+function isProject(dirPath) {
+  for (const marker of PROJECT_MARKERS) {
+    if (existsSync(join(dirPath, marker))) return true;
+  }
+  return false;
+}

package/src/screenshot-manager.js

@@ -0,0 +1,204 @@
+import { execSync, exec } from "child_process";
+import { readFileSync, unlinkSync, existsSync } from "fs";
+import { getDb, FieldValue } from "./firebase.js";
+import * as log from "./logger.js";
+
+/**
+ * Captures periodic screenshots from the iOS Simulator (or Android emulator)
+ * and uploads them to Firestore so the mobile app can display a live preview
+ * of native apps being built by Claude.
+ *
+ * Detection:
+ *   - macOS: `xcrun simctl list devices booted` for iOS Simulator
+ *   - Android: `adb devices` for connected emulators
+ *
+ * Capture:
+ *   - iOS:  `xcrun simctl io booted screenshot <path>`
+ *   - Android: `adb exec-out screencap -p` (binary PNG to stdout)
+ *
+ * Images are resized to 400px wide via `sips` (macOS) to keep payloads
+ * small, then base64-encoded and stored in the session doc.
+ */
+
+const activeCaptures = new Map(); // sessionId → intervalId
+
+const CAPTURE_INTERVAL_MS = 5_000;
+const TEMP_PATH_PREFIX = "/tmp/forge-preview-";
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Start periodic screenshot capture for a session.
+ * Auto-detects whether an iOS Simulator or Android emulator is running.
+ */
+export function startCapturing(sessionId) {
+  if (activeCaptures.has(sessionId)) return;
+
+  const target = detectTarget();
+  if (!target) {
+    log.info(`[screenshot] No simulator/emulator detected — skipping capture`);
+    return;
+  }
+
+  log.success(
+    `[screenshot] Starting capture for session ${sessionId.slice(0, 8)} (${target.type}: ${target.name})`,
+  );
+
+  // Take an initial screenshot immediately, then repeat.
+  captureAndUpload(sessionId, target);
+
+  const intervalId = setInterval(() => {
+    captureAndUpload(sessionId, target);
+  }, CAPTURE_INTERVAL_MS);
+
+  activeCaptures.set(sessionId, intervalId);
+}
+
+/**
+ * Stop capturing for a session.
+ */
+export function stopCapturing(sessionId) {
+  const intervalId = activeCaptures.get(sessionId);
+  if (intervalId) {
+    clearInterval(intervalId);
+    activeCaptures.delete(sessionId);
+    log.info(
+      `[screenshot] Stopped capture for session ${sessionId.slice(0, 8)}`,
+    );
+  }
+  // Clean up temp file.
+  const tmpFile = `${TEMP_PATH_PREFIX}${sessionId}.png`;
+  try {
+    if (existsSync(tmpFile)) unlinkSync(tmpFile);
+  } catch {
+    // ignore
+  }
+}
+
+/**
+ * Stop all active captures (relay shutdown cleanup).
+ */
+export function stopAllCaptures() {
+  for (const [sessionId] of activeCaptures) {
+    stopCapturing(sessionId);
+  }
+}
+
+/**
+ * Check whether any simulator/emulator is currently running.
+ */
+export function hasActiveSimulator() {
+  return detectTarget() !== null;
+}
+
+// ---------------------------------------------------------------------------
+// Target detection
+// ---------------------------------------------------------------------------
+
+function detectTarget() {
+  // Try iOS Simulator first (macOS only).
+  if (process.platform === "darwin") {
+    try {
+      const output = execSync("xcrun simctl list devices booted", {
+        encoding: "utf-8",
+        timeout: 5000,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      // Look for booted devices — lines like: "iPhone 15 (UUID) (Booted)"
+      const match = output.match(/^\s+(.+?)\s+\([A-F0-9-]+\)\s+\(Booted\)/im);
+      if (match) {
+        return { type: "ios-simulator", name: match[1].trim() };
+      }
+    } catch {
+      // xcrun not available or no booted simulators.
+    }
+  }
+
+  // Try Android emulator.
+  try {
+    const output = execSync("adb devices", {
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    const lines = output.split("\n").filter((l) => l.includes("emulator"));
+    if (lines.length > 0) {
+      const deviceId = lines[0].split("\t")[0];
+      return { type: "android-emulator", name: deviceId };
+    }
+  } catch {
+    // adb not available.
+  }
+
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Capture + upload
+// ---------------------------------------------------------------------------
+
+async function captureAndUpload(sessionId, target) {
+  const tmpFile = `${TEMP_PATH_PREFIX}${sessionId}.png`;
+
+  try {
+    // Capture screenshot.
+    if (target.type === "ios-simulator") {
+      execSync(`xcrun simctl io booted screenshot "${tmpFile}"`, {
+        timeout: 10_000,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+    } else if (target.type === "android-emulator") {
+      // adb screencap outputs binary PNG data.
+      execSync(`adb exec-out screencap -p > "${tmpFile}"`, {
+        timeout: 10_000,
+        shell: true,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+    }
+
+    if (!existsSync(tmpFile)) return;
+
+    // Resize to 400px wide to keep Firestore payload small.
+    if (process.platform === "darwin") {
+      try {
+        execSync(
+          `sips --resampleWidth 400 "${tmpFile}" --out "${tmpFile}" 2>/dev/null`,
+          {
+            timeout: 5000,
+            shell: true,
+            stdio: ["pipe", "pipe", "pipe"],
+          },
+        );
+      } catch {
+        // If sips fails, we still upload the full-size image.
+      }
+    }
+
+    // Read and base64-encode.
+    const imageBuffer = readFileSync(tmpFile);
+    const base64 = imageBuffer.toString("base64");
+
+    // Store in Firestore session doc.
+    const db = getDb();
+    await db
+      .collection("sessions")
+      .doc(sessionId)
+      .update({
+        previewScreenshot: {
+          data: base64,
+          capturedAt: FieldValue.serverTimestamp(),
+          target: target.type,
+          deviceName: target.name,
+        },
+        lastActivity: FieldValue.serverTimestamp(),
+      });
+  } catch (err) {
+    // Don't spam logs — capture failures happen when the simulator is briefly
+    // busy (e.g. during app launch/restart).
+    if (err.message && !err.message.includes("timed out")) {
+      log.warn(`[screenshot] Capture failed: ${err.message}`);
+    }
+  }
+}