owlmem 0.3.0 → 0.4.0

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";
+export const VERSION = "0.4.0";
 const BASE = (process.env.OWLMEM_URL || "https://app.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,39 @@ 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)) };
+}
+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 +169,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 +272,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 +435,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.0",
   "description": "OwlMem command line: end-to-end encrypted vault for your AI agents, and a local MCP server.",
   "type": "module",
   "bin": { "owlmem": "owlmem.mjs" },