lunel-cli 0.1.75 → 0.1.77

package/dist/index.js

@@ -24,7 +24,25 @@ const PTY_RELEASE_INFO_URL = process.env.LUNEL_PTY_INFO_URL ||
     "https://raw.githubusercontent.com/ssbharambe-m/pty-releases/refs/heads/main/info.json";
 const VERBOSE_AI_LOGS = process.env.LUNEL_DEBUG_AI === "1";
 // Root directory - sandbox all file operations to this
-const ROOT_DIR = process.cwd();
+const ROOT_DIR = (() => {
+    try {
+        return fssync.realpathSync(process.cwd());
+    }
+    catch {
+        return process.cwd();
+    }
+})();
+const CLI_CONFIG_PATH = (() => {
+    if (process.platform === "darwin") {
+        return path.join(os.homedir(), "Library", "Application Support", "lunel", "config.json");
+    }
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+        return path.join(appData, "lunel", "config.json");
+    }
+    const xdgConfig = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+    return path.join(xdgConfig, "lunel", "config.json");
+})();
 // Terminal sessions (managed by Rust PTY binary)
 const terminals = new Set();
 // PTY binary process
@@ -242,6 +260,7 @@ function parseExtraPortsFromArgs(args) {
 }
 const EXTRA_PORTS = parseExtraPortsFromArgs(CLI_ARGS);
 const SCAN_PORTS = Array.from(new Set([...DEV_PORTS, ...EXTRA_PORTS])).sort((a, b) => a - b);
+const RUN_ABCD_MODE = CLI_ARGS.includes("--run-abcd");
 function samePortSet(a, b) {
     if (a.length !== b.length)
         return false;
@@ -312,6 +331,104 @@ function assertSafePath(requestedPath) {
     }
     return safePath;
 }
+function generatePersistentSecret(length) {
+    const alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    const bytes = crypto.randomBytes(length);
+    let out = "";
+    for (let i = 0; i < length; i++) {
+        out += alphabet[bytes[i] % alphabet.length];
+    }
+    return out;
+}
+function normalizePairingRoot(input) {
+    try {
+        return fssync.realpathSync(input);
+    }
+    catch {
+        return path.resolve(input);
+    }
+}
+async function readCliConfig() {
+    try {
+        const raw = await fs.readFile(CLI_CONFIG_PATH, "utf-8");
+        const parsed = JSON.parse(raw);
+        const pairings = Array.isArray(parsed.pairings)
+            ? parsed.pairings
+                .filter((entry) => {
+                return Boolean(entry &&
+                    typeof entry.secret === "string" &&
+                    typeof entry.root === "string" &&
+                    typeof entry.hostname === "string" &&
+                    typeof entry.phoneId === "string" &&
+                    typeof entry.pairedAt === "number" &&
+                    typeof entry.lastUsedAt === "number");
+            })
+                .map((entry) => ({
+                ...entry,
+                root: normalizePairingRoot(entry.root),
+            }))
+            : [];
+        return {
+            version: 1,
+            deviceId: typeof parsed.deviceId === "string" && parsed.deviceId ? parsed.deviceId : generatePersistentSecret(32),
+            pairings,
+        };
+    }
+    catch {
+        return {
+            version: 1,
+            deviceId: generatePersistentSecret(32),
+            pairings: [],
+        };
+    }
+}
+async function writeCliConfig(config) {
+    await fs.mkdir(path.dirname(CLI_CONFIG_PATH), { recursive: true });
+    await fs.writeFile(CLI_CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+}
+let cliConfigPromise = null;
+async function getCliConfig() {
+    if (!cliConfigPromise) {
+        cliConfigPromise = readCliConfig();
+    }
+    return await cliConfigPromise;
+}
+async function persistCliConfig(mutator) {
+    const current = await getCliConfig();
+    const next = mutator({
+        version: 1,
+        deviceId: current.deviceId,
+        pairings: [...current.pairings],
+    });
+    cliConfigPromise = Promise.resolve(next);
+    await writeCliConfig(next);
+    return next;
+}
+async function getSavedPairingForRoot(root) {
+    const normalizedRoot = normalizePairingRoot(root);
+    const config = await getCliConfig();
+    const matches = config.pairings
+        .filter((entry) => entry.root === normalizedRoot)
+        .sort((a, b) => b.lastUsedAt - a.lastUsedAt);
+    return matches[0] || null;
+}
+async function savePairing(pairing) {
+    await persistCliConfig((config) => {
+        const deduped = config.pairings.filter((entry) => entry.secret !== pairing.secret);
+        deduped.push(pairing);
+        deduped.sort((a, b) => b.lastUsedAt - a.lastUsedAt);
+        return {
+            ...config,
+            pairings: deduped.slice(0, 50),
+        };
+    });
+}
+async function removePairing(secret) {
+    await persistCliConfig((config) => ({
+        ...config,
+        pairings: config.pairings.filter((entry) => entry.secret !== secret),
+    }));
+}
 // ============================================================================
 // File System Handlers
 // ============================================================================
@@ -2205,6 +2322,14 @@ async function processMessage(message) {
                     case "ping":
                         result = handleSystemPing();
                         break;
+                    case "pairDevice": {
+                        const phoneId = typeof payload.phoneId === "string" ? payload.phoneId.trim() : "";
+                        if (!phoneId) {
+                            throw Object.assign(new Error("phoneId is required"), { code: "EINVAL" });
+                        }
+                        result = { ...(await registerPersistentPairing(phoneId)) };
+                        break;
+                    }
                     default:
                         throw Object.assign(new Error(`Unknown action: ${ns}.${action}`), { code: "EINVAL" });
                 }
@@ -2526,10 +2651,11 @@ function normalizeGatewayUrl(input) {
     const path = parsed.pathname === "/" ? "" : parsed.pathname.replace(/\/+$/, "");
     return `${parsed.protocol}//${parsed.host}${path}`;
 }
-async function createSessionFromManager() {
+async function createSessionFromManager(opts = {}) {
     const response = await fetch(`${MANAGER_URL}/v1/session`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(opts.requestedCode ? { requestedCode: opts.requestedCode } : {}),
     });
     if (!response.ok) {
         throw new Error(`Failed to create session from manager: ${response.status}`);
@@ -2580,7 +2706,7 @@ async function resolveSessionByResumeToken(resumeToken) {
     }
     return {
         sessionId: snapshot.sessionId || "",
-        code: snapshot.code,
+        code: snapshot.code || "",
         password: snapshot.resumeToken,
         primary: snapshot.primary,
         backup: snapshot.backup ?? null,
@@ -2588,6 +2714,52 @@ async function resolveSessionByResumeToken(resumeToken) {
         expiresAt: snapshot.expiresAt,
     };
 }
+async function registerPersistentPairing(phoneId) {
+    if (!currentSessionPassword) {
+        throw new Error("No active session secret available for pairing");
+    }
+    const config = await getCliConfig();
+    const response = await fetch(`${MANAGER_URL}/v1/pairings/register`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            activeSecret: currentSessionPassword,
+            phoneId,
+            pcId: config.deviceId,
+            root: ROOT_DIR,
+            hostname: os.hostname(),
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to register persistent pairing (${response.status})`);
+    }
+    const payload = await response.json();
+    if (typeof payload.secret !== "string" ||
+        typeof payload.hostname !== "string" ||
+        typeof payload.root !== "string" ||
+        typeof payload.phoneId !== "string" ||
+        typeof payload.pairedAt !== "number" ||
+        typeof payload.lastUsedAt !== "number") {
+        throw new Error("Manager returned invalid pairing response");
+    }
+    const normalized = {
+        secret: payload.secret,
+        hostname: payload.hostname,
+        root: normalizePairingRoot(payload.root),
+        phoneId: payload.phoneId,
+        pairedAt: payload.pairedAt,
+        lastUsedAt: payload.lastUsedAt,
+    };
+    await savePairing({
+        secret: normalized.secret,
+        root: normalized.root,
+        hostname: normalized.hostname,
+        phoneId: normalized.phoneId,
+        pairedAt: normalized.pairedAt,
+        lastUsedAt: normalized.lastUsedAt,
+    });
+    return normalized;
+}
 function displayQR(primaryGateway, backupGateway, code) {
     console.log("\n");
     qrcode.generate(code, { small: true }, (qr) => {
@@ -2901,7 +3073,11 @@ async function main() {
     if (cloudJobConfig?.session_code) {
         console.log(`[cloud] Running in VM mode (sandbox: ${cloudJobConfig.sandbox_id})`);
     }
+    if (RUN_ABCD_MODE) {
+        console.log("[review] Running in pinned review session mode (code: abcd)");
+    }
     try {
+        await getCliConfig();
         console.log("Checking PTY runtime...");
         await ensurePtyBinaryReady();
         console.log("PTY runtime ready.\n");
@@ -2921,15 +3097,41 @@ async function main() {
             }
         });
         let session;
-        if (cloudJobConfig?.session_code) {
+        if (RUN_ABCD_MODE) {
+            session = await createSessionFromManager({ requestedCode: "abcd" });
+            console.log(`[review] Attached to session ${session.code} via ${session.primary}`);
+        }
+        else if (cloudJobConfig?.session_code) {
             // Cloud mode: connect to an existing session assigned by the manager
             session = await connectToCloudSession(cloudJobConfig.session_code);
             console.log(`[cloud] Connected to session ${session.code} via ${session.primary}`);
         }
         else {
-            // Public mode: create a new session and show QR code
-            session = await createSessionFromManager();
-            displayQR(normalizeGatewayUrl(session.primary), session.backup ? normalizeGatewayUrl(session.backup) : null, session.code);
+            const savedPairing = await getSavedPairingForRoot(ROOT_DIR);
+            if (savedPairing) {
+                try {
+                    const resolved = await resolveSessionByResumeToken(savedPairing.secret);
+                    if (resolved) {
+                        session = resolved;
+                        console.log(`[pairing] Waiting on saved connection for ${savedPairing.hostname}`);
+                    }
+                    else {
+                        await removePairing(savedPairing.secret);
+                        session = await createSessionFromManager();
+                        displayQR(normalizeGatewayUrl(session.primary), session.backup ? normalizeGatewayUrl(session.backup) : null, session.code);
+                    }
+                }
+                catch {
+                    await removePairing(savedPairing.secret);
+                    session = await createSessionFromManager();
+                    displayQR(normalizeGatewayUrl(session.primary), session.backup ? normalizeGatewayUrl(session.backup) : null, session.code);
+                }
+            }
+            else {
+                // Public mode: create a new session and show QR code
+                session = await createSessionFromManager();
+                displayQR(normalizeGatewayUrl(session.primary), session.backup ? normalizeGatewayUrl(session.backup) : null, session.code);
+            }
         }
         currentPrimaryGateway = normalizeGatewayUrl(session.primary);
         currentBackupGateway = session.backup ? normalizeGatewayUrl(session.backup) : null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lunel-cli",
-  "version": "0.1.75",
+  "version": "0.1.77",
   "author": [
     {
       "name": "Soham Bharambe",