v0.2.0: bubble for Android 0.2.0 — chat search, swipe for unread, faster chat opening
Desktop: - Search lists chats whose own name matches first, so a named group isn't pushed out of the top 8 by chats that merely include a member. Android (Rabbit R1) app, 0.2.0: - Pull the chat list past its top for a search box (name, person, number, then group members; archived chats too; Back clears it). - Swipe right to left marks a chat unread / read over a magenta band; left to right still archives (SwipeActions replaces SwipeArchive). - Google Voice chats don't offer voice notes in the paperclip bubble. - Chats open with their newest 60 messages, then the full history; marking read (and the Google Voice network call) waits until they're on screen. Cached pictures show at once, and one slow download no longer blocks the other images. Fixed a contacts reload race. - Sandbox data gains filler chats, a named group and a 4,000-message chat. Also: the Android app, Google Voice support, media, export, emoji and the other work since the first commit, and a CLAUDE.md carrying the privacy rule.
This commit is contained in:
@@ -0,0 +1,266 @@
|
||||
// Installing the Android app on a Rabbit R1 (or any Android device) over adb,
|
||||
// with the accounts, history and chat names copied into its private storage,
|
||||
// so it opens signed in and with everything already there.
|
||||
//
|
||||
// Files go in through `adb shell -T "run-as <pkg> ..."`: run-as needs the APK
|
||||
// to be debuggable (android/build.py builds it that way), and shell -T (no
|
||||
// pty) passes stdin through byte for byte, waits for the command to finish and
|
||||
// returns its exit code. (exec-in does none of the last two: it ends the
|
||||
// remote command as soon as stdin runs out.) Nothing secret touches the desktop's disk on
|
||||
// the way: the accounts JSON is piped straight in.
|
||||
import Database from 'better-sqlite3'
|
||||
import { app } from 'electron'
|
||||
import { spawn } from 'node:child_process'
|
||||
import fs from 'node:fs'
|
||||
import os from 'node:os'
|
||||
import path from 'node:path'
|
||||
import type { MessageDb, NameChange, ReadState } from './db'
|
||||
|
||||
export interface RabbitConfig {
|
||||
sandbox?: boolean
|
||||
voipms: { username: string; password: string } | null
|
||||
gvoice: { number: string; cookies: Record<string, string> } | null
|
||||
dids: Array<{ did: string; description: string }>
|
||||
defaultDid?: string
|
||||
}
|
||||
|
||||
export interface RabbitTarget {
|
||||
pkg: string
|
||||
apk: string
|
||||
}
|
||||
|
||||
export interface DeviceInfo {
|
||||
serial: string
|
||||
model: string
|
||||
installedVersion?: string
|
||||
}
|
||||
|
||||
const ADB_DIRS = ['/usr/local/sbin', '/usr/local/bin', '/usr/bin', path.join(os.homedir(), 'Android/Sdk/platform-tools')]
|
||||
|
||||
export function findAdb(): string | undefined {
|
||||
const dirs = [...(process.env['PATH'] ?? '').split(':'), ...ADB_DIRS]
|
||||
return dirs.map((d) => path.join(d, 'adb')).find((f) => f && fs.existsSync(f))
|
||||
}
|
||||
|
||||
// The APK shipped with the desktop app (android/build.py --ship).
|
||||
export function bundledApk(): { apk: string; version?: string } | undefined {
|
||||
const packaged = path.join(process.resourcesPath ?? '', 'android', 'VoipMessages.apk')
|
||||
const dev = path.join(app.getAppPath(), 'resources', 'android', 'VoipMessages.apk')
|
||||
const apk = [packaged, dev].find((f) => fs.existsSync(f))
|
||||
if (!apk) return undefined
|
||||
try {
|
||||
const meta = JSON.parse(fs.readFileSync(apk.replace(/\.apk$/, '.json'), 'utf8')) as { version_name: string }
|
||||
return { apk, version: meta.version_name }
|
||||
} catch {
|
||||
return { apk }
|
||||
}
|
||||
}
|
||||
|
||||
class Adb {
|
||||
constructor(
|
||||
readonly adb: string,
|
||||
readonly serial: string
|
||||
) {}
|
||||
|
||||
// Runs adb; resolves stdout. `input` is piped to stdin (a Buffer or a stream).
|
||||
run(args: string[], input?: Buffer | NodeJS.ReadableStream, timeoutMs = 120_000): Promise<Buffer> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const p = spawn(this.adb, this.serial ? ['-s', this.serial, ...args] : args)
|
||||
const out: Buffer[] = []
|
||||
const err: Buffer[] = []
|
||||
const timer = setTimeout(() => p.kill(), timeoutMs)
|
||||
p.stdout.on('data', (d: Buffer) => out.push(d))
|
||||
p.stderr.on('data', (d: Buffer) => err.push(d))
|
||||
p.on('error', reject)
|
||||
p.on('close', (code) => {
|
||||
clearTimeout(timer)
|
||||
const stderr = Buffer.concat(err).toString().trim()
|
||||
if (code === 0) resolve(Buffer.concat(out))
|
||||
else reject(new Error(stderr.split('\n').pop() || `adb ${args[0]} failed (${code})`))
|
||||
})
|
||||
if (input instanceof Buffer) p.stdin.end(input)
|
||||
else if (input) (input as NodeJS.ReadableStream).pipe(p.stdin)
|
||||
else p.stdin.end()
|
||||
})
|
||||
}
|
||||
|
||||
async shell(cmd: string, timeoutMs?: number): Promise<string> {
|
||||
return (await this.run(['shell', cmd], undefined, timeoutMs)).toString()
|
||||
}
|
||||
|
||||
// A command run as the app (in its private data dir), fed `input`.
|
||||
asApp(pkg: string, cmd: string, input?: Buffer | NodeJS.ReadableStream, timeoutMs?: number): Promise<Buffer> {
|
||||
return this.run(['shell', '-T', `run-as ${pkg} sh -c ${shq(cmd)}`], input, timeoutMs)
|
||||
}
|
||||
|
||||
readAsApp(pkg: string, file: string): Promise<Buffer> {
|
||||
return this.run(['exec-out', `run-as ${pkg} sh -c ${shq(`cat ${file} 2>/dev/null || true`)}`])
|
||||
}
|
||||
}
|
||||
|
||||
const shq = (s: string): string => `'${s.replace(/'/g, `'\\''`)}'`
|
||||
|
||||
async function listDevices(adb: string): Promise<Array<{ serial: string; state: string; model: string }>> {
|
||||
const out = await new Adb(adb, '').run(['devices', '-l']).catch(() => Buffer.from(''))
|
||||
return out
|
||||
.toString()
|
||||
.split('\n')
|
||||
.slice(1)
|
||||
.map((l) => l.trim())
|
||||
.filter(Boolean)
|
||||
.map((l) => {
|
||||
const [serial, state] = l.split(/\s+/)
|
||||
const model = /model:(\S+)/.exec(l)?.[1]?.replace(/_/g, ' ') ?? serial
|
||||
return { serial, state, model }
|
||||
})
|
||||
}
|
||||
|
||||
export async function connect(): Promise<Adb> {
|
||||
const adb = findAdb()
|
||||
if (!adb) throw new Error("adb isn't installed on this computer.")
|
||||
const devices = await listDevices(adb)
|
||||
const ready = devices.find((d) => d.state === 'device')
|
||||
if (ready) return new Adb(adb, ready.serial)
|
||||
if (devices.some((d) => d.state === 'unauthorized')) throw new Error('Unlock the Rabbit and allow USB debugging for this computer.')
|
||||
throw new Error('No Rabbit connected. Plug it in over USB (with USB debugging on).')
|
||||
}
|
||||
|
||||
export async function status(pkg: string): Promise<DeviceInfo | undefined> {
|
||||
const adb = findAdb()
|
||||
if (!adb) return undefined
|
||||
const ready = (await listDevices(adb)).find((d) => d.state === 'device')
|
||||
if (!ready) return undefined
|
||||
const a = new Adb(adb, ready.serial)
|
||||
const info = await a.shell(`dumpsys package ${pkg} | grep -m1 versionName`).catch(() => '')
|
||||
const version = /versionName=(\S+)/.exec(info)?.[1]
|
||||
return { serial: ready.serial, model: ready.model, ...(version ? { installedVersion: version } : {}) }
|
||||
}
|
||||
|
||||
// A copy of the history the Android app can open: its SQLite has no FTS5,
|
||||
// so the search index (and the triggers that feed it) come out.
|
||||
async function historyCopy(db: MessageDb): Promise<string> {
|
||||
const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'voip-rabbit-'))
|
||||
const file = path.join(dir, 'messages.db')
|
||||
await db.db.backup(file)
|
||||
const copy = new Database(file)
|
||||
copy.exec(`
|
||||
DROP TRIGGER IF EXISTS messages_ai; DROP TRIGGER IF EXISTS messages_ad; DROP TRIGGER IF EXISTS messages_au;
|
||||
DROP TABLE IF EXISTS messages_fts;
|
||||
`)
|
||||
copy.pragma('journal_mode = DELETE')
|
||||
copy.exec('VACUUM')
|
||||
copy.close()
|
||||
return file
|
||||
}
|
||||
|
||||
// Merge chat names and read/unread/archived state both ways: the Rabbit's
|
||||
// (files/state.json, which the app keeps current) into the desktop, then the
|
||||
// combined result back (files/state-in.json, applied by the app on its next
|
||||
// start or check). Newest change wins on each side. Returns how many
|
||||
// conversations changed here.
|
||||
interface SyncState {
|
||||
names: NameChange[]
|
||||
read: ReadState[]
|
||||
}
|
||||
|
||||
async function syncState(a: Adb, pkg: string, db: MessageDb): Promise<number> {
|
||||
const raw = (await a.readAsApp(pkg, 'files/state.json')).toString().trim()
|
||||
let theirs: SyncState = { names: [], read: [] }
|
||||
try {
|
||||
if (raw) theirs = { names: [], read: [], ...(JSON.parse(raw) as Partial<SyncState>) }
|
||||
} catch {
|
||||
/* a half-written file: skip this round */
|
||||
}
|
||||
const changed = db.namesImport(theirs.names) + db.readStateImport(theirs.read)
|
||||
const ours: SyncState = { names: db.namesExport(), read: db.readStateExport() }
|
||||
await a.asApp(pkg, 'umask 077 && cat > files/state-in.json.tmp && mv files/state-in.json.tmp files/state-in.json', Buffer.from(JSON.stringify(ours)))
|
||||
return changed
|
||||
}
|
||||
|
||||
export type Progress = (step: string) => void
|
||||
|
||||
export interface InstallDeps {
|
||||
db: MessageDb
|
||||
mediaDir: string
|
||||
target: RabbitTarget
|
||||
config: () => Promise<RabbitConfig>
|
||||
progress: Progress
|
||||
}
|
||||
|
||||
async function pushConfig(a: Adb, pkg: string, cfg: RabbitConfig): Promise<void> {
|
||||
// Straight from memory into the app's private files: no temp file.
|
||||
await a.asApp(pkg, 'mkdir -p files && umask 077 && cat > files/config.json.tmp && mv files/config.json.tmp files/config.json', Buffer.from(JSON.stringify(cfg)))
|
||||
}
|
||||
|
||||
async function lockDown(a: Adb, pkg: string): Promise<void> {
|
||||
await a.asApp(pkg, 'chmod -R go-rwx files')
|
||||
}
|
||||
|
||||
// Fresh install (or reinstall): app, permissions, accounts, history, photos, names.
|
||||
// Photos the Rabbit doesn't have yet (files are named by content hash, so a
|
||||
// name it already has is the same file). Returns how many were sent.
|
||||
async function copyMedia(a: Adb, pkg: string, mediaDir: string, progress: Progress): Promise<number> {
|
||||
if (!fs.existsSync(mediaDir)) return 0
|
||||
const have = new Set((await a.asApp(pkg, 'mkdir -p files/media && ls files/media')).toString().split('\n').map((l) => l.trim()))
|
||||
const missing = fs.readdirSync(mediaDir).filter((f) => !have.has(f) && fs.statSync(path.join(mediaDir, f)).isFile())
|
||||
if (!missing.length) return 0
|
||||
progress(`Copying ${missing.length.toLocaleString()} photo${missing.length === 1 ? '' : 's'} and attachments…`)
|
||||
const tar = spawn('tar', ['-C', mediaDir, '-cf', '-', '-T', '-'])
|
||||
tar.stdin.end(missing.join('\n') + '\n')
|
||||
await a.asApp(pkg, 'cd files/media && tar xf -', tar.stdout, 1_800_000)
|
||||
return missing.length
|
||||
}
|
||||
|
||||
// 'full': the app plus history and photos (first install, or starting over;
|
||||
// only photos the Rabbit lacks are sent). 'update': just the new app version
|
||||
// -- Android keeps the app's data across an update -- plus accounts and the
|
||||
// names / read-status merge.
|
||||
export async function install({ db, mediaDir, target, config, progress, mode = 'full' }: InstallDeps & { mode?: 'full' | 'update' }): Promise<number> {
|
||||
const { pkg, apk } = target
|
||||
progress('Connecting to the Rabbit…')
|
||||
const a = await connect()
|
||||
progress('Installing the app…')
|
||||
await a.run(['install', '-r', '-g', apk], undefined, 300_000)
|
||||
// Background checks: exempt from Doze and background limits.
|
||||
await a.shell(`dumpsys deviceidle whitelist +${pkg}`).catch(() => undefined)
|
||||
await a.shell(`cmd appops set ${pkg} RUN_ANY_IN_BACKGROUND allow`).catch(() => undefined)
|
||||
await a.shell(`am force-stop ${pkg}`)
|
||||
|
||||
progress('Copying your accounts…')
|
||||
await pushConfig(a, pkg, await config())
|
||||
|
||||
if (mode === 'full') {
|
||||
progress('Copying your message history…')
|
||||
const history = await historyCopy(db)
|
||||
try {
|
||||
await a.asApp(pkg, 'rm -f files/messages.db files/messages.db-wal files/messages.db-shm files/messages.db-journal')
|
||||
await a.asApp(pkg, 'umask 077 && cat > files/messages.db', fs.createReadStream(history), 600_000)
|
||||
} finally {
|
||||
fs.rmSync(path.dirname(history), { recursive: true, force: true })
|
||||
}
|
||||
await copyMedia(a, pkg, mediaDir, progress)
|
||||
}
|
||||
|
||||
progress('Syncing chat names and read status…')
|
||||
const names = await syncState(a, pkg, db)
|
||||
await lockDown(a, pkg)
|
||||
progress('Opening it on the Rabbit…')
|
||||
await a.shell(`am start -n ${pkg}/me.teafry.voipmessages.MainActivity`)
|
||||
return names
|
||||
}
|
||||
|
||||
// Accounts and chat names again (e.g. after reconnecting Google Voice), without
|
||||
// touching the app or its history. Returns how many names changed here.
|
||||
export async function sync({ db, target, config, progress }: Omit<InstallDeps, 'mediaDir'>): Promise<number> {
|
||||
const { pkg } = target
|
||||
progress('Connecting to the Rabbit…')
|
||||
const a = await connect()
|
||||
const installed = await a.shell(`pm path ${pkg}`).catch(() => '')
|
||||
if (!installed.trim()) throw new Error("The app isn't on the Rabbit yet. Use Install to Rabbit first.")
|
||||
progress('Copying your accounts…')
|
||||
await pushConfig(a, pkg, await config())
|
||||
progress('Syncing chat names and read status…')
|
||||
const names = await syncState(a, pkg, db)
|
||||
await lockDown(a, pkg)
|
||||
return names
|
||||
}
|
||||
Reference in New Issue
Block a user