@interncom/diplomatic 0.1.2 → 0.2.0-rc1

package/dist/web/shared/types.d.ts

@@ -0,0 +1,163 @@
+import { IClock } from "./clock.ts";
+import { Decoder, Encoder } from "./codec.ts";
+import { IAuthTimestamp } from "./codecs/authTimestamp.ts";
+import type { IBagPeekItem } from "./codecs/peekItem.ts";
+import { IUsageQuota } from "./codecs/usageQuota.ts";
+import { APICallName, Status } from "./consts.ts";
+import { ValStat } from "./valstat.ts";
+export type GroupID = string;
+declare const entityIDSymbol: unique symbol;
+export type EntityID = Uint8Array & {
+    readonly [entityIDSymbol]: true;
+};
+export type SerializedContent = Uint8Array;
+export interface IMsgEntBody<T = unknown> {
+    gid?: GroupID;
+    pid?: EntityID;
+    type: string;
+    body?: T;
+}
+export interface IMessageHead {
+    eid: EntityID;
+    off: number;
+    ctr: number;
+    len: number;
+    hsh?: Uint8Array;
+}
+export interface IMessage extends IMessageHead {
+    bod?: SerializedContent;
+}
+export interface IMessageWithHash extends IMessage {
+    headHash: Hash;
+}
+export interface IDeleteOp extends Omit<IMessageHead, "len" | "hsh" | "bod"> {
+}
+export interface IMutateOp<T = unknown> extends IDeleteOp, Omit<IMsgEntBody<T>, "body"> {
+    body: T;
+}
+export type IOp = IDeleteOp | IMutateOp;
+export declare function isDeleteOp(op: IOp): op is IDeleteOp;
+export declare function isMutateOp(op: IOp): op is IMutateOp;
+export interface IInsertParams<T> extends IMsgEntBody<T> {
+    id?: Uint8Array;
+}
+export interface IUpsertParams<T> extends IMsgEntBody<T> {
+    eid?: EntityID;
+}
+export interface IStorage {
+    addUser: (pubKey: PublicKey) => Promise<ValStat<void>>;
+    hasUser: (pubKey: PublicKey) => Promise<ValStat<boolean>>;
+    subMeta: (pubKey: PublicKey) => Promise<ValStat<ISubscriptionMetadata>>;
+    setBag: (pubKey: PublicKey, bag: IBag) => Promise<ValStat<number>>;
+    getBody: (pubKey: PublicKey, seq: number) => Promise<ValStat<Uint8Array | undefined>>;
+    listHeads: (pubKey: PublicKey, minSeq: number) => Promise<ValStat<IBagPeekItem[]>>;
+}
+export interface KeyPair {
+    keyType: "ed25519";
+    privateKey: PrivateKey;
+    publicKey: PublicKey;
+}
+declare const masterSeedSymbol: unique symbol;
+declare const derivationSeedSymbol: unique symbol;
+declare const publicKeySymbol: unique symbol;
+declare const privateKeySymbol: unique symbol;
+declare const hostSpecificKeyPairSymbol: unique symbol;
+declare const hashSymbol: unique symbol;
+export type MasterSeed = Uint8Array & {
+    readonly [masterSeedSymbol]: true;
+};
+export type DerivationSeed = Uint8Array & {
+    readonly [derivationSeedSymbol]: true;
+};
+export type PublicKey = Uint8Array & {
+    readonly [publicKeySymbol]: true;
+};
+export type PrivateKey = Uint8Array & {
+    readonly [privateKeySymbol]: true;
+};
+export type HostSpecificKeyPair = KeyPair & {
+    readonly [hostSpecificKeyPairSymbol]: true;
+};
+export type Hash = Uint8Array & {
+    readonly [hashSymbol]: true;
+};
+export interface IHostCrypto {
+    checkSigEd25519: (sig: Uint8Array, message: Uint8Array | string, pubKey: PublicKey) => Promise<boolean>;
+}
+export interface ICrypto extends IHostCrypto {
+    genRandomBytes: (bytes: number) => Promise<Uint8Array>;
+    gen256BitSecureRandomSeed: () => Promise<Uint8Array>;
+    encryptXSalsa20Poly1305Combined: (plaintext: Uint8Array, key: Uint8Array) => Promise<Uint8Array>;
+    decryptXSalsa20Poly1305Combined: (headerAndCipher: Uint8Array, key: Uint8Array) => Promise<Uint8Array>;
+    deriveEd25519KeyPair: (derivationSeed: DerivationSeed) => Promise<KeyPair>;
+    signEd25519: (message: Uint8Array | string, secKey: PrivateKey) => Promise<Uint8Array>;
+    blake3: (data: Uint8Array) => Promise<Hash>;
+}
+export interface IMsgpackCodec {
+    encode: (source: unknown) => Uint8Array;
+    decode: (packed: ArrayBuffer | Uint8Array) => unknown;
+    decodeAsync: (stream: ReadableStream<Uint8Array>) => Promise<unknown>;
+}
+export interface IProtoHost {
+    storage: IStorage;
+    crypto: IHostCrypto;
+    notifier: IPushNotifier;
+    clock: IClock;
+}
+export type PushReceiver = (data: Uint8Array) => void;
+export interface IPushOpenResponse {
+    send: (data: Uint8Array) => Status;
+    shut: () => Status;
+    status: Status;
+}
+export interface IPushNotifier {
+    open(authTS: IAuthTimestamp, recv: PushReceiver, crypto: IHostCrypto, clock: IClock): Promise<IPushOpenResponse>;
+    push(pubKey: PublicKey, data: Uint8Array): void;
+}
+export interface IPushListener {
+    connect(authTS: IAuthTimestamp, recv: PushReceiver, onDisconnect: () => void): Promise<Status>;
+    connected(): boolean;
+    disconnect(): void;
+}
+export interface IBagHeader {
+    sig: Uint8Array;
+    kdm: Uint8Array;
+}
+export interface IBag extends IBagHeader {
+    headCph: Uint8Array;
+    bodyCph: Uint8Array;
+}
+export type EncodedBag = Uint8Array;
+export type HostHandle = URL | IProtoHost;
+export interface IHostConnectionInfo<Handle extends HostHandle> {
+    handle: Handle;
+    label: string;
+    idx?: number;
+}
+export interface ISubscriptionMetadata {
+    term: number;
+    elapsed: number;
+    stat: IUsageQuota;
+    dyn: IUsageQuota;
+}
+export declare const nullSubMeta: ISubscriptionMetadata;
+export interface IHostMetadata {
+    subscription: ISubscriptionMetadata;
+    clockOffset: number;
+}
+export interface ITransport {
+    call: (name: APICallName, enc: Encoder) => Promise<ValStat<Decoder>>;
+    listener: IPushListener;
+}
+export interface IStateManager {
+    apply: (msgs: IMessage[]) => Promise<Status[]>;
+    on: (type: string, listener: () => void) => void;
+    off: (type: string, listener: () => void) => void;
+}
+export interface IUpsertMessage extends IMessage {
+    bod: SerializedContent;
+}
+export interface IDeleteMessage extends Omit<IMessage, "bod"> {
+    len: 0;
+}
+export {};

package/dist/web/shared/valstat.d.ts

@@ -0,0 +1,6 @@
+import { Status } from "./consts.ts";
+export type StatusOK = Status.Success;
+export type StatusNOK = Exclude<Status, Status.Success>;
+export type ValStat<T> = [T, StatusOK] | [undefined, StatusNOK];
+export declare function ok<T>(val: T): ValStat<T>;
+export declare function err<T>(stat: StatusNOK): ValStat<T>;

package/package.json

@@ -1,19 +1,35 @@
 {
   "name": "@interncom/diplomatic",
-  "version": "0.1.2",
+  "version": "0.2.0-rc1",
   "type": "module",
-  "description": "Secure sync layer",
-  "main": "dist/index.mjs",
-  "types": "dist/index.d.ts",
+  "description": "Secure sync layer and CLI utilities for DIPLOMATIC",
   "files": [
     "dist"
   ],
+  "bin": {
+    "diplomatic-host": "dist/cli/bin/host.js"
+  },
+  "exports": {
+    ".": {
+      "browser": "./dist/web/index.mjs",
+      "node": "./dist/cli/index.mjs",
+      "types": "./dist/web/index.d.ts"
+    },
+    "./web": {
+      "import": "./dist/web/index.mjs",
+      "types": "./dist/web/index.d.ts"
+    },
+    "./cli": {
+      "import": "./dist/cli/index.mjs",
+      "types": "./dist/cli/index.d.ts"
+    }
+  },
   "scripts": {
-    "tsc": "tsc",
-    "build": "node esbuild.mjs",
-    "test": "vitest",
-    "coverage": "vitest run --coverage",
-    "fmt": "deno fmt"
+    "build": "bun run build-web.mjs && bun run build-cli.mjs",
+    "check": "node check.mjs",
+    "clean": "rm -rf dist",
+    "tsc": "tsc --project ../web/tsconfig.json",
+    "test": "npm test --workspace=web && deno test --allow-net --allow-ffi --allow-env ../deno/"
   },
   "author": "The Internet Committee",
   "license": "ISC",
@@ -21,6 +37,7 @@
     "access": "public"
   },
   "devDependencies": {
+    "@types/bun": "latest",
     "@types/file-saver": "^2.0.7",
     "@types/node": "^20.14.11",
     "@types/react": "^19.1.0",
@@ -36,7 +53,6 @@
   "dependencies": {
     "@msgpack/msgpack": "3.1.3",
     "@noble/hashes": "1.8.0",
-    "file-saver": "2.0.5",
-    "libsodium.js": "git+ssh://github.com/interncom/libsodium.js#e4e7647"
+    "file-saver": "2.0.5"
   }
 }

package/dist/crypto.d.ts

@@ -1,3 +0,0 @@
-import { LibsodiumCrypto } from "./shared/crypto/libsodium";
-declare const libsodiumCrypto: LibsodiumCrypto;
-export default libsodiumCrypto;