enclave-link 0.1.0 → 0.2.0

package/dist/types/answer.d.ts

@@ -1,3 +1,3 @@
 export type Answer = Record<string, string>;
 export declare function sealAnswer(publicKey: Uint8Array<ArrayBuffer>, name: string, answer: Answer): Promise<Uint8Array<ArrayBuffer>>;
-export declare function openAnswer(privateKey: Uint8Array<ArrayBuffer>, name: string, sealed: Uint8Array<ArrayBuffer>): Promise<Answer>;
+export declare function openAnswer(privateKey: Uint8Array<ArrayBuffer>, name: string, sealed: Uint8Array<ArrayBuffer>): Promise<any>;

package/dist/types/index.d.ts

@@ -1 +1,2 @@
-export { openVault, vault, type Request, type Vault, type VaultOptions } from "./vault.js";
+export { Store, type Item } from "./store.js";
+export { openVault, vault, type ItemStore, type Request, type Vault, type VaultOptions } from "./vault.js";

package/dist/types/passkey.d.ts

@@ -1,10 +1,12 @@
+import * as z from "zod";
 import type { Passkey } from "./proton.js";
-export interface SignRequest {
-    origin: string;
-    rpId?: string;
-    challenge: string;
-    allowCredentials?: string[];
-}
+export declare const signRequest: z.ZodObject<{
+    origin: z.ZodString;
+    rpId: z.ZodOptional<z.ZodString>;
+    challenge: z.ZodString;
+    allowCredentials: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type SignRequest = z.infer<typeof signRequest>;
 export interface Assertion {
     id: string;
     authenticatorData: string;

package/dist/types/proton.d.ts

@@ -1,13 +1,15 @@
+import * as z from "zod";
 import type { Item } from "./store.js";
-export interface ProtonItem {
-    title: string;
-    content: Record<string, Record<string, unknown> | string>;
-    note?: string;
-    extra_fields?: {
-        name: string;
-        content: Record<string, string>;
-    }[];
-}
+declare const protonItem: z.ZodObject<{
+    title: z.ZodString;
+    content: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    extra_fields: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        content: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+export type ProtonItem = z.input<typeof protonItem>;
 export interface Passkey {
     rpId: string;
     credentialId: string;
@@ -15,7 +17,14 @@ export interface Passkey {
     userName: string;
     privateKey: string;
 }
-export declare function readProton(vaultName: string, passCli?: string): AsyncGenerator<any, any, any>;
-export declare function toItems(proton: Iterable<ProtonItem>, items?: Map<string, Item>): Generator<readonly [string, Item], void, unknown>;
+export interface ProtonEntry {
+    id: string;
+    vault: string;
+    content: ProtonItem;
+}
+export declare function protonVaults(): Promise<string[]>;
+export declare function readProton(vault: string): Promise<ProtonEntry[]>;
+export declare function toItems<Entry extends ProtonItem>(proton: Iterable<Entry>, items?: Map<string, true | Item>): Generator<readonly [string, Item, Entry], void, unknown>;
 export declare function toItem({ content, note, extra_fields }: ProtonItem): Item;
-export declare function readPasskey(content: ArrayLike<number>): Passkey;
+export declare function readPasskey(content: number[]): Passkey;
+export {};

package/dist/types/store.d.ts

@@ -1,6 +1,7 @@
 export type Item = Record<string, string>;
 export declare class Store {
     readonly dir: string;
+    private keys?;
     constructor(dir: string);
     get(name: string): Promise<Item | undefined>;
     put(name: string, item: Item): Promise<void>;
@@ -8,5 +9,6 @@ export declare class Store {
     names(): Promise<string[]>;
     private path;
     private key;
+    private load;
     private temporary;
 }

package/dist/types/vault.d.ts

@@ -1,45 +1,57 @@
 import { type SignRequest } from "./passkey.js";
 import { type Stdio } from "./run.js";
-import { type Item } from "./store.js";
+import { Store } from "./store.js";
 export interface VaultOptions {
     from?: string;
     home?: string;
     relay?: string;
+    store?: ItemStore;
 }
+export type ItemStore = Pick<Store, "get" | "put" | "remove" | "names">;
 export interface Request {
     url: string;
     wait(): Promise<string[]>;
 }
-export declare function openVault({ from, home, relay, }?: VaultOptions): {
+export declare function openVault({ from, home, relay, store, }?: VaultOptions): {
     ask: (name: string, fields?: string[]) => Promise<Request>;
-    wait: (name: string) => Promise<string[]>;
+    wait: (name: string, signal?: AbortSignal) => Promise<string[]>;
     get: (name: string, field: string) => Promise<string>;
-    list: () => Promise<{
+    save: (name: string, field: string, value: string) => Promise<void>;
+    list: (search?: string) => Promise<{
         name: string;
         fields: string[];
     }[]>;
     remove: (name: string) => Promise<void>;
     run: (command: string[], secrets: Record<string, string>, stdio?: Stdio) => Promise<number>;
-    importProton: (vaultName: string) => Promise<Map<string, Item>>;
-    passkey: (name: string, field?: string, timeout?: number) => Promise<{
-        signedIn: Promise<void>;
+    importProton: (vaults?: string[]) => Promise<{
+        items: {
+            name: string;
+            fields: string[];
+        }[];
+        removed: string[];
     }>;
+    passkey: (name: string, field?: string, timeout?: number) => Promise<void>;
     sign: (request: SignRequest) => Promise<import("./passkey.ts").Assertion>;
 };
 export type Vault = ReturnType<typeof openVault>;
 export declare const vault: {
     ask: (name: string, fields?: string[]) => Promise<Request>;
-    wait: (name: string) => Promise<string[]>;
+    wait: (name: string, signal?: AbortSignal) => Promise<string[]>;
     get: (name: string, field: string) => Promise<string>;
-    list: () => Promise<{
+    save: (name: string, field: string, value: string) => Promise<void>;
+    list: (search?: string) => Promise<{
         name: string;
         fields: string[];
     }[]>;
     remove: (name: string) => Promise<void>;
     run: (command: string[], secrets: Record<string, string>, stdio?: Stdio) => Promise<number>;
-    importProton: (vaultName: string) => Promise<Map<string, Item>>;
-    passkey: (name: string, field?: string, timeout?: number) => Promise<{
-        signedIn: Promise<void>;
+    importProton: (vaults?: string[]) => Promise<{
+        items: {
+            name: string;
+            fields: string[];
+        }[];
+        removed: string[];
     }>;
+    passkey: (name: string, field?: string, timeout?: number) => Promise<void>;
     sign: (request: SignRequest) => Promise<import("./passkey.ts").Assertion>;
 };

package/package.json

@@ -1,41 +1,45 @@
 {
   "name": "enclave-link",
-  "version": "0.1.0",
-  "description": "Ask a person for a secret through a one-time link. It's encrypted in their browser, and only your agent can open it.",
+  "version": "0.2.0",
+  "description": "A vault for your agent: ask for secrets by encrypted one-time link, use them unseen, 2FA and passkeys too",
   "license": "MIT",
-  "type": "module",
-  "exports": {
-    ".": {
-      "types": "./dist/types/index.d.ts",
-      "default": "./dist/index.js"
-    }
-  },
-  "types": "./dist/types/index.d.ts",
   "bin": {
     "enclave": "dist/enclave.js"
   },
   "files": [
     "dist"
   ],
-  "engines": {
-    "node": ">=22"
+  "type": "module",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/index.js"
+    }
   },
   "scripts": {
     "dev": "node scripts/page.ts && convex dev",
     "deploy": "node scripts/page.ts && convex deploy",
     "build": "node scripts/build.ts",
     "prepack": "npm run build",
-    "check": "node scripts/page.ts && tsc -p . && node --test 'test/*.test.ts'"
+    "check": "node scripts/page.ts && tsc -p . && oxlint && oxfmt --check && node --test 'test/*.test.ts'",
+    "format": "oxfmt && oxlint --fix"
   },
   "devDependencies": {
     "@convex-dev/rate-limiter": "^0.4.1",
     "@modelcontextprotocol/sdk": "^1.32.1",
     "@msgpack/msgpack": "^3.1.3",
+    "@oxlint/plugins": "^1.90.0",
     "@types/node": "^24.0.0",
     "convex": "^1.46.0",
     "esbuild": "0.27.0",
+    "oxfmt": "^0.75.0",
+    "oxlint": "^1.90.0",
     "typescript": "^7.0.2",
     "zod": "^4.6.5"
   },
+  "engines": {
+    "node": ">=22"
+  },
   "mcpName": "io.github.avgvstvs96/enclave"
 }

package/dist/chunk-U67V476Y.js

@@ -1,35 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-export {
-  __commonJS,
-  __export,
-  __toESM
-};