enclave-link 0.0.0-stage → 0.2.0

package/dist/types/answer.d.ts

@@ -0,0 +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<any>;

package/dist/types/base64url.d.ts

@@ -0,0 +1,2 @@
+export declare function encode(bytes: Uint8Array): string;
+export declare function decode(text: string): Uint8Array<ArrayBuffer>;

package/dist/types/hpke.d.ts

@@ -0,0 +1,8 @@
+type Bytes = Uint8Array<ArrayBuffer>;
+export declare function generateKeyPair(): Promise<{
+    publicKey: Uint8Array<ArrayBuffer>;
+    privateKey: Uint8Array<ArrayBuffer>;
+}>;
+export declare function seal(publicKey: Bytes, info: Bytes, aad: Bytes, plaintext: Bytes): Promise<Uint8Array<ArrayBuffer>>;
+export declare function open(privateKey: Bytes, info: Bytes, aad: Bytes, sealed: Bytes): Promise<Uint8Array<ArrayBuffer>>;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,19 @@
+import * as z from "zod";
+import type { Passkey } from "./proton.js";
+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;
+    clientDataJSON: string;
+    signature: string;
+    userHandle: string;
+}
+export declare function relyingParty({ origin, rpId }: SignRequest): string;
+export declare function accepts(passkey: Passkey, request: SignRequest): boolean;
+export declare function signAssertion(passkey: Passkey, request: SignRequest): Assertion;

package/dist/types/proton.d.ts

@@ -0,0 +1,30 @@
+import * as z from "zod";
+import type { Item } from "./store.js";
+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;
+    userHandle: string;
+    userName: string;
+    privateKey: string;
+}
+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: number[]): Passkey;
+export {};

package/dist/types/run.d.ts

@@ -0,0 +1,8 @@
+import { Transform, type Writable } from "node:stream";
+export interface Stdio {
+    stdin: "inherit" | "ignore";
+    stdout: Writable;
+    stderr: Writable;
+}
+export declare function runWithSecrets(command: string[], secrets: Record<string, string>, stdio?: Stdio): Promise<number>;
+export declare function redact(secrets: Record<string, string>): Transform;

package/dist/types/store.d.ts

@@ -0,0 +1,14 @@
+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>;
+    remove(name: string): Promise<void>;
+    names(): Promise<string[]>;
+    private path;
+    private key;
+    private load;
+    private temporary;
+}

package/dist/types/totp.d.ts

@@ -0,0 +1 @@
+export declare function totp(setupKey: string, now?: number): Promise<string>;

package/dist/types/vault.d.ts

@@ -0,0 +1,57 @@
+import { type SignRequest } from "./passkey.js";
+import { type Stdio } from "./run.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, store, }?: VaultOptions): {
+    ask: (name: string, fields?: string[]) => Promise<Request>;
+    wait: (name: string, signal?: AbortSignal) => Promise<string[]>;
+    get: (name: string, field: string) => Promise<string>;
+    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: (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, signal?: AbortSignal) => Promise<string[]>;
+    get: (name: string, field: string) => Promise<string>;
+    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: (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,6 +1,45 @@
 {
   "name": "enclave-link",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "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",
+  "bin": {
+    "enclave": "dist/enclave.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "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 . && 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"
+}