rechrome 1.46.0 → 1.48.0

package/README.md

@@ -56,6 +56,9 @@ rech tab-list
 rech eval "() => document.title"
 rech --profile work@example.com open https://example.com   # another registered profile
 rech --isolate open https://accounts.example.com           # throwaway session, e.g. for a login flow
+rech --isolate=login open https://accounts.example.com     # named isolated session: reused by later
+rech --isolate=login fill-secret e12 --from-env PASSWORD   #   --isolate=login commands (same tabs)
+rech session close login                                   #   until you close it (rech session ls lists it)
 ```
 
 Any [playwright-cli](https://github.com/snomiao/playwright-cli) command works after `rech`. When a
@@ -174,6 +177,10 @@ Over **WebRTC** the two machines need no open port, VPN or domain. A small signa
 encrypted with keys the signal server never sees. The first `rech` command after connecting starts
 a small local bridge that keeps the connection open between commands.
 
+**Opening the link in a browser shows what it gives**, without redeeming it: whether the host is
+online, the share and when it ends, whether the invite is still open, its profiles, and its open
+sessions. Anyone holding the link can see that. `rech connect` lists the open sessions too.
+
 **The link is an invite, not a key.** `rech connect` redeems it once: this machine gets its own
 device credential (saved to `.rechrome/.env.local`) and the invite stops working, so a link that
 leaks after it was used is harmless, and if someone else used it first you'll know. Unused invites
@@ -545,7 +552,11 @@ Each client gets its own browser session, keyed by the **git worktree root path*
 roll up to their parent), or the current directory outside git. So two worktrees of one repo
 get separate sessions, and `git checkout` keeps you in the same one. `RECH_IDENTITY=branch`
 restores the older `<remote>/tree/<branch>` keying and `RECH_IDENTITY=cwd` keys on the exact
-directory. Pass `-s=<name>` for a named sub-session, or `--isolate` for a throwaway one.
+directory. Pass `-s=<name>` for a named sub-session, `--isolate` for a throwaway one (a new session per
+command), or `--isolate=<name>` for a named isolated session (`-s=iso_<name>`) that later
+`--isolate=<name>` commands from the same worktree reuse until `rech session close <name>`.
+An isolated session is its own tab group in the same Chrome profile: it shares the profile's
+cookies, so profile-scoped listeners still refuse `eval`, `run-code` and other arbitrary code in it.
 A share device's sessions are additionally keyed by its share and device, so they never meet
 another device's or a listener link's; `rech session ls` lists the ones this link drove.
 

package/e2e.js

@@ -1,5 +1,5 @@
 // @bun
-// secret.ts
+// token.ts
 var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 var B58 = "[1-9A-HJ-NP-Za-km-z]";
 var BODY_LEN = 22;
@@ -145,7 +145,7 @@ async function open(key, frame, th, state) {
 var pack = (obj) => enc.encode(JSON.stringify(obj));
 var unpack = (bytes) => JSON.parse(dec.decode(bytes));
 function randomHex(n) {
-  return Buffer.from(globalThis.crypto.getRandomValues(new Uint8Array(n))).toString("hex");
+  return Array.from(globalThis.crypto.getRandomValues(new Uint8Array(n)), (b) => b.toString(16).padStart(2, "0")).join("");
 }
 export {
   CONFIRM_TIMEOUT_MS,

package/e2e.ts

@@ -7,7 +7,7 @@
 // The AES keys are HKDF(secret, transcriptHash) where the transcript binds both DTLS
 // fingerprints: a relay that swaps in its own fingerprints derives different keys, and the
 // mandatory key-confirmation round fails closed.
-import { parseToken } from "./secret.ts";
+import { parseToken } from "./token.ts";
 
 export const PROTO = "rech-e2e-1";
 export const MAX_CHUNK = 12_000;          // plaintext bytes per sealed frame, well under SCTP limits
@@ -102,5 +102,5 @@ export async function open(key: CryptoKey, frame: ArrayBuffer | Uint8Array, th:
 export const pack = (obj: unknown) => enc.encode(JSON.stringify(obj));
 export const unpack = (bytes: Uint8Array) => JSON.parse(dec.decode(bytes));
 export function randomHex(n: number): string {
-  return Buffer.from(globalThis.crypto.getRandomValues(new Uint8Array(n))).toString("hex");
+  return Array.from(globalThis.crypto.getRandomValues(new Uint8Array(n)), b => b.toString(16).padStart(2, "0")).join("");
 }

package/extension-token.js

@@ -1,6 +1,8 @@
 // @bun
 // extension-token.ts
-import { readFileSync, readdirSync } from "fs";
+import { Database } from "bun:sqlite";
+import { copyFileSync, existsSync, mkdtempSync, readFileSync, readdirSync, rmSync } from "fs";
+import { tmpdir } from "os";
 import { join } from "path";
 function varint(b, cursor) {
   let value = 0;
@@ -111,7 +113,41 @@ function* logRecords(b) {
     }
   }
 }
+function readExtensionTokenFromSqlite(userDataDir, profileDir, extensionId) {
+  const path = join(userDataDir, profileDir, "LocalStorage");
+  if (!existsSync(path))
+    return null;
+  const query = (file, readonly) => {
+    const db = new Database(file, readonly ? { readonly: true } : undefined);
+    try {
+      const row = db.query("SELECT e.value AS value, e.value_compression_type AS compression FROM map_entries e JOIN maps m ON m.row_id = e.map_id WHERE m.storage_key = ? AND e.key = ?").get(Buffer.from(`chrome-extension://${extensionId}/`, "latin1"), Buffer.from("\x01auth-token", "latin1"));
+      if (!row || row.compression !== 0)
+        return null;
+      const value = Buffer.from(row.value).toString("latin1");
+      return /^\x01[A-Za-z0-9_-]{43}$/.test(value) ? value.slice(1) : null;
+    } finally {
+      db.close();
+    }
+  };
+  try {
+    return query(path, true);
+  } catch {}
+  const tmp = mkdtempSync(join(tmpdir(), "rech-ls-"));
+  try {
+    copyFileSync(path, join(tmp, "LocalStorage"));
+    if (existsSync(`${path}-wal`))
+      copyFileSync(`${path}-wal`, join(tmp, "LocalStorage-wal"));
+    return query(join(tmp, "LocalStorage"), false);
+  } catch {
+    return null;
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
 function readExtensionTokenFromProfile(userDataDir, profileDir, extensionId) {
+  return readExtensionTokenFromSqlite(userDataDir, profileDir, extensionId) ?? readExtensionTokenFromLeveldb(userDataDir, profileDir, extensionId);
+}
+function readExtensionTokenFromLeveldb(userDataDir, profileDir, extensionId) {
   const dir = join(userDataDir, profileDir, "Local Storage", "leveldb");
   const wanted = Buffer.from(`_chrome-extension://${extensionId}\x00\x01auth-token`, "latin1");
   let newest = -1n, token = null;

package/extension-token.ts

@@ -1,4 +1,6 @@
-import { readFileSync, readdirSync } from "fs";
+import { Database } from "bun:sqlite";
+import { copyFileSync, existsSync, mkdtempSync, readFileSync, readdirSync, rmSync } from "fs";
+import { tmpdir } from "os";
 import { join } from "path";
 
 function varint(b: Buffer, cursor: { p: number }): number {
@@ -87,7 +89,41 @@ function* logRecords(b: Buffer): Generator<Buffer> {
 // Read files without opening the database or taking Chrome's LevelDB lock. Internal
 // sequence numbers, not filenames/byte order, determine the latest value. Decode
 // SST prefix compression and Snappy, and scope the key to the exact extension origin.
+// Chromium 156+ keeps localStorage in a SQLite file `<profile>/LocalStorage` (maps + map_entries)
+// instead of `Local Storage/leveldb`; keys and values keep the same 0x01-prefixed Latin-1 encoding.
+function readExtensionTokenFromSqlite(userDataDir: string, profileDir: string, extensionId: string): string | null {
+  const path = join(userDataDir, profileDir, "LocalStorage");
+  if (!existsSync(path)) return null;
+  const query = (file: string, readonly: boolean): string | null => {
+    const db = new Database(file, readonly ? { readonly: true } : undefined);
+    try {
+      const row = db.query(
+        "SELECT e.value AS value, e.value_compression_type AS compression FROM map_entries e JOIN maps m ON m.row_id = e.map_id WHERE m.storage_key = ? AND e.key = ?",
+      ).get(Buffer.from(`chrome-extension://${extensionId}/`, "latin1"), Buffer.from("\x01auth-token", "latin1")) as { value: Uint8Array; compression: number } | null;
+      if (!row || row.compression !== 0) return null;
+      const value = Buffer.from(row.value).toString("latin1");
+      return /^\x01[A-Za-z0-9_-]{43}$/.test(value) ? value.slice(1) : null;
+    } finally { db.close(); }
+  };
+  // Chrome keeps the file in WAL mode. While Chrome runs, a recent write (a freshly minted token)
+  // can sit in the -wal file only, and a read-only open sees it. Once Chrome has exited and
+  // removed the -shm file, a read-only open fails (SQLITE_CANTOPEN): then read a private copy of
+  // the file and its -wal, which never touches Chrome's own files. (No `file:` URIs: Bun's SQLite
+  // on Linux does not take them.)
+  try { return query(path, true); } catch {}
+  const tmp = mkdtempSync(join(tmpdir(), "rech-ls-"));
+  try {
+    copyFileSync(path, join(tmp, "LocalStorage"));
+    if (existsSync(`${path}-wal`)) copyFileSync(`${path}-wal`, join(tmp, "LocalStorage-wal"));
+    return query(join(tmp, "LocalStorage"), false);
+  } catch { return null; } finally { rmSync(tmp, { recursive: true, force: true }); }
+}
+
 export function readExtensionTokenFromProfile(userDataDir: string, profileDir: string, extensionId: string): string | null {
+  return readExtensionTokenFromSqlite(userDataDir, profileDir, extensionId) ?? readExtensionTokenFromLeveldb(userDataDir, profileDir, extensionId);
+}
+
+function readExtensionTokenFromLeveldb(userDataDir: string, profileDir: string, extensionId: string): string | null {
   const dir = join(userDataDir, profileDir, "Local Storage", "leveldb");
   const wanted = Buffer.from(`_chrome-extension://${extensionId}\0\x01auth-token`, "latin1");
   let newest = -1n, token: string | null = null;