@interncom/diplomatic 0.0.0

package/dist/localStorageStore.d.ts

@@ -0,0 +1,19 @@
+import type { IClientStateStore } from "./types";
+declare class LocalStorageStore implements IClientStateStore {
+    getSeed(): Promise<Uint8Array | undefined>;
+    setSeed(seed: Uint8Array): Promise<void>;
+    getHostURL(): Promise<string | undefined>;
+    setHostURL(url: string): Promise<void>;
+    getHostID(): Promise<string | undefined>;
+    setHostID(id: string): Promise<void>;
+    uploadQueue: Map<string, Uint8Array>;
+    enqueueUpload: (sha256: Uint8Array, cipherOp: Uint8Array) => Promise<void>;
+    dequeueUpload: (sha256: Uint8Array) => Promise<void>;
+    peekUpload: (sha256: Uint8Array) => Promise<Uint8Array | undefined>;
+    listUploadQueue(): Promise<string[]>;
+    downloadQueue: Set<string>;
+    enqueueDownload: (path: string) => Promise<void>;
+    dequeueDownload: (path: string) => Promise<void>;
+}
+export declare const localStorageStore: LocalStorageStore;
+export {};

package/dist/ops.d.ts

@@ -0,0 +1,2 @@
+import { type IOp } from './shared/types';
+export declare function genUpsertOp<T>(type: string, body: T, version?: number): IOp;

package/dist/shared/client.d.ts

@@ -0,0 +1,11 @@
+import type { ICrypto, IGetDeltaPathsResponse, IMsgpackCodec, KeyPair } from "./types.ts";
+export default class DiplomaticClientAPI {
+    codec: IMsgpackCodec;
+    crypto: ICrypto;
+    constructor(codec: IMsgpackCodec, crypto: ICrypto);
+    getHostID(hostURL: URL): Promise<string>;
+    register(hostURL: URL, pubKey: Uint8Array, token: string): Promise<void>;
+    putDelta(hostURL: URL, cipherOp: Uint8Array, keyPair: KeyPair): Promise<string>;
+    getDelta(hostURL: URL, opPath: string, keyPair: KeyPair): Promise<Uint8Array>;
+    getDeltaPaths(hostURL: URL, begin: Date, keyPair: KeyPair): Promise<IGetDeltaPathsResponse>;
+}

package/dist/shared/crypto/libsodium.d.ts

@@ -0,0 +1,15 @@
+import type { ICrypto, KeyPair } from "../types.ts";
+type Libsodium = any;
+export declare class LibsodiumCrypto implements ICrypto {
+    sodium: Libsodium;
+    constructor(sodium: Libsodium);
+    gen256BitSecureRandomSeed(): Promise<Uint8Array>;
+    deriveXSalsa20Poly1305Key(seed: Uint8Array): Promise<Uint8Array>;
+    encryptXSalsa20Poly1305Combined(data: Uint8Array, key: Uint8Array): Promise<Uint8Array>;
+    decryptXSalsa20Poly1305Combined(data: Uint8Array, key: Uint8Array): Promise<Uint8Array>;
+    deriveEd25519KeyPair(seed: Uint8Array, hostID: string, derivationIndex?: number): Promise<KeyPair>;
+    signEd25519(message: Uint8Array | string, secKey: Uint8Array): Promise<Uint8Array>;
+    checkSigEd25519(sig: Uint8Array, message: Uint8Array | string, pubKey: Uint8Array): Promise<boolean>;
+    sha256Hash(data: Uint8Array): Promise<Uint8Array>;
+}
+export {};

package/dist/shared/lib.d.ts

@@ -0,0 +1,2 @@
+export declare function btoh(bytes: Uint8Array): string;
+export declare function htob(hex: string): Uint8Array;

package/dist/shared/server.d.ts

@@ -0,0 +1,11 @@
+import type { IHostCrypto, IMsgpackCodec, IStorage } from "./types.ts";
+export declare class DiplomaticServer {
+    hostID: string;
+    regToken: string;
+    storage: IStorage;
+    codec: IMsgpackCodec;
+    crypto: IHostCrypto;
+    constructor(hostID: string, regToken: string, storage: IStorage, codec: IMsgpackCodec, crypto: IHostCrypto);
+    corsHandler: (request: Request) => Promise<Response>;
+    handler: (request: Request) => Promise<Response>;
+}

package/dist/shared/types.d.ts

@@ -0,0 +1,58 @@
+export declare enum Verb {
+    DELETE = 0,
+    UPSERT = 1
+}
+type Timestamp = string;
+export interface IOp {
+    ts: Timestamp;
+    type: string;
+    verb: Verb;
+    ver: number;
+    body: unknown;
+}
+export type CipherOp = Uint8Array;
+export interface ISyncRequest {
+    ops: CipherOp[];
+    begin: Timestamp;
+}
+export interface IRegistrationRequest {
+    token: string;
+    pubKey: Uint8Array;
+}
+export interface IOperationRequest {
+    cipher: Uint8Array;
+}
+export interface IGetDeltaPathsResponse {
+    paths: string[];
+    fetchedAt: string;
+}
+export interface IStorage {
+    addUser: (pubKeyHex: string) => Promise<void>;
+    hasUser: (pubKeyHex: string) => Promise<boolean>;
+    setOp: (pubKeyHex: string, path: string, op: Uint8Array) => Promise<void>;
+    getOp: (pubKeyHex: string, path: string) => Promise<Uint8Array | undefined>;
+    listOps: (pubKeyHex: string, begin: string, end: string) => Promise<string[]>;
+}
+export interface KeyPair {
+    keyType: "public" | "private" | "secret";
+    privateKey: Uint8Array;
+    publicKey: Uint8Array;
+}
+export interface IHostCrypto {
+    checkSigEd25519: (sig: Uint8Array, message: Uint8Array | string, pubKey: Uint8Array) => Promise<boolean>;
+    sha256Hash: (data: Uint8Array) => Promise<Uint8Array>;
+}
+export interface ICrypto extends IHostCrypto {
+    gen256BitSecureRandomSeed: () => Promise<Uint8Array>;
+    deriveXSalsa20Poly1305Key: (seed: Uint8Array, derivationIndex: number) => Promise<Uint8Array>;
+    encryptXSalsa20Poly1305Combined: (plaintext: Uint8Array, key: Uint8Array) => Promise<Uint8Array>;
+    decryptXSalsa20Poly1305Combined: (headerAndCipher: Uint8Array, key: Uint8Array) => Promise<Uint8Array>;
+    deriveEd25519KeyPair: (seed: Uint8Array, hostID: string, derivationIndex: number) => Promise<KeyPair>;
+    signEd25519: (message: Uint8Array | string, secKey: Uint8Array) => Promise<Uint8Array>;
+}
+export interface IMsgpackCodec {
+    encode: (source: unknown) => Uint8Array;
+    decode: (packed: ArrayBuffer | Uint8Array) => unknown;
+    decodeAsync: (stream: ReadableStream<Uint8Array>) => Promise<unknown>;
+}
+export {};

package/dist/state.d.ts

@@ -0,0 +1,12 @@
+import { EventEmitter } from "./eventEmitter";
+import type { Applier } from "./types";
+import type { IOp } from "./shared/types";
+export declare class StateManager {
+    emitter: EventEmitter;
+    applier: Applier;
+    constructor(applier: Applier);
+    apply: (op: IOp) => Promise<void>;
+    on: (opType: string, listener: () => void) => void;
+    off: (opType: string, listener: () => void) => void;
+}
+export declare function useStateWatcher<T>(mgr: StateManager, opType: string, callback: () => T): T;

package/dist/sync.d.ts

@@ -0,0 +1,2 @@
+import type DiplomaticClient from "./client";
+export declare function usePollingSync(client: DiplomaticClient, intervalMillis: number): void;

package/dist/types.d.ts

@@ -0,0 +1,18 @@
+import type { IOp } from "./shared/types";
+export interface IClientStateStore {
+    init?: () => Promise<void>;
+    getSeed: () => Promise<Uint8Array | undefined>;
+    setSeed: (seed: Uint8Array) => Promise<void>;
+    getHostURL: () => Promise<string | undefined>;
+    setHostURL: (url: string) => Promise<void>;
+    getHostID: () => Promise<string | undefined>;
+    setHostID: (id: string) => Promise<void>;
+    enqueueUpload: (sha256: Uint8Array, cipherOp: Uint8Array) => Promise<void>;
+    dequeueUpload: (sha256: Uint8Array) => Promise<void>;
+    peekUpload: (sha256: Uint8Array) => Promise<Uint8Array | undefined>;
+    listUploadQueue: () => Promise<string[]>;
+    enqueueDownload: (path: string) => Promise<void>;
+    dequeueDownload: (path: string) => Promise<void>;
+}
+export type DiplomaticClientState = "loading" | "seedless" | "hostless" | "ready";
+export type Applier = (op: IOp) => Promise<void>;

package/dist/useClient.d.ts

@@ -0,0 +1,8 @@
+import DiplomaticClient, { type IDiplomaticClientParams } from "./client";
+import type { DiplomaticClientState, IClientStateStore } from "./types";
+interface IClientHookParams extends Omit<IDiplomaticClientParams, "store"> {
+    refreshInterval?: number;
+    store?: IClientStateStore;
+}
+export default function useClient(params: IClientHookParams): [DiplomaticClient, DiplomaticClientState, () => void];
+export {};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@interncom/diplomatic",
+  "version": "0.0.0",
+  "type": "module",
+  "description": "Secure sync layer",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "tsc": "tsc",
+    "build": "node esbuild.mjs"
+  },
+  "author": "The Internet Committee",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.3",
+    "react": "^18.3.1",
+    "esbuild": "0.21.5",
+    "typescript": "^5.5.2"
+  },
+  "peerDependencies": {
+    "react": "^18.3.1"
+  },
+  "dependencies": {
+    "@msgpack/msgpack": "^3.0.0-beta2"
+  }
+}