lunel-cli 0.1.76 → 0.1.78

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
@@ -313,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
 // ============================================================================
@@ -2206,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" });
                 }
@@ -2582,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,
@@ -2590,6 +2714,85 @@ 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,
+    });
+    currentSessionPassword = normalized.secret;
+    return normalized;
+}
+async function lookupPersistentPairings() {
+    const config = await getCliConfig();
+    const response = await fetch(`${MANAGER_URL}/v1/pairings/lookup`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            pcId: config.deviceId,
+            root: ROOT_DIR,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to look up persistent pairings (${response.status})`);
+    }
+    const payload = await response.json();
+    const pairings = Array.isArray(payload.pairings) ? payload.pairings : [];
+    return pairings
+        .filter((entry) => (entry &&
+        typeof entry.secret === "string" &&
+        typeof entry.hostname === "string" &&
+        typeof entry.root === "string" &&
+        typeof entry.phoneId === "string" &&
+        typeof entry.pairedAt === "number" &&
+        typeof entry.lastUsedAt === "number"))
+        .map((entry) => ({
+        secret: entry.secret,
+        root: normalizePairingRoot(entry.root),
+        hostname: entry.hostname,
+        phoneId: entry.phoneId,
+        pairedAt: entry.pairedAt,
+        lastUsedAt: entry.lastUsedAt,
+    }));
+}
 function displayQR(primaryGateway, backupGateway, code) {
     console.log("\n");
     qrcode.generate(code, { small: true }, (qr) => {
@@ -2706,9 +2909,13 @@ async function connectWebSocket() {
                             if (message.type === "connected")
                                 return;
                             if (message.type === "session_password" && message.password) {
+                                const nextPassword = message.password;
+                                if (currentSessionPassword && currentSessionPassword.length > nextPassword.length) {
+                                    return;
+                                }
                                 if (!currentSessionPassword)
                                     resetReplayBuffer(); // new session
-                                currentSessionPassword = message.password;
+                                currentSessionPassword = nextPassword;
                                 console.log("[session] received reconnect password");
                                 return;
                             }
@@ -2907,6 +3114,7 @@ async function main() {
         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");
@@ -2936,9 +3144,77 @@ async function main() {
             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);
+            let savedPairing = await getSavedPairingForRoot(ROOT_DIR);
+            if (!savedPairing) {
+                try {
+                    const remotePairings = await lookupPersistentPairings();
+                    for (const pairing of remotePairings) {
+                        await savePairing(pairing);
+                    }
+                    savedPairing = remotePairings.sort((a, b) => b.lastUsedAt - a.lastUsedAt)[0] || null;
+                }
+                catch {
+                    // fall back to QR
+                }
+            }
+            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);
+                        const remotePairings = await lookupPersistentPairings().catch(() => []);
+                        const fallbackPairing = remotePairings.sort((a, b) => b.lastUsedAt - a.lastUsedAt)[0] || null;
+                        if (fallbackPairing) {
+                            await savePairing(fallbackPairing);
+                            const fallbackResolved = await resolveSessionByResumeToken(fallbackPairing.secret);
+                            if (fallbackResolved) {
+                                session = fallbackResolved;
+                                console.log(`[pairing] Waiting on saved connection for ${fallbackPairing.hostname}`);
+                            }
+                            else {
+                                await removePairing(fallbackPairing.secret);
+                                session = await createSessionFromManager();
+                                displayQR(normalizeGatewayUrl(session.primary), session.backup ? normalizeGatewayUrl(session.backup) : null, session.code);
+                            }
+                        }
+                        else {
+                            session = await createSessionFromManager();
+                            displayQR(normalizeGatewayUrl(session.primary), session.backup ? normalizeGatewayUrl(session.backup) : null, session.code);
+                        }
+                    }
+                }
+                catch {
+                    await removePairing(savedPairing.secret);
+                    const remotePairings = await lookupPersistentPairings().catch(() => []);
+                    const fallbackPairing = remotePairings.sort((a, b) => b.lastUsedAt - a.lastUsedAt)[0] || null;
+                    if (fallbackPairing) {
+                        await savePairing(fallbackPairing);
+                        const fallbackResolved = await resolveSessionByResumeToken(fallbackPairing.secret);
+                        if (fallbackResolved) {
+                            session = fallbackResolved;
+                            console.log(`[pairing] Waiting on saved connection for ${fallbackPairing.hostname}`);
+                        }
+                        else {
+                            await removePairing(fallbackPairing.secret);
+                            session = await createSessionFromManager();
+                            displayQR(normalizeGatewayUrl(session.primary), session.backup ? normalizeGatewayUrl(session.backup) : null, session.code);
+                        }
+                    }
+                    else {
+                        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.76",
+  "version": "0.1.78",
   "author": [
     {
       "name": "Soham Bharambe",