swarm-deploy 0.0.0 → 0.1.0

package/dist/identity.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSeed = parseSeed;
+exports.parsePublicKey = parsePublicKey;
+exports.generateSeed = generateSeed;
+exports.keyPairFromSeed = keyPairFromSeed;
+exports.publicKeyFromSeed = publicKeyFromSeed;
+const b4a_1 = __importDefault(require("b4a"));
+const sodium_native_1 = __importDefault(require("sodium-native"));
+const errors_js_1 = require("./errors.js");
+const CANONICAL_HEX64 = /^[0-9a-f]{64}$/;
+function parseCanonicalHex(value, code) {
+    if (typeof value !== 'string' || !CANONICAL_HEX64.test(value)) {
+        throw new errors_js_1.SwarmDeployError(code, `Expected lowercase 64-character hex string`);
+    }
+    return b4a_1.default.from(value, 'hex');
+}
+function parseSeed(value) {
+    return parseCanonicalHex(value, errors_js_1.ERRORS.INVALID_SEED);
+}
+function parsePublicKey(value) {
+    return parseCanonicalHex(value, errors_js_1.ERRORS.INVALID_PUBLIC_KEY);
+}
+function generateSeed() {
+    const seed = b4a_1.default.allocUnsafe(32);
+    sodium_native_1.default.randombytes_buf(seed);
+    return seed;
+}
+function normalizeSeed(seed) {
+    if (typeof seed === 'string')
+        return parseSeed(seed);
+    if (!b4a_1.default.isBuffer(seed) || seed.byteLength !== 32) {
+        throw new errors_js_1.SwarmDeployError(errors_js_1.ERRORS.INVALID_SEED, 'Expected 32-byte seed');
+    }
+    return b4a_1.default.from(seed);
+}
+function keyPairFromSeed(seed) {
+    const normalized = normalizeSeed(seed);
+    const publicKey = b4a_1.default.alloc(32);
+    const secretKey = b4a_1.default.alloc(64);
+    sodium_native_1.default.crypto_sign_seed_keypair(publicKey, secretKey, normalized);
+    return { publicKey, secretKey };
+}
+function publicKeyFromSeed(seed) {
+    return keyPairFromSeed(seed).publicKey;
+}
+//# sourceMappingURL=identity.js.map

package/dist/identity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.js","sourceRoot":"","sources":["../src/identity.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,8CAAqB;AACrB,kEAAkC;AAClC,2CAAsD;AAKtD,MAAM,eAAe,GAAG,gBAAgB,CAAA;AAExC,SAAS,iBAAiB,CACxB,KAAa,EACb,IAAmE;IAEnE,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9D,MAAM,IAAI,4BAAgB,CAAC,IAAI,EAAE,4CAA4C,CAAC,CAAA;IAChF,CAAC;IACD,OAAO,aAAG,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;AAC/B,CAAC;AAED,mBAA0B,KAAa;IACrC,OAAO,iBAAiB,CAAC,KAAK,EAAE,kBAAM,CAAC,YAAY,CAAC,CAAA;AACtD,CAAC;AAED,wBAA+B,KAAa;IAC1C,OAAO,iBAAiB,CAAC,KAAK,EAAE,kBAAM,CAAC,kBAAkB,CAAC,CAAA;AAC5D,CAAC;AAED;IACE,MAAM,IAAI,GAAG,aAAG,CAAC,WAAW,CAAC,EAAE,CAAC,CAAA;IAChC,uBAAM,CAAC,eAAe,CAAC,IAAI,CAAC,CAAA;IAC5B,OAAO,IAAI,CAAA;AACb,CAAC;AAED,SAAS,aAAa,CAAC,IAAe;IACpC,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAC,IAAI,CAAC,CAAA;IACpD,IAAI,CAAC,aAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,UAAU,KAAK,EAAE,EAAE,CAAC;QAClD,MAAM,IAAI,4BAAgB,CAAC,kBAAM,CAAC,YAAY,EAAE,uBAAuB,CAAC,CAAA;IAC1E,CAAC;IACD,OAAO,aAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AACvB,CAAC;AAED,yBAAgC,IAAe;IAC7C,MAAM,UAAU,GAAG,aAAa,CAAC,IAAI,CAAC,CAAA;IACtC,MAAM,SAAS,GAAG,aAAG,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;IAC/B,MAAM,SAAS,GAAG,aAAG,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;IAC/B,uBAAM,CAAC,wBAAwB,CAAC,SAAS,EAAE,SAAS,EAAE,UAAU,CAAC,CAAA;IACjE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,CAAA;AACjC,CAAC;AAED,2BAAkC,IAAe;IAC/C,OAAO,eAAe,CAAC,IAAI,CAAC,CAAC,SAAS,CAAA;AACxC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { ERRORS, SwarmDeployError, type ErrorCode } from './errors.js';
+export type { Binary, BinaryInput, Digest, FingerprintEvent, KeyPair, Logger, PublicKey, PublicKeyInput, Seed, SeedInput, ServerScheduler } from './types.js';
+export { parseSeed, parsePublicKey, generateSeed, keyPairFromSeed, publicKeyFromSeed } from './identity.js';
+export { parseAllowlist } from './allowlist.js';
+export type { SkippedUploadReason } from './files.js';
+export { Server, type AllowlistKey, type RecoveryEvent, type RetentionEvent, type ServerCloseEvent, type ServerConnectionEvent, type ServerEvent, type ServerEventName, type ServerEventMap, type ServerListeningEvent, type ServerOfferEvent, type ServerOptions, type ServerProgressEvent, type ServerTransferLifecycleEvent } from './server.js';
+export { Client, type BatchUploadFailure, type BatchUploadResult, type ClientEvent, type ClientEventMap, type ClientEventName, type ClientOfferEvent, type ClientOptions, type ClientProgressEvent, type ClientResultEvent, type ClientUploadResult, type SkippedUploadEntry, type UploadResult, type UploadStatus } from './client.js';
+export type { StorageAdapter, StorageFileHandle, StorageMkdirOptions, StorageReadResult, StorageRmOptions, StorageStatFs, StorageStats, StorageWriteResult } from './storage/types.js';

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = exports.Server = exports.parseAllowlist = exports.publicKeyFromSeed = exports.keyPairFromSeed = exports.generateSeed = exports.parsePublicKey = exports.parseSeed = exports.SwarmDeployError = exports.ERRORS = void 0;
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "ERRORS", { enumerable: true, get: function () { return errors_js_1.ERRORS; } });
+Object.defineProperty(exports, "SwarmDeployError", { enumerable: true, get: function () { return errors_js_1.SwarmDeployError; } });
+var identity_js_1 = require("./identity.js");
+Object.defineProperty(exports, "parseSeed", { enumerable: true, get: function () { return identity_js_1.parseSeed; } });
+Object.defineProperty(exports, "parsePublicKey", { enumerable: true, get: function () { return identity_js_1.parsePublicKey; } });
+Object.defineProperty(exports, "generateSeed", { enumerable: true, get: function () { return identity_js_1.generateSeed; } });
+Object.defineProperty(exports, "keyPairFromSeed", { enumerable: true, get: function () { return identity_js_1.keyPairFromSeed; } });
+Object.defineProperty(exports, "publicKeyFromSeed", { enumerable: true, get: function () { return identity_js_1.publicKeyFromSeed; } });
+var allowlist_js_1 = require("./allowlist.js");
+Object.defineProperty(exports, "parseAllowlist", { enumerable: true, get: function () { return allowlist_js_1.parseAllowlist; } });
+var server_js_1 = require("./server.js");
+Object.defineProperty(exports, "Server", { enumerable: true, get: function () { return server_js_1.Server; } });
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_js_1.Client; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,yCAAsE;AAA7D,mGAAA,MAAM,OAAA;AAAE,6GAAA,gBAAgB,OAAA;AAcjC,6CAMsB;AALpB,wGAAA,SAAS,OAAA;AACT,6GAAA,cAAc,OAAA;AACd,2GAAA,YAAY,OAAA;AACZ,8GAAA,eAAe,OAAA;AACf,gHAAA,iBAAiB,OAAA;AAEnB,+CAA+C;AAAtC,8GAAA,cAAc,OAAA;AAEvB,yCAeoB;AAdlB,mGAAA,MAAM,OAAA;AAeR,yCAeoB;AAdlB,mGAAA,MAAM,OAAA"}

package/dist/os-node.d.ts

@@ -0,0 +1,2 @@
+import os from 'node:os';
+export = os;

package/dist/os-node.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const node_os_1 = __importDefault(require("node:os"));
+module.exports = node_os_1.default;
+//# sourceMappingURL=os-node.js.map

package/dist/os-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"os-node.js","sourceRoot":"","sources":["../src/os-node.ts"],"names":[],"mappings":";;;;AAAA,sDAAwB;AAExB,iBAAS,iBAAE,CAAA"}

package/dist/path-node.d.ts

@@ -0,0 +1,2 @@
+import path from 'node:path';
+export = path;

package/dist/path-node.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const node_path_1 = __importDefault(require("node:path"));
+module.exports = node_path_1.default;
+//# sourceMappingURL=path-node.js.map

package/dist/path-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-node.js","sourceRoot":"","sources":["../src/path-node.ts"],"names":[],"mappings":";;;;AAAA,0DAA4B;AAE5B,iBAAS,mBAAI,CAAA"}

package/dist/process-node.d.ts

@@ -0,0 +1,2 @@
+import process from 'node:process';
+export = process;

package/dist/process-node.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const node_process_1 = __importDefault(require("node:process"));
+module.exports = node_process_1.default;
+//# sourceMappingURL=process-node.js.map

package/dist/process-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-node.js","sourceRoot":"","sources":["../src/process-node.ts"],"names":[],"mappings":";;;;AAAA,gEAAkC;AAElC,iBAAS,sBAAO,CAAA"}

package/dist/server.d.ts

@@ -0,0 +1,153 @@
+import events from '#events';
+import { type DirectDhtFactory, type DirectDhtNode } from './direct-dht.js';
+import { type ErrorCode } from './errors.js';
+import type { StorageAdapter } from './storage/types.js';
+import type { AuthenticationEvent, FingerprintEvent, Logger, PublicKey, PublicKeyInput, SeedInput, ServerScheduler, TransferEvent, TransferLifecycleEvent } from './types.js';
+declare const EventEmitter: typeof events;
+declare const DEFAULT_MAX_CONNECTIONS = 64;
+declare const DEFAULT_MAX_ACTIVE_UPLOADS = 8;
+declare const DEFAULT_MIN_FREE_BYTES: number;
+declare const MAX_CONNECTIONS = 1024;
+declare const MAX_ACTIVE_UPLOADS = 1024;
+declare const FINGERPRINT_LENGTH = 12;
+export type ServerLogger = Logger;
+export type AllowlistKey = PublicKeyInput | string;
+export interface ServerOptions {
+    seed: SeedInput;
+    storageDir: string;
+    allowedKeys: Iterable<AllowlistKey>;
+    maxFileBytes: number;
+    maxStagingBytes: number;
+    maxConnections?: number;
+    maxActiveUploads?: number;
+    idleTimeout?: number;
+    cleanupInterval?: number;
+    resumeTtl?: number;
+    minFreeBytes?: number;
+    maxAge?: number;
+    maxStorageBytes?: number;
+    dht?: DirectDhtNode;
+    dhtFactory?: DirectDhtFactory;
+    storage?: StorageAdapter;
+    scheduler?: ServerScheduler;
+    logger?: Logger | null;
+    replaceNames?: Iterable<string>;
+}
+export interface ServerConnectionEvent extends FingerprintEvent {
+    connections: number;
+}
+export interface ServerListeningEvent {
+    fingerprint: string;
+}
+export interface ServerOfferEvent extends TransferEvent, FingerprintEvent {
+    status: 'accepted' | 'resumed' | 'reset' | 'rejected' | 'already-committed';
+    offset?: number;
+    reason?: ErrorCode;
+}
+export interface ServerProgressEvent extends TransferEvent, FingerprintEvent {
+    bytesReceived: number;
+    totalBytes: number;
+}
+export type ServerTransferLifecycleEvent = TransferLifecycleEvent & FingerprintEvent;
+export interface RecoveryEvent {
+    status: 'started' | 'completed' | 'failed' | 'CORRUPT' | 'COMMITTED' | 'ABORTED' | 'RESUMABLE' | 'MISSING' | 'FILE_EXISTS';
+    transfer?: string;
+    phase?: 'classification' | 'sessions' | 'journal';
+    reason?: string;
+    journals?: number;
+    purgedSessions?: number;
+}
+export interface RetentionEvent {
+    trigger: 'startup' | 'scheduled' | 'manual' | 'commit' | 'post-commit';
+    status: 'completed' | 'deferred' | 'failed';
+    reason?: string;
+    expiredSessions?: number;
+    scrubbed?: number;
+    ageDeleted?: number;
+    storageDeleted?: number;
+}
+export interface ServerCloseEvent {
+    status: 'closed' | 'failed';
+}
+export interface ServerEventMap {
+    authentication: AuthenticationEvent;
+    connection: ServerConnectionEvent;
+    'connection-open': ServerConnectionEvent;
+    'connection-close': ServerConnectionEvent;
+    offer: ServerOfferEvent;
+    progress: ServerProgressEvent;
+    verification: ServerTransferLifecycleEvent;
+    commit: ServerTransferLifecycleEvent;
+    recovery: RecoveryEvent;
+    retention: RetentionEvent;
+    failure: FingerprintEvent & {
+        reason: ErrorCode;
+    };
+    listening: ServerListeningEvent;
+    close: ServerCloseEvent;
+}
+export type ServerEventName = keyof ServerEventMap;
+export type ServerEvent = ServerEventMap[ServerEventName];
+type SafeLogger = Required<Logger>;
+declare function fingerprint(value: Uint8Array): string;
+/** A static-allowlist direct HyperDHT artifact receiver. */
+export interface Server {
+    on<EventName extends ServerEventName>(event: EventName, listener: (event: ServerEventMap[EventName]) => void): this;
+    on(event: string | symbol, listener: (...args: never[]) => void): this;
+}
+export declare class Server extends EventEmitter {
+    readonly publicKey: PublicKey;
+    readonly storageDir: string;
+    readonly maxFileBytes: number;
+    readonly maxStagingBytes: number;
+    readonly maxConnections: number;
+    readonly maxActiveUploads: number;
+    readonly idleTimeout: number;
+    readonly cleanupInterval: number;
+    readonly resumeTtl: number;
+    readonly minFreeBytes: number;
+    readonly maxAge: number | undefined;
+    readonly maxStorageBytes: number | undefined;
+    private readonly allowedKeySnapshot;
+    readonly logger: SafeLogger;
+    readonly dht: DirectDhtNode | undefined;
+    readonly dhtFactory: DirectDhtFactory | undefined;
+    readonly storage: StorageAdapter;
+    readonly scheduler: ServerScheduler;
+    readonly replaceNames: ReadonlySet<string>;
+    listening: boolean;
+    closed: boolean;
+    private readonly keyPair;
+    private readonly signal;
+    private readonly abort;
+    private readonly active;
+    private readonly activeUploads;
+    private readonly receives;
+    private layout;
+    private sessions;
+    private commits;
+    private retention;
+    private transport;
+    private releaseLock;
+    private listenPromise;
+    private closePromise;
+    constructor(options: ServerOptions);
+    private emitSafe;
+    private allowed;
+    private transfer;
+    private receive;
+    /**
+     * Retires a committed session without letting cleanup undo a durable commit.
+     *
+     * The artifact is already published at this point, so a failure to unlink the
+     * session leaves recoverable residue that `init()` purges on the next start.
+     * Propagating it here would abort before the terminal record and tell the
+     * client its upload failed after it had in fact succeeded.
+     */
+    private retireQuietly;
+    private start;
+    listen(): Promise<this>;
+    private dispose;
+    close(): Promise<void>;
+}
+export { DEFAULT_MAX_CONNECTIONS, DEFAULT_MAX_ACTIVE_UPLOADS, DEFAULT_MIN_FREE_BYTES, MAX_CONNECTIONS, MAX_ACTIVE_UPLOADS, FINGERPRINT_LENGTH, fingerprint };