owlmem 0.3.0 → 0.4.1

package/owlmem.mjs

@@ -27,13 +27,14 @@ import { homedir } from "node:os";
 import { join, dirname } from "node:path";
 import { spawn } from "node:child_process";
 
-export const VERSION = "0.3.0";
-const BASE = (process.env.OWLMEM_URL || "https://app.owlmem.com").replace(/\/$/, "");
+export const VERSION = "0.4.1";
+const BASE = (process.env.OWLMEM_URL || "https://owlmem.com").replace(/\/$/, "");
 const DIR = process.env.OWLMEM_HOME || join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "owlmem");
 const enc = new TextEncoder(), dec = new TextDecoder();
 const say = (...a) => process.stderr.write(a.join(" ") + "\n");
 class Fail extends Error {}
 
+// >>> vault core（浏览器也能跑：控制台的保险库导入导出经 /cli/vault-core.mjs 用同一份代码；这一段里别用 Node 专有的东西）
 // ── encoding ──
 const B32 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
 export function b32encode(bytes) {
@@ -47,8 +48,8 @@ export function b32decode(s) {
   for (const ch of s) { const i = B32.indexOf(ch); if (i < 0) throw new Fail("That recovery code has a character that doesn't belong in it."); val = (val << 5) | i; bits += 5; if (bits >= 8) { out.push((val >>> (bits - 8)) & 255); bits -= 8; } }
   return new Uint8Array(out);
 }
-const b64 = (u8) => Buffer.from(u8).toString("base64");
-const unb64 = (s) => new Uint8Array(Buffer.from(s, "base64"));
+const b64 = (u8) => { let s = ""; for (const x of u8) s += String.fromCharCode(x); return btoa(s); };
+const unb64 = (s) => Uint8Array.from(atob(s), (c) => c.charCodeAt(0));
 
 // ── keys ──
 export function recoveryCode(key) { return "OWL-" + b32encode(key).match(/.{1,4}/g).join("-"); }
@@ -84,6 +85,76 @@ export async function verifyKeyCheck(raw, space, kc) {
   try { return (await open(raw, space, KEY_CHECK, n, c)).owlmem === "key-check-v1"; } catch { return false; }
 }
 
+// ── unlock in the browser (passkey) ──
+// The command line makes a one-time ECDH (P-256) key pair and sends only the public key. Someone signed in to the console unlocks the
+// vault there (passkey or recovery code) and seals the vault key to that public key; OwlMem relays the sealed box and can't open it.
+// Both sides show the same fingerprint of the public key, so a swapped key would be noticed.
+const UNLOCK_INFO = enc.encode("owlmem-unlock-v1");
+const ECDH = { name: "ECDH", namedCurve: "P-256" };
+async function unlockAesKey(priv, pub, space, usage) {
+  const bits = await crypto.subtle.deriveBits({ name: "ECDH", public: pub }, priv, 256);
+  const hk = await crypto.subtle.importKey("raw", bits, "HKDF", false, ["deriveKey"]);
+  return crypto.subtle.deriveKey({ name: "HKDF", hash: "SHA-256", salt: enc.encode(space), info: UNLOCK_INFO }, hk, { name: "AES-GCM", length: 256 }, false, [usage]);
+}
+export async function unlockKeypair() {
+  const kp = await crypto.subtle.generateKey(ECDH, false, ["deriveBits"]);
+  return { privateKey: kp.privateKey, pubkey: b64(new Uint8Array(await crypto.subtle.exportKey("raw", kp.publicKey))) };
+}
+export async function unlockFingerprint(pubkey) {
+  const h = new Uint8Array(await crypto.subtle.digest("SHA-256", unb64(pubkey)));
+  const s = b32encode(h).slice(0, 8); return s.slice(0, 4) + "-" + s.slice(4);
+}
+export async function sealForMachine(pubkey, rawKey, space) {
+  const eph = await crypto.subtle.generateKey(ECDH, true, ["deriveBits"]);
+  const pub = await crypto.subtle.importKey("raw", unb64(pubkey), ECDH, false, []);
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const ct = await crypto.subtle.encrypt({ name: "AES-GCM", iv, additionalData: enc.encode(space) }, await unlockAesKey(eph.privateKey, pub, space, "encrypt"), rawKey);
+  return { epk: b64(new Uint8Array(await crypto.subtle.exportKey("raw", eph.publicKey))), nonce: b64(iv), ct: b64(new Uint8Array(ct)) };
+}
+// ── passkey unlock (browser only: navigator.credentials) ──
+// A passkey's PRF extension returns 32 bytes only that passkey can compute (the server never sees them). They're stretched (HKDF) into a
+// wrapping key that seals the vault key; OwlMem stores only the sealed box (vault_key_wraps). The page that calls these runs on owlmem.com.
+const b64url = (u8) => b64(u8).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+const unb64url = (s) => { s = String(s).replace(/-/g, "+").replace(/_/g, "/"); while (s.length % 4) s += "="; return unb64(s); };
+async function prfWrapKey(prf) {
+  const k = await crypto.subtle.importKey("raw", prf, "HKDF", false, ["deriveKey"]);
+  return crypto.subtle.deriveKey({ name: "HKDF", hash: "SHA-256", salt: new Uint8Array(32), info: enc.encode("owlmem-vault-wrap-v1") }, k, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
+}
+const wrapAad = (space, user, credId) => enc.encode(space + "\n" + user + "\n" + credId);
+// challenge（可选）：服务器发的先验挑战。给了的话这一次刷 Passkey 同时就是「验明正身」——返回的 credential 交给服务器验签（10-24：导出要一步到位）
+export async function passkeyPrf(creds, challenge) {    // creds: [{cred_id, salt}] → {cred_id, prf, credential}
+  if (!globalThis.PublicKeyCredential) throw new Fail("This browser doesn't support passkeys.");
+  const map = Object.fromEntries(creds.map((c) => [c.cred_id, { first: unb64(c.salt) }]));
+  const prf = creds.length === 1 ? { eval: { first: unb64(creds[0].salt) } } : { evalByCredential: map };
+  const cred = await navigator.credentials.get({ publicKey: { challenge: challenge ? unb64url(challenge) : crypto.getRandomValues(new Uint8Array(32)), rpId: location.hostname, userVerification: "required",
+    timeout: 60000, allowCredentials: creds.map((c) => ({ type: "public-key", id: unb64url(c.cred_id) })), extensions: { prf } } });
+  const out = cred.getClientExtensionResults()?.prf?.results?.first;
+  if (!out) throw new Fail("This passkey can't unlock the vault (its device doesn't support the PRF feature). Use another passkey or the recovery code.");
+  const u = (b) => b64url(new Uint8Array(b));
+  return { cred_id: u(cred.rawId), prf: out, credential: { id: cred.id, type: cred.type, response: { clientDataJSON: u(cred.response.clientDataJSON),
+           authenticatorData: u(cred.response.authenticatorData), signature: u(cred.response.signature) } } };
+}
+export async function wrapVaultKey(prf, rawKey, space, user, credId) {
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const ct = await crypto.subtle.encrypt({ name: "AES-GCM", iv, additionalData: wrapAad(space, user, credId) }, await prfWrapKey(prf), rawKey);
+  return { nonce: b64(iv), wrapped: b64(new Uint8Array(ct)) };
+}
+export async function unlockWithPasskey(wraps, space, user, keyCheck, challenge) {   // → {raw, cred_id, credential}
+  const r = await passkeyPrf(wraps, challenge);
+  const w = wraps.find((x) => x.cred_id === r.cred_id);
+  const raw = new Uint8Array(await crypto.subtle.decrypt({ name: "AES-GCM", iv: unb64(w.nonce), additionalData: wrapAad(space, user, w.cred_id) }, await prfWrapKey(r.prf), unb64(w.wrapped)));
+  if (!(await verifyKeyCheck(raw, space, keyCheck))) throw new Fail("Passkey unlock is out of date (the vault was reset). Use the recovery code and set the passkey up again.");
+  return { raw, cred_id: w.cred_id, credential: r.credential };
+}
+export function newSalt() { return b64(crypto.getRandomValues(new Uint8Array(32))); }
+
+export async function openFromBrowser(privateKey, space, box) {
+  const epk = await crypto.subtle.importKey("raw", unb64(box.epk), ECDH, false, []);
+  const pt = await crypto.subtle.decrypt({ name: "AES-GCM", iv: unb64(box.nonce), additionalData: enc.encode(space) }, await unlockAesKey(privateKey, epk, space, "decrypt"), unb64(box.ct));
+  return new Uint8Array(pt);
+}
+// <<< vault core
+
 // ── config ──
 function cfg() { try { return JSON.parse(readFileSync(join(DIR, "config.json"), "utf8")); } catch { return {}; } }
 function saveFile(path, text) { mkdirSync(dirname(path), { recursive: true, mode: 0o700 }); writeFileSync(path, text, { mode: 0o600 }); chmodSync(path, 0o600); }
@@ -135,6 +206,7 @@ async function approved(method, path, body, kind = "access") {
 async function space() { const r = await call("GET", "key-check"); if (r.status >= 400) throw new Fail(r.data.detail || r.data.error); return r.data; }
 const itemPath = (name) => "items/" + name.split("/").map(encodeURIComponent).join("/");
 
+// >>> vault core
 // ── import / export formats ──
 export function parseCSV(text) {
   const rows = []; let row = [], f = "", q = false;
@@ -237,6 +309,26 @@ export function guessCSV(text) {
   if (head.includes('"group"') || head.startsWith("group,") || head.includes("last modified")) return "keepass-csv";
   return "1password-csv";
 }
+// <<< vault core
+
+// ── unlock via the console ──
+async function unlockInBrowser(space) {
+  const kp = await unlockKeypair();
+  const r = await call("POST", "unlock", { pubkey: kp.pubkey });
+  if (r.status >= 400) throw new Fail(r.data.detail || r.data.error);
+  const fp = await unlockFingerprint(kp.pubkey);
+  say("Open this link, sign in, and approve with your passkey:\n\n  " + r.data.url + "\n\nThe console will show a code — check it matches: " + fp + "\nWaiting (up to 10 minutes)…");
+  try { spawn(process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer" : "xdg-open", [r.data.url], { stdio: "ignore", detached: true }).on("error", () => {}).unref(); } catch {}
+  const wait = Number(process.env.OWLMEM_POLL_MS || 2000), until = Date.now() + 10 * 60 * 1000;
+  while (Date.now() < until) {
+    await new Promise((res) => setTimeout(res, wait));
+    const p = await call("GET", "unlock/" + r.data.id);
+    if (p.status >= 400) throw new Fail(p.data.detail || p.data.error);
+    if (p.data.status === "done") { say("Key received from " + p.data.by + "."); return openFromBrowser(kp.privateKey, space, p.data); }
+    if (p.data.status === "expired") break;
+  }
+  throw new Fail("Nobody approved the unlock in time. Run `owlmem vault unlock` again.");
+}
 
 // ── prompts ──
 function readStdin() { return new Promise((res) => { let s = ""; process.stdin.setEncoding("utf8"); process.stdin.on("data", (d) => (s += d)); process.stdin.on("end", () => res(s)); }); }
@@ -380,8 +472,9 @@ export async function main(argv) {
   }
   if (sub === "unlock") {
     const sp = await space();
-    const raw = parseRecovery(await ask("Paste your recovery code (OWL-…, shown as dots), then Enter: "));
-    if (!(await verifyKeyCheck(raw, sp.space, sp.key_check))) throw new Fail("That recovery code doesn't match this space's vault.");
+    const typed = (await ask("Paste your recovery code (OWL-…, shown as dots) — or just press Enter to unlock in your browser with a passkey: ")).trim();
+    const raw = typed ? parseRecovery(typed) : await unlockInBrowser(sp.space);
+    if (!(await verifyKeyCheck(raw, sp.space, sp.key_check))) throw new Fail(typed ? "That recovery code doesn't match this space's vault." : "The key from the browser doesn't match this vault.");
     saveFile(join(DIR, "keys", sp.space + ".key"), b64(raw));
     say("Unlocked: this machine can now decrypt the vault of space " + sp.space + ".");
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "owlmem",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "OwlMem command line: end-to-end encrypted vault for your AI agents, and a local MCP server.",
   "type": "module",
   "bin": { "owlmem": "owlmem.mjs" },