clauderipple 0.12.3 → 0.12.4

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.12.4 — 2026-10-22
+
+### Added
+
+- **On Windows, the phone can send to a session open in the Claude app.** Before, such a session
+  could be read but not written to. It needs Remote Control turned on in the Claude app, the same
+  as on macOS; with only the Claude app in use, the login ClaudeRipple saw the app use carries it.
+  Handing a phone session over to the Claude app is still macOS only.
+
 ## 0.12.3 — 2026-10-22
 
 ### Added

package/dist/app/package.json

@@ -1,5 +1,5 @@
 {
   "private": true,
-  "version": "0.12.3",
+  "version": "0.12.4",
   "type": "commonjs"
 }

package/dist/remote/src/bridge-client.js

@@ -53,13 +53,42 @@ export function loadObservedAuth(now = Date.now(), home = process.env.CLAUDERIPP
         return null;
     }
 }
-export function loadBridgeAuth() {
-    if (process.platform !== "darwin")
+/** The Claude Code CLI's own login on macOS: the keychain item the CLI writes. */
+function keychainCredentials() {
+    try {
+        const credentials = object(JSON.parse(execFileSync("security", ["find-generic-password", "-a", process.env.USER ?? os.userInfo().username, "-s", "Claude Code-credentials", "-w"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] })));
+        const oauth = object(credentials?.claudeAiOauth);
+        if (typeof oauth?.accessToken === "string" && oauth.accessToken && typeof oauth.expiresAt === "number")
+            return { accessToken: oauth.accessToken, expiresAt: oauth.expiresAt };
+    }
+    catch { /* the observed login may still serve */ }
+    return null;
+}
+/**
+ * The Claude Code CLI's own login on Windows: `%USERPROFILE%\.claude\.credentials.json`. There is
+ * no keychain there, and the Claude app on its own keeps no credentials file of its own: it
+ * injects the login into the CLI it starts (issue #70).
+ */
+function windowsCredentials(read, userHome) {
+    try {
+        const credentials = object(JSON.parse(read(path.join(userHome, ".claude", ".credentials.json"))));
+        const oauth = object(credentials?.claudeAiOauth);
+        if (typeof oauth?.accessToken === "string" && oauth.accessToken && typeof oauth.expiresAt === "number")
+            return { accessToken: oauth.accessToken, expiresAt: oauth.expiresAt };
+    }
+    catch { /* the observed login may still serve */ }
+    return null;
+}
+export function loadBridgeAuth(options = {}) {
+    const platform = options.platform ?? process.platform;
+    if (platform !== "darwin" && platform !== "win32")
         throw new Error(DESKTOP_BLOCKED);
-    const now = Date.now();
+    const now = options.now ?? Date.now();
+    const userHome = options.userHome ?? os.homedir();
+    const read = options.readFile ?? ((file) => fs.readFileSync(file, "utf8"));
     let organizationUuid;
     try {
-        const account = object(object(JSON.parse(fs.readFileSync(path.join(os.homedir(), ".claude.json"), "utf8")))?.oauthAccount);
+        const account = object(object(JSON.parse(read(path.join(userHome, ".claude.json"))))?.oauthAccount);
         if (typeof account?.organizationUuid !== "string")
             throw new Error();
         organizationUuid = account.organizationUuid;
@@ -67,23 +96,17 @@ export function loadBridgeAuth() {
     catch {
         throw new BridgeAuthError("이 컴퓨터의 Claude 로그인 정보를 읽을 수 없습니다.");
     }
-    let keychain = null;
-    try {
-        const credentials = object(JSON.parse(execFileSync("security", ["find-generic-password", "-a", process.env.USER ?? os.userInfo().username, "-s", "Claude Code-credentials", "-w"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] })));
-        const oauth = object(credentials?.claudeAiOauth);
-        if (typeof oauth?.accessToken === "string" && oauth.accessToken && typeof oauth.expiresAt === "number")
-            keychain = { accessToken: oauth.accessToken, expiresAt: oauth.expiresAt };
-    }
-    catch { /* the observed login may still serve */ }
+    // The CLI's own login: the macOS keychain item, or the credentials file Windows keeps.
+    const cli = options.cli ? options.cli() : platform === "darwin" ? keychainCredentials() : windowsCredentials(read, userHome);
     // The CLI's login while it is good; else the one the Claude app is working with; else the
     // CLI's expired one, so the phone is told it expired.
-    if (keychain && keychain.expiresAt - now > 5 * 60_000)
-        return { ...keychain, organizationUuid };
-    const observed = loadObservedAuth(now);
+    if (cli && cli.expiresAt - now > 5 * 60_000)
+        return { ...cli, organizationUuid };
+    const observed = options.observed ? options.observed(now) : loadObservedAuth(now);
     if (observed)
         return { ...observed, organizationUuid };
-    if (keychain)
-        return { ...keychain, organizationUuid };
+    if (cli)
+        return { ...cli, organizationUuid };
     throw new BridgeAuthError(LOGIN_EXPIRED);
 }
 /** `slash_commands` minus `terminal_slash_commands`, which phone UIs should hide (SDK init docs). */

package/dist/remote/src/desktop.js

@@ -5,7 +5,7 @@ import { execFileSync } from "node:child_process";
 import os from "node:os";
 import path from "node:path";
 import { EventLog } from "./eventlog.js";
-import { processCommands } from "./processes.js";
+import { creationDateToFileTime, parseFileTime, processCommands, processSnapshot, sameFileTime } from "./processes.js";
 import { messageContent, sendUserFileImages } from "./images.js";
 import { PERMISSION_MODES } from "./protocol.js";
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -18,15 +18,64 @@ const RECENT_MS = 14 * 24 * 60 * 60 * 1000;
  */
 const verifiedStarts = new Map();
 let snapshot = null;
-/** Registry identity is authoritative; ps flags remain a legacy fallback only. Cached for 1 s. */
-export function liveDesktopProcesses(dir, maxAgeMs = 1000, platform = process.platform) {
-    if (platform !== "darwin")
+/**
+ * Is this pid the process the registry recorded? On macOS the start time comes from `ps`.
+ */
+function darwinAlive() {
+    return (pid, procStart) => {
+        try {
+            process.kill(pid, 0);
+            if (typeof procStart === "string" && verifiedStarts.get(pid) !== procStart) {
+                const started = execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf8", env: { ...process.env, LC_ALL: "C", TZ: "UTC" }, stdio: ["ignore", "pipe", "ignore"] }).trim();
+                if (started !== procStart)
+                    return false;
+                verifiedStarts.set(pid, started);
+            }
+            return true;
+        }
+        catch {
+            return false;
+        } // Dead or recycled process, not a live desktop writer.
+    };
+}
+/**
+ * Is this pid the process the registry recorded? Windows has no `ps -o lstart=`: the registry's
+ * procStart is a FILETIME (100 ns ticks since 1601) and the OS reports the same instant as a
+ * CreationDate. A pid alone proves nothing there — Windows recycles pids — so the start times
+ * are compared (issue #70).
+ */
+function windowsAlive(processes) {
+    const running = new Set();
+    const starts = new Map();
+    for (const p of processes.current()) {
+        running.add(p.pid);
+        const start = typeof p.started === "string" ? creationDateToFileTime(p.started) : null;
+        if (start !== null)
+            starts.set(p.pid, start);
+    }
+    return (pid, procStart) => {
+        if (!running.has(pid))
+            return false;
+        const started = starts.get(pid);
+        const recorded = parseFileTime(procStart);
+        if (started === undefined || recorded === null)
+            return true; // Nothing to compare: the pid runs.
+        return sameFileTime(started, recorded);
+    };
+}
+/**
+ * Registry identity is authoritative; ps flags remain a legacy fallback only. Cached for 1 s.
+ * The Windows snapshot behind it is read in the background, so this never waits for PowerShell
+ * more than once (see ProcessSnapshot).
+ */
+export function liveDesktopProcesses(dir, maxAgeMs = 1000, platform = process.platform, processes = processSnapshot) {
+    if (platform !== "darwin" && platform !== "win32")
         return new Map();
     const now = Date.now();
-    if (snapshot && snapshot.dir === dir && now - snapshot.at < maxAgeMs)
+    if (snapshot && snapshot.dir === dir && snapshot.platform === platform && now - snapshot.at < maxAgeMs)
         return snapshot.result;
     const result = new Map();
-    snapshot = { dir, at: now, result };
+    snapshot = { dir, platform, at: now, result };
     let entries;
     try {
         entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -36,6 +85,7 @@ export function liveDesktopProcesses(dir, maxAgeMs = 1000, platform = process.pl
             return result;
         throw error;
     }
+    const candidates = [];
     for (const entry of entries) {
         if (!entry.isFile() || !/^\d+\.json$/.test(entry.name))
             continue;
@@ -53,20 +103,16 @@ export function liveDesktopProcesses(dir, maxAgeMs = 1000, platform = process.pl
             continue;
         if (!["busy", "shell", "idle", "waiting"].includes(str(value.status)))
             continue;
-        try {
-            process.kill(pid, 0);
-            if (typeof value.procStart === "string" && verifiedStarts.get(pid) !== value.procStart) {
-                const started = execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf8", env: { ...process.env, LC_ALL: "C", TZ: "UTC" }, stdio: ["ignore", "pipe", "ignore"] }).trim();
-                if (started !== value.procStart)
-                    continue;
-                verifiedStarts.set(pid, started);
-            }
-        }
-        catch {
-            continue;
-        } // Dead or recycled process, not a live desktop writer.
         const status = value.status;
-        result.set(value.sessionId, { sessionId: value.sessionId, pid, status, ...(typeof value.bridgeSessionId === "string" ? { bridgeSessionId: value.bridgeSessionId } : {}) });
+        candidates.push({ pid, procStart: value.procStart, entry: { sessionId: value.sessionId, pid, status, ...(typeof value.bridgeSessionId === "string" ? { bridgeSessionId: value.bridgeSessionId } : {}) } });
+    }
+    if (!candidates.length)
+        return result;
+    const alive = platform === "win32" ? windowsAlive(processes) : darwinAlive();
+    for (const candidate of candidates) {
+        if (!alive(candidate.pid, candidate.procStart))
+            continue;
+        result.set(candidate.entry.sessionId, candidate.entry);
     }
     return result;
 }

package/dist/remote/src/processes.js

@@ -1,11 +1,26 @@
-// One OS process snapshot for transcript liveness. Desktop registry identity remains macOS-only.
-import { execFileSync } from "node:child_process";
+// One OS process snapshot for transcript liveness. The desktop registry reads macOS and Windows.
+import { execFile, execFileSync } from "node:child_process";
 import { windowsPowerShellEnv } from "../../cli/src/windows-powershell.js";
-export function listProcesses(platform = process.platform, exec = (file, args) => execFileSync(file, args, {
+/** 100 ns ticks from 1601-01-01 to 1970-01-01: a Windows FILETIME counts from 1601, Unix time from 1970. */
+const FILETIME_UNIX_TICKS = 116444736000000000n;
+/** A millisecond: the registry's own start time and the OS's CreationDate may differ by a hair. */
+const FILETIME_TOLERANCE = 10000n;
+const exec = (file, args) => execFileSync(file, args, {
     encoding: "utf8", maxBuffer: 16 * 1024 * 1024, timeout: 5000, windowsHide: true, env: windowsPowerShellEnv(), stdio: ["ignore", "pipe", "pipe"],
-})) {
+});
+const execAsync = (file, args) => new Promise((resolve, reject) => {
+    execFile(file, args, { encoding: "utf8", maxBuffer: 16 * 1024 * 1024, timeout: 5000, windowsHide: true, env: windowsPowerShellEnv() }, (error, stdout) => { if (error)
+        reject(error);
+    else
+        resolve(stdout); });
+});
+/** The PowerShell that reads the Windows process table: pid, command line and start time. */
+function windowsSnapshotArgs() {
+    return ["-NoProfile", "-NonInteractive", "-Command", "$ErrorActionPreference = 'Stop'; [Console]::OutputEncoding = [Text.UTF8Encoding]::new(); ConvertTo-Json -Compress -InputObject @(Get-CimInstance Win32_Process | Select-Object ProcessId,CommandLine,@{Name='CreationDate';Expression={if ($_.CreationDate) {$_.CreationDate.ToUniversalTime().ToString('o')}}})"];
+}
+export function listProcesses(platform = process.platform, run = exec) {
     if (platform === "win32") {
-        const raw = JSON.parse(exec("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", "$ErrorActionPreference = 'Stop'; [Console]::OutputEncoding = [Text.UTF8Encoding]::new(); ConvertTo-Json -Compress -InputObject @(Get-CimInstance Win32_Process | Select-Object ProcessId,CommandLine,@{Name='CreationDate';Expression={if ($_.CreationDate) {$_.CreationDate.ToUniversalTime().ToString('o')}}})"]));
+        const raw = JSON.parse(run("powershell.exe", windowsSnapshotArgs()));
         if (!Array.isArray(raw))
             throw new Error("invalid Windows process snapshot");
         return raw.flatMap((value) => {
@@ -16,9 +31,123 @@ export function listProcesses(platform = process.platform, exec = (file, args) =
                 ? [{ pid: p.ProcessId, command: p.CommandLine, ...(typeof p.CreationDate === "string" ? { started: p.CreationDate } : {}) }] : [];
         });
     }
-    return exec("ps", ["-axo", "pid,command"]).split(/\r?\n/).flatMap(line => {
+    return run("ps", ["-axo", "pid,command"]).split(/\r?\n/).flatMap(line => {
         const m = /^\s*(\d+)\s+(.+)$/.exec(line);
         return m ? [{ pid: Number(m[1]), command: m[2] }] : [];
     });
 }
-export function processCommands() { return listProcesses().map(p => `${p.pid} ${p.command}`).join("\n"); }
+/** The same snapshot, read without blocking: the Windows path spawns PowerShell in the background. */
+export function listProcessesAsync(platform = process.platform, run = execAsync) {
+    if (platform === "win32")
+        return run("powershell.exe", windowsSnapshotArgs()).then(output => listProcesses(platform, () => output));
+    return run("ps", ["-axo", "pid,command"]).then(output => listProcesses(platform, () => output));
+}
+/**
+ * A Windows process start as the FILETIME the Claude app writes into its desktop registry:
+ * 100 ns ticks since 1601-01-01 UTC. The OS reports the same instant as an ISO string, so it
+ * is converted here (issue #70).
+ */
+export function creationDateToFileTime(value) {
+    const m = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(Z|[+-]\d{2}:?\d{2})?$/.exec(value.trim());
+    if (!m)
+        return null;
+    const [, year, month, day, hour, minute, second, fraction, zone] = m;
+    const seconds = Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second)) / 1000;
+    if (!Number.isFinite(seconds))
+        return null;
+    let offset = 0;
+    if (zone && zone !== "Z") {
+        const parts = zone.slice(1).replace(":", "").match(/\d{2}/g) ?? [];
+        offset = (zone[0] === "-" ? -1 : 1) * (Number(parts[0] ?? 0) * 60 + Number(parts[1] ?? 0)) * 60;
+    }
+    // The fraction is in seconds; its digits are the 100 ns ticks themselves.
+    const ticks = BigInt(Math.round(seconds - offset)) * 10000000n + BigInt((fraction ?? "").padEnd(7, "0").slice(0, 7) || "0");
+    return ticks + FILETIME_UNIX_TICKS;
+}
+/** The registry's own start time, in the same FILETIME. A JSON number has lost its last digits already. */
+export function parseFileTime(value) {
+    if (typeof value === "bigint")
+        return value;
+    if (typeof value === "number")
+        return Number.isFinite(value) && Number.isInteger(value) ? BigInt(value) : null;
+    if (typeof value === "string" && /^\d{1,20}$/.test(value.trim()))
+        return BigInt(value.trim());
+    return null;
+}
+/** The same process start: the same instant, or within a millisecond of it. */
+export function sameFileTime(a, b) {
+    const diff = a > b ? a - b : b - a;
+    return diff <= FILETIME_TOLERANCE;
+}
+/**
+ * The host's view of the running processes. On Windows PowerShell costs hundreds of
+ * milliseconds, so the snapshot is refreshed in the background and read from memory: the host's
+ * event loop never waits for it again (2026-10-12, one keychain read per request blocked the
+ * relay pings). Only the very first read waits, once, so the desktop registry is never empty
+ * when it is asked for (issue #70).
+ *
+ * The registry is read synchronously — Sessions.list, summary and isOpen all are — so the
+ * snapshot cannot be awaited everywhere without making the whole session list asynchronous.
+ * One bounded wait at startup is the price; every later read is a map lookup.
+ */
+export class ProcessSnapshot {
+    processes = [];
+    at = 0;
+    read = false;
+    pending = null;
+    failed = false;
+    platform;
+    ttlMs;
+    now;
+    run;
+    runAsync;
+    onError;
+    constructor(options = {}) {
+        this.platform = options.platform ?? process.platform;
+        this.ttlMs = options.ttlMs ?? 5000;
+        this.now = options.now ?? Date.now;
+        this.run = options.exec ?? exec;
+        this.runAsync = options.execAsync ?? execAsync;
+        this.onError = options.onError ?? (error => console.error("[process snapshot]", error instanceof Error ? error.message : String(error)));
+    }
+    /** The processes known now; on Windows this is what the last read found. */
+    current() {
+        if (this.platform !== "win32")
+            return listProcesses(this.platform, this.run);
+        if (!this.read) {
+            // The first read is the one the host cannot do without: it waits, once.
+            this.read = true;
+            try {
+                this.processes = listProcesses(this.platform, this.run);
+                this.at = this.now();
+                this.failed = false;
+            }
+            catch {
+                this.refresh();
+            }
+            return this.processes;
+        }
+        if (this.now() - this.at >= this.ttlMs)
+            this.refresh();
+        return this.processes;
+    }
+    /** Reads a new snapshot in the background; the current one is served until it lands. */
+    refresh() {
+        if (this.pending)
+            return;
+        this.pending = listProcessesAsync(this.platform, this.runAsync).then(processes => {
+            this.processes = processes;
+            this.at = this.now();
+            this.failed = false;
+        }).catch(error => {
+            // The snapshot stays as it was; a run of failures is reported once, not every read.
+            if (!this.failed) {
+                this.failed = true;
+                this.onError(error);
+            }
+        }).finally(() => { this.pending = null; });
+    }
+}
+/** The snapshot the host reads. One per process, so every reader sees the same processes. */
+export const processSnapshot = new ProcessSnapshot();
+export function processCommands() { return processSnapshot.current().map(p => `${p.pid} ${p.command}`).join("\n"); }

package/dist/router/src/version.js

@@ -5,4 +5,4 @@
 // from the manifests. Until 0.1.1 the router and the CLI each carried their own literal, and both
 // still said "0.1.0" in the 0.1.1 release: after an update nobody could tell which router was
 // running, and the tray app had nothing to compare (2026-09-15, reported from a Windows install).
-export const VERSION = "0.12.3";
+export const VERSION = "0.12.4";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clauderipple",
-  "version": "0.12.3",
+  "version": "0.12.4",
   "description": "Use GPT (any ChatGPT plan with Codex), DeepSeek and 400+ other models in the Claude Desktop Code tab and Claude Code while staying signed in to your Claude subscription — no third-party gateway mode. Several ChatGPT accounts that take over when one runs out, in Codex too.",
   "license": "GPL-3.0-only",
   "workspaces": [