@push.rocks/containerarchive 0.0.2

package/dist_ts/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@push.rocks/containerarchive',
+    version: '0.0.2',
+    description: 'content-addressed incremental backup engine with deduplication, encryption, and error correction'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSw4QkFBOEI7SUFDcEMsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLGtHQUFrRztDQUNoSCxDQUFBIn0=

package/dist_ts/classes.containerarchive.d.ts

@@ -0,0 +1,87 @@
+import * as plugins from './plugins.js';
+import type { IInitOptions, IOpenOptions, IIngestOptions, IIngestItem, IRestoreOptions, ISnapshot, ISnapshotFilter, IVerifyOptions, IVerifyResult, IRetentionPolicy, IPruneResult, IRepairResult, IUnlockOptions, IIngestProgress, IIngestComplete, IVerifyError } from './interfaces.js';
+/**
+ * Content-addressed incremental backup engine.
+ *
+ * Provides deduplicated, optionally encrypted, gzip-compressed storage
+ * for arbitrary data streams with full snapshot history.
+ */
+export declare class ContainerArchive {
+    private bridge;
+    private repoPath;
+    private spawned;
+    ingestProgress: plugins.smartrx.rxjs.Subject<IIngestProgress>;
+    ingestComplete: plugins.smartrx.rxjs.Subject<IIngestComplete>;
+    verifyError: plugins.smartrx.rxjs.Subject<IVerifyError>;
+    private constructor();
+    private ensureSpawned;
+    /**
+     * Initialize a new repository at the given path.
+     */
+    static init(repoPath: string, options?: IInitOptions): Promise<ContainerArchive>;
+    /**
+     * Open an existing repository at the given path.
+     */
+    static open(repoPath: string, options?: IOpenOptions): Promise<ContainerArchive>;
+    /**
+     * Ingest a single data stream into the repository.
+     */
+    ingest(inputStream: NodeJS.ReadableStream, options?: IIngestOptions): Promise<ISnapshot>;
+    /**
+     * Ingest multiple data streams as a single multi-item snapshot.
+     * Each item gets its own Unix socket for parallel data transfer.
+     */
+    ingestMulti(items: IIngestItem[], options?: IIngestOptions): Promise<ISnapshot>;
+    /**
+     * List snapshots with optional filtering.
+     */
+    listSnapshots(filter?: ISnapshotFilter): Promise<ISnapshot[]>;
+    /**
+     * Get details of a specific snapshot.
+     */
+    getSnapshot(snapshotId: string): Promise<ISnapshot>;
+    /**
+     * Restore a snapshot to a ReadableStream.
+     */
+    restore(snapshotId: string, options?: IRestoreOptions): Promise<NodeJS.ReadableStream>;
+    /**
+     * Verify repository integrity.
+     */
+    verify(options?: IVerifyOptions): Promise<IVerifyResult>;
+    /**
+     * Repair repository (rebuild index, remove stale locks).
+     */
+    repair(): Promise<IRepairResult>;
+    /**
+     * Prune old snapshots and garbage-collect unreferenced packs.
+     */
+    prune(retention: IRetentionPolicy, dryRun?: boolean): Promise<IPruneResult>;
+    /**
+     * Rebuild the global index from pack .idx files.
+     */
+    reindex(): Promise<void>;
+    /**
+     * Remove locks from the repository.
+     */
+    unlock(options?: IUnlockOptions): Promise<void>;
+    /**
+     * Subscribe to events.
+     */
+    on(event: 'ingest:progress', handler: (data: IIngestProgress) => void): plugins.smartrx.rxjs.Subscription;
+    on(event: 'ingest:complete', handler: (data: IIngestComplete) => void): plugins.smartrx.rxjs.Subscription;
+    on(event: 'verify:error', handler: (data: IVerifyError) => void): plugins.smartrx.rxjs.Subscription;
+    /**
+     * Close the repository and terminate the Rust process.
+     */
+    close(): Promise<void>;
+    /**
+     * Create a Unix socket server that accepts a connection from Rust
+     * and pipes the inputStream to it (for ingest).
+     */
+    private createSocketServer;
+    /**
+     * Create a Unix socket server that accepts a connection from Rust
+     * and provides a ReadableStream of the received data (for restore).
+     */
+    private createRestoreSocketServer;
+}

package/dist_ts/classes.containerarchive.js

@@ -0,0 +1,305 @@
+import * as plugins from './plugins.js';
+import { commitinfo } from './00_commitinfo_data.js';
+/**
+ * Content-addressed incremental backup engine.
+ *
+ * Provides deduplicated, optionally encrypted, gzip-compressed storage
+ * for arbitrary data streams with full snapshot history.
+ */
+export class ContainerArchive {
+    constructor(repoPath) {
+        this.spawned = false;
+        // Event subjects
+        this.ingestProgress = new plugins.smartrx.rxjs.Subject();
+        this.ingestComplete = new plugins.smartrx.rxjs.Subject();
+        this.verifyError = new plugins.smartrx.rxjs.Subject();
+        this.repoPath = plugins.path.resolve(repoPath);
+        const packageDir = plugins.path.resolve(plugins.path.dirname(new URL(import.meta.url).pathname), '..');
+        this.bridge = new plugins.smartrust.RustBridge({
+            binaryName: 'containerarchive',
+            localPaths: [
+                plugins.path.join(packageDir, 'dist_rust', 'containerarchive'),
+            ],
+            readyTimeoutMs: 30000,
+            requestTimeoutMs: 300000,
+        });
+        // Listen for events from the Rust binary
+        this.bridge.on('event', (event) => {
+            if (event.event === 'progress') {
+                this.ingestProgress.next(event.data);
+            }
+        });
+    }
+    async ensureSpawned() {
+        if (!this.spawned) {
+            await this.bridge.spawn();
+            this.spawned = true;
+        }
+    }
+    /**
+     * Initialize a new repository at the given path.
+     */
+    static async init(repoPath, options) {
+        const instance = new ContainerArchive(repoPath);
+        await instance.ensureSpawned();
+        await instance.bridge.sendCommand('init', {
+            path: instance.repoPath,
+            passphrase: options?.passphrase,
+        });
+        return instance;
+    }
+    /**
+     * Open an existing repository at the given path.
+     */
+    static async open(repoPath, options) {
+        const instance = new ContainerArchive(repoPath);
+        await instance.ensureSpawned();
+        await instance.bridge.sendCommand('open', {
+            path: instance.repoPath,
+            passphrase: options?.passphrase,
+        });
+        return instance;
+    }
+    /**
+     * Ingest a single data stream into the repository.
+     */
+    async ingest(inputStream, options) {
+        const socketPath = plugins.path.join(plugins.os.tmpdir(), `containerarchive-ingest-${Date.now()}-${Math.random().toString(36).slice(2)}.sock`);
+        // Create Unix socket server that Rust will connect to
+        const { promise: dataTransferred, server } = await this.createSocketServer(socketPath, inputStream);
+        try {
+            // Send ingest command to Rust (Rust connects to our socket)
+            const result = await this.bridge.sendCommand('ingest', {
+                socketPath,
+                tags: options?.tags,
+                items: options?.items || [{ name: 'data', type: 'data' }],
+            });
+            // Wait for data transfer to complete
+            await dataTransferred;
+            const snapshot = result.snapshot;
+            this.ingestComplete.next({
+                snapshotId: snapshot.id,
+                originalSize: snapshot.originalSize,
+                storedSize: snapshot.storedSize,
+                newChunks: snapshot.newChunks,
+                reusedChunks: snapshot.reusedChunks,
+            });
+            return snapshot;
+        }
+        finally {
+            server.close();
+            // Clean up socket file
+            try {
+                plugins.fs.unlinkSync(socketPath);
+            }
+            catch { }
+        }
+    }
+    /**
+     * Ingest multiple data streams as a single multi-item snapshot.
+     * Each item gets its own Unix socket for parallel data transfer.
+     */
+    async ingestMulti(items, options) {
+        if (items.length === 0) {
+            throw new Error('At least one item is required');
+        }
+        // Create one socket per item
+        const sockets = [];
+        const itemOptions = [];
+        try {
+            for (const item of items) {
+                const socketPath = plugins.path.join(plugins.os.tmpdir(), `containerarchive-ingest-${Date.now()}-${Math.random().toString(36).slice(2)}.sock`);
+                const { promise, server } = await this.createSocketServer(socketPath, item.stream);
+                sockets.push({ socketPath, promise, server });
+                itemOptions.push({
+                    name: item.name,
+                    type: item.type || 'data',
+                    socketPath,
+                });
+            }
+            // Send ingestMulti command to Rust with per-item socket paths
+            const result = await this.bridge.sendCommand('ingestMulti', {
+                tags: options?.tags,
+                items: itemOptions,
+            });
+            // Wait for all data transfers
+            await Promise.all(sockets.map((s) => s.promise));
+            const snapshot = result.snapshot;
+            this.ingestComplete.next({
+                snapshotId: snapshot.id,
+                originalSize: snapshot.originalSize,
+                storedSize: snapshot.storedSize,
+                newChunks: snapshot.newChunks,
+                reusedChunks: snapshot.reusedChunks,
+            });
+            return snapshot;
+        }
+        finally {
+            for (const s of sockets) {
+                s.server.close();
+                try {
+                    plugins.fs.unlinkSync(s.socketPath);
+                }
+                catch { }
+            }
+        }
+    }
+    /**
+     * List snapshots with optional filtering.
+     */
+    async listSnapshots(filter) {
+        const result = await this.bridge.sendCommand('listSnapshots', {
+            filter,
+        });
+        return result.snapshots;
+    }
+    /**
+     * Get details of a specific snapshot.
+     */
+    async getSnapshot(snapshotId) {
+        const result = await this.bridge.sendCommand('getSnapshot', {
+            snapshotId,
+        });
+        return result.snapshot;
+    }
+    /**
+     * Restore a snapshot to a ReadableStream.
+     */
+    async restore(snapshotId, options) {
+        const socketPath = plugins.path.join(plugins.os.tmpdir(), `containerarchive-restore-${Date.now()}-${Math.random().toString(36).slice(2)}.sock`);
+        // Create Unix socket server that Rust will connect to and write data
+        const { readable, server } = await this.createRestoreSocketServer(socketPath);
+        // Send restore command to Rust (Rust connects and writes data)
+        // Don't await — let it run in parallel with reading
+        this.bridge.sendCommand('restore', {
+            snapshotId,
+            socketPath,
+            item: options?.item,
+        }).catch((err) => {
+            readable.destroy(err);
+        }).finally(() => {
+            server.close();
+            try {
+                plugins.fs.unlinkSync(socketPath);
+            }
+            catch { }
+        });
+        return readable;
+    }
+    /**
+     * Verify repository integrity.
+     */
+    async verify(options) {
+        const result = await this.bridge.sendCommand('verify', {
+            level: options?.level || 'standard',
+        });
+        for (const error of result.errors) {
+            this.verifyError.next(error);
+        }
+        return result;
+    }
+    /**
+     * Repair repository (rebuild index, remove stale locks).
+     */
+    async repair() {
+        return this.bridge.sendCommand('repair', {});
+    }
+    /**
+     * Prune old snapshots and garbage-collect unreferenced packs.
+     */
+    async prune(retention, dryRun = false) {
+        return this.bridge.sendCommand('prune', {
+            retention,
+            dryRun,
+        });
+    }
+    /**
+     * Rebuild the global index from pack .idx files.
+     */
+    async reindex() {
+        await this.bridge.sendCommand('reindex', {});
+    }
+    /**
+     * Remove locks from the repository.
+     */
+    async unlock(options) {
+        await this.bridge.sendCommand('unlock', {
+            force: options?.force,
+        });
+    }
+    on(event, handler) {
+        switch (event) {
+            case 'ingest:progress':
+                return this.ingestProgress.subscribe(handler);
+            case 'ingest:complete':
+                return this.ingestComplete.subscribe(handler);
+            case 'verify:error':
+                return this.verifyError.subscribe(handler);
+            default:
+                throw new Error(`Unknown event: ${event}`);
+        }
+    }
+    /**
+     * Close the repository and terminate the Rust process.
+     */
+    async close() {
+        try {
+            await this.bridge.sendCommand('close', {});
+        }
+        catch {
+            // Ignore errors during close
+        }
+        this.bridge.kill();
+        this.spawned = false;
+        this.ingestProgress.complete();
+        this.ingestComplete.complete();
+        this.verifyError.complete();
+    }
+    // ==================== Private Helpers ====================
+    /**
+     * Create a Unix socket server that accepts a connection from Rust
+     * and pipes the inputStream to it (for ingest).
+     */
+    createSocketServer(socketPath, inputStream) {
+        return new Promise((resolve, reject) => {
+            const server = plugins.net.createServer((socket) => {
+                // Pipe input data to the Rust process via socket
+                const readableStream = inputStream;
+                readableStream.pipe(socket);
+            });
+            server.on('error', reject);
+            server.listen(socketPath, () => {
+                const promise = new Promise((res) => {
+                    server.on('close', () => res());
+                    // Also resolve after a connection is handled
+                    server.once('connection', (socket) => {
+                        socket.on('end', () => {
+                            res();
+                        });
+                        socket.on('error', () => {
+                            res();
+                        });
+                    });
+                });
+                resolve({ promise, server });
+            });
+        });
+    }
+    /**
+     * Create a Unix socket server that accepts a connection from Rust
+     * and provides a ReadableStream of the received data (for restore).
+     */
+    createRestoreSocketServer(socketPath) {
+        return new Promise((resolve, reject) => {
+            const passthrough = new plugins.stream.PassThrough();
+            const server = plugins.net.createServer((socket) => {
+                socket.pipe(passthrough);
+            });
+            server.on('error', reject);
+            server.listen(socketPath, () => {
+                resolve({ readable: passthrough, server });
+            });
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.containerarchive.js","sourceRoot":"","sources":["../ts/classes.containerarchive.ts"],"names":[],"mappings":"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"}

package/dist_ts/index.d.ts

@@ -0,0 +1,2 @@
+export * from './classes.containerarchive.js';
+export * from './interfaces.js';

package/dist_ts/index.js

@@ -0,0 +1,3 @@
+export * from './classes.containerarchive.js';
+export * from './interfaces.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsaUJBQWlCLENBQUMifQ==

package/dist_ts/interfaces.d.ts

@@ -0,0 +1,184 @@
+import type { ICommandDefinition } from '@push.rocks/smartrust';
+export interface IRepositoryConfig {
+    version: number;
+    id: string;
+    createdAt: string;
+    chunking: IChunkingConfig;
+    compression: string;
+    encryption?: IEncryptionConfig;
+    packTargetSize: number;
+}
+export interface IChunkingConfig {
+    algorithm: string;
+    minSize: number;
+    avgSize: number;
+    maxSize: number;
+}
+export interface IEncryptionConfig {
+    algorithm: string;
+    kdf: string;
+    kdfParams: IKdfParams;
+}
+export interface IKdfParams {
+    memory: number;
+    iterations: number;
+    parallelism: number;
+}
+export interface ISnapshot {
+    id: string;
+    version: number;
+    createdAt: string;
+    tags: Record<string, string>;
+    originalSize: number;
+    storedSize: number;
+    chunkCount: number;
+    newChunks: number;
+    reusedChunks: number;
+    items: ISnapshotItem[];
+}
+export interface ISnapshotItem {
+    name: string;
+    type: string;
+    size: number;
+    chunks: string[];
+}
+export interface ISnapshotFilter {
+    tags?: Record<string, string>;
+    after?: string;
+    before?: string;
+}
+export interface IInitOptions {
+    passphrase?: string;
+    chunking?: Partial<IChunkingConfig>;
+    packTargetSize?: number;
+}
+export interface IOpenOptions {
+    passphrase?: string;
+}
+export interface IIngestOptions {
+    tags?: Record<string, string>;
+    items?: IIngestItemOptions[];
+}
+export interface IIngestItemOptions {
+    name: string;
+    type?: string;
+}
+export interface IIngestItem {
+    stream: NodeJS.ReadableStream;
+    name: string;
+    type?: string;
+}
+export interface IRestoreOptions {
+    item?: string;
+}
+export interface IVerifyOptions {
+    level?: 'quick' | 'standard' | 'full';
+}
+export interface IVerifyResult {
+    ok: boolean;
+    errors: IVerifyError[];
+    stats: {
+        packsChecked: number;
+        chunksChecked: number;
+        snapshotsChecked: number;
+    };
+}
+export interface IVerifyError {
+    pack?: string;
+    chunk?: string;
+    snapshot?: string;
+    error: string;
+}
+export interface IRetentionPolicy {
+    keepLast?: number;
+    keepDays?: number;
+    keepWeeks?: number;
+    keepMonths?: number;
+}
+export interface IPruneResult {
+    removedSnapshots: number;
+    removedPacks: number;
+    freedBytes: number;
+    dryRun: boolean;
+}
+export interface IRepairResult {
+    indexRebuilt: boolean;
+    indexedChunks: number;
+    staleLocksRemoved: number;
+    packsRepaired: number;
+    errors: string[];
+}
+export interface IUnlockOptions {
+    force?: boolean;
+}
+export interface IIngestProgress {
+    operation: string;
+    percentage: number;
+    message: string;
+}
+export interface IIngestComplete {
+    snapshotId: string;
+    originalSize: number;
+    storedSize: number;
+    newChunks: number;
+    reusedChunks: number;
+}
+export type TContainerArchiveCommands = {
+    init: ICommandDefinition<{
+        path: string;
+        passphrase?: string;
+    }, IRepositoryConfig>;
+    open: ICommandDefinition<{
+        path: string;
+        passphrase?: string;
+    }, IRepositoryConfig>;
+    close: ICommandDefinition<Record<string, never>, Record<string, never>>;
+    ingest: ICommandDefinition<{
+        socketPath: string;
+        tags?: Record<string, string>;
+        items?: IIngestItemOptions[];
+    }, {
+        snapshot: ISnapshot;
+    }>;
+    ingestMulti: ICommandDefinition<{
+        tags?: Record<string, string>;
+        items: Array<{
+            name: string;
+            type: string;
+            socketPath: string;
+        }>;
+    }, {
+        snapshot: ISnapshot;
+    }>;
+    restore: ICommandDefinition<{
+        snapshotId: string;
+        socketPath: string;
+        item?: string;
+    }, Record<string, never>>;
+    listSnapshots: ICommandDefinition<{
+        filter?: ISnapshotFilter;
+    }, {
+        snapshots: ISnapshot[];
+    }>;
+    getSnapshot: ICommandDefinition<{
+        snapshotId: string;
+    }, {
+        snapshot: ISnapshot;
+    }>;
+    verify: ICommandDefinition<{
+        level: string;
+    }, IVerifyResult>;
+    repair: ICommandDefinition<Record<string, never>, IRepairResult>;
+    prune: ICommandDefinition<{
+        retention: IRetentionPolicy;
+        dryRun?: boolean;
+    }, IPruneResult>;
+    reindex: ICommandDefinition<Record<string, never>, {
+        indexedChunks: number;
+    }>;
+    unlock: ICommandDefinition<{
+        force?: boolean;
+    }, {
+        removedLocks: number;
+    }>;
+};

package/dist_ts/interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist_ts/plugins.d.ts

@@ -0,0 +1,12 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import * as net from 'node:net';
+import * as os from 'node:os';
+import * as stream from 'node:stream';
+import * as crypto from 'node:crypto';
+export { path, fs, net, os, stream, crypto };
+import * as smartrust from '@push.rocks/smartrust';
+import * as smartrx from '@push.rocks/smartrx';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as lik from '@push.rocks/lik';
+export { smartrust, smartrx, smartpromise, lik };

package/dist_ts/plugins.js

@@ -0,0 +1,15 @@
+// node native scope
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import * as net from 'node:net';
+import * as os from 'node:os';
+import * as stream from 'node:stream';
+import * as crypto from 'node:crypto';
+export { path, fs, net, os, stream, crypto };
+// @push.rocks scope
+import * as smartrust from '@push.rocks/smartrust';
+import * as smartrx from '@push.rocks/smartrx';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as lik from '@push.rocks/lik';
+export { smartrust, smartrx, smartpromise, lik };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBQ2xDLE9BQU8sS0FBSyxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQzlCLE9BQU8sS0FBSyxHQUFHLE1BQU0sVUFBVSxDQUFDO0FBQ2hDLE9BQU8sS0FBSyxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQzlCLE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBQ3RDLE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBRXRDLE9BQU8sRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFLEdBQUcsRUFBRSxFQUFFLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxDQUFDO0FBRTdDLG9CQUFvQjtBQUNwQixPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUFDL0MsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssR0FBRyxNQUFNLGlCQUFpQixDQUFDO0FBRXZDLE9BQU8sRUFBRSxTQUFTLEVBQUUsT0FBTyxFQUFFLFlBQVksRUFBRSxHQUFHLEVBQUUsQ0FBQyJ9