A tinder like app for your lightroom / photo folder
npm run android:install # build the APK and install it over USB
npm run android:install -- --skip-build # reinstall the APK that is already builtNeeds, once: JDK 21 (Temurin), the Android SDK platform-tools, and USB debugging
enabled on the phone. The script checks all three, and that node_modules matches
package.json, and says which one is the problem rather than failing inside Gradle
or adb, or leaving a plugin out of the APK. ANDROID_SERIAL picks a phone when more
than one is attached.
What the APK contains. The frontend. capacitor.config.ts has no server.url,
so the bundle built from your working copy is the app, served from the app's own
origin, https://photokeeper. Backend calls can't share that origin, so they go to
the deployed backend by absolute URL (backendBaseUri in lightroom.service.ts),
which allows the app through ANDROID_ORIGIN in CorsConfig.
The consequences are worth knowing:
- Frontend changes need a reinstall, not
./deploy.sh. Whatever is in your working copy is what lands on the phone, so a change can be tried before anyone else sees it../deploy.shis for the website and for backend changes, which the phone can't see until they are deployed. - The app opens with no network and works from what is on the device. Reaching Lightroom still needs the deployed backend to be up.
- The app's data is its own. Its IndexedDB belongs to
https://photokeeper, so it shares nothing with the website, and changinghostnamewould strand it. - Sign-in runs in the system browser and returns through
photokeeper://auth, because Google refuses to authenticate inside an embedded webview.
PhotoKeeper works over your Lightroom cloud catalog and (in a native/PWA build) the device's own photos. Both can be read in full, which is what lets PhotoKeeper background-scan for near-duplicates, bursts, panos, and stereo pairs.
Google Photos cannot be used as a source — this is a hard limit, not a to-do. Google locked down its Photos API in 2025:
- The Library API's "read your whole library" scopes were removed on 2025-03-31; an app can now only see media it uploaded itself, never your existing photos.
- The replacement Picker API only returns photos you manually hand-pick in the Google Photos UI — there is no way to enumerate a library programmatically. So the background whole-library scanning PhotoKeeper is built around is impossible on Google Photos.
- No Google Photos API can delete a photo from your library either.
Because PhotoKeeper's whole value is scanning an entire library and routing decisions, Google Photos is a non-starter. The realistic second source is the device's own photos.
PhotoKeeper reads your Lightroom catalog and lets you make decisions (keep/reject, ratings, edit/print routing). A natural question is how much of that can be written back into Lightroom. The answer is: very little — and this is a hard limit of Adobe's Lightroom partner API, not a PhotoKeeper shortcoming.
You cannot change these in Lightroom from PhotoKeeper:
- ⭐ Star ratings — no write endpoint exists.
- 🚩 Pick / reject flags — no write endpoint exists.
- 🎨 Color labels, and other per-asset review metadata — no write endpoint exists.
The partner API exposes rating and flag only as read-side filters (you can list
"all rejected assets"), but offers no way to set them. The asset endpoint is
create-only: trying to update an existing asset returns
403 ResourceExistsError "duplicate asset already exists".
The one durable write-back that does work: adding an existing photo to an existing album. PhotoKeeper cannot create albums either (the partner API blocks creating normal user albums), but it can add photos to an album you made yourself.
Adding is one-way: a photo cannot be taken out again. Every removal shape was probed against a real catalog:
| attempt | result |
|---|---|
DELETE /albums/{id}/assets + body |
403000 Forbidden |
DELETE /albums/{id}/assets?ids= |
403000 Forbidden |
DELETE /albums/{id}/assets/{assetId} |
404 Resource not found |
PUT marking the association removed |
ignored; treated as an add |
403000 is the same generic code the rating write returns, so the endpoint exists
and this scope is simply not allowed to call it — a licensing boundary rather than a
missing feature, and one a different scope might lift. The 404 shows the per-membership
path is not the API's shape at all. Editing membership from the asset side is closed
too: any asset PUT is create-only.
What that means in practice: a photo whose verdict changes is added to its new album and stays in the old one. Sent to edit and later promoted to print, it appears in both KeeperEdit and KeeperPrint. PhotoKeeper files the current verdict's album because the alternative — not re-filing — would leave promoted photos missing from KeeperPrint, which is worse than an untidy inbox you empty as you work.
Deleting a photo does not take it out of its albums. Lightroom replaces the asset
with a tombstone: a new asset of subtype: "deleted_image", under a new id, carrying
original.id (the id the photo had), payload.purgeDate (thirty days out) and the
original's metadata down to the filename. That tombstone stays in every album the photo
was in.
So an album listing mixes photographs with the headstones of photographs, and anything
comparing ids against a listing must map a deleted_image back through original.id
first. Compared by id alone every correctly-deleted photo reads as missing from the
album: probed against a real KeeperDelete holding 87 filings, that was 85 "missing", of
which 49 were simply deleted and awaiting the purge and only 36 had genuinely been taken
out of the album by hand. Settings' Put back what Lightroom lost relies on this
distinction — offering to re-file a photo the user had correctly deleted would undo the
work the app exists to help them finish.
So Settings carries a Tidy up Lightroom section listing the photos left behind, with
a link that opens their album showing only them — select all, remove, done. The web app
scopes a search to one album with albumFilter and takes a comma-separated list of
filenames as an OR; both were established by trying them against a real catalog, since
neither route is documented. (OR between terms works too; a pipe does not.) The app
cannot undo its own filing, but it can put you in front of exactly what needs undoing.
Adding is also not idempotent. A photo already in the album is refused with
403 ResourceExistsError "already in album", and one such member fails the whole write
with nothing applied. PhotoKeeper reads that refusal as success for a single-photo call,
and splits a rejected batch to retry one at a time — otherwise a single already-filed
photo would block its album for good.
So PhotoKeeper can route your decisions somewhere durable, create these albums in Lightroom yourself (as normal albums), and PhotoKeeper will populate them:
KeeperEdit— photos you want to editKeeperDelete— photos you've rejected / want to deleteKeeperPrint— photos you want to print
Anything that can't be written back (ratings, flags, the actual edits) is instead handled by deep-linking you to the specific photo in Lightroom, and/or kept in PhotoKeeper's own on-device store.
This limitation is validated live in the detection lab (throwaway write-spike buttons): "Set ★5 + pick" reproduces the
duplicate assetrejection, while the album write-spike succeeds — kept around so the boundary can be re-checked if the partner API ever changes.