swarm-deploy 0.0.0 → 0.2.0

package/dist/storage/tree-staging.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTreeStagingTarget = createTreeStagingTarget;
+const errors_js_1 = require("../errors.js");
+const tree_fs_js_1 = require("./tree-fs.js");
+/**
+ * Writes an extracted tree into `treePath`, which must live directly under
+ * `parent`. Every path is created exclusively, with no-follow opens, from
+ * validated components only, and every call carries the storage layout so the
+ * protected directories are refused by identity.
+ */
+function createTreeStagingTarget(treePath, parent, storage, layout) {
+    const options = { layout };
+    let created = false;
+    const ensureRoot = async () => {
+        if (created)
+            return;
+        await (0, tree_fs_js_1.createTreeRoot)(treePath, parent, storage, options);
+        created = true;
+    };
+    return {
+        async createDirectory(relativePath) {
+            await ensureRoot();
+            await (0, tree_fs_js_1.createTreeSubdirectory)(treePath, relativePath, storage, options);
+        },
+        async createFile(relativePath) {
+            await ensureRoot();
+            const handle = await (0, tree_fs_js_1.openTreeFile)(treePath, relativePath, storage, options);
+            let position = 0;
+            return {
+                async write(chunk) {
+                    let offset = 0;
+                    while (offset < chunk.byteLength) {
+                        const written = await handle.write(chunk, offset, chunk.byteLength - offset, position + offset);
+                        const count = typeof written === 'number' ? written : written.bytesWritten;
+                        if (!Number.isSafeInteger(count) || count <= 0) {
+                            throw new errors_js_1.SwarmDeployError(errors_js_1.ERRORS.PROTOCOL_INVALID, 'Unable to write staged tree file');
+                        }
+                        offset += count;
+                    }
+                    position += chunk.byteLength;
+                },
+                async close() {
+                    try {
+                        await handle.sync();
+                    }
+                    finally {
+                        await handle.close();
+                    }
+                }
+            };
+        },
+        async complete() {
+            await ensureRoot();
+            await (0, tree_fs_js_1.syncTreeDirectories)(treePath, storage);
+        },
+        async abort() {
+            if (!created)
+                return;
+            await (0, tree_fs_js_1.removeTree)(treePath, parent, storage, options).catch(() => { });
+        }
+    };
+}
+//# sourceMappingURL=tree-staging.js.map

package/dist/storage/tree-staging.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-staging.js","sourceRoot":"","sources":["../../src/storage/tree-staging.ts"],"names":[],"mappings":";;;AAAA,4CAAuD;AAEvD,6CAMqB;AAGrB;;;;;GAKG;AACH,iCACE,QAAgB,EAChB,MAAc,EACd,OAAuB,EACvB,MAAqB;IAErB,MAAM,OAAO,GAAG,EAAE,MAAM,EAAE,CAAA;IAC1B,IAAI,OAAO,GAAG,KAAK,CAAA;IACnB,MAAM,UAAU,GAAG,KAAK,IAAmB,EAAE;QAC3C,IAAI,OAAO;YAAE,OAAM;QACnB,MAAM,IAAA,2BAAc,EAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,CAAA;QACxD,OAAO,GAAG,IAAI,CAAA;IAChB,CAAC,CAAA;IACD,OAAO;QACL,KAAK,CAAC,eAAe,CAAC,YAAoB;YACxC,MAAM,UAAU,EAAE,CAAA;YAClB,MAAM,IAAA,mCAAsB,EAAC,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,CAAC,CAAA;QACxE,CAAC;QACD,KAAK,CAAC,UAAU,CAAC,YAAoB;YACnC,MAAM,UAAU,EAAE,CAAA;YAClB,MAAM,MAAM,GAAG,MAAM,IAAA,yBAAY,EAAC,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,CAAC,CAAA;YAC3E,IAAI,QAAQ,GAAG,CAAC,CAAA;YAChB,OAAO;gBACL,KAAK,CAAC,KAAK,CAAC,KAAiB;oBAC3B,IAAI,MAAM,GAAG,CAAC,CAAA;oBACd,OAAO,MAAM,GAAG,KAAK,CAAC,UAAU,EAAE,CAAC;wBACjC,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,KAAK,CAChC,KAAK,EACL,MAAM,EACN,KAAK,CAAC,UAAU,GAAG,MAAM,EACzB,QAAQ,GAAG,MAAM,CAClB,CAAA;wBACD,MAAM,KAAK,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,YAAY,CAAA;wBAC1E,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;4BAC/C,MAAM,IAAI,4BAAgB,CACxB,kBAAM,CAAC,gBAAgB,EACvB,kCAAkC,CACnC,CAAA;wBACH,CAAC;wBACD,MAAM,IAAI,KAAK,CAAA;oBACjB,CAAC;oBACD,QAAQ,IAAI,KAAK,CAAC,UAAU,CAAA;gBAC9B,CAAC;gBACD,KAAK,CAAC,KAAK;oBACT,IAAI,CAAC;wBACH,MAAM,MAAM,CAAC,IAAI,EAAE,CAAA;oBACrB,CAAC;4BAAS,CAAC;wBACT,MAAM,MAAM,CAAC,KAAK,EAAE,CAAA;oBACtB,CAAC;gBACH,CAAC;aACF,CAAA;QACH,CAAC;QACD,KAAK,CAAC,QAAQ;YACZ,MAAM,UAAU,EAAE,CAAA;YAClB,MAAM,IAAA,gCAAmB,EAAC,QAAQ,EAAE,OAAO,CAAC,CAAA;QAC9C,CAAC;QACD,KAAK,CAAC,KAAK;YACT,IAAI,CAAC,OAAO;gBAAE,OAAM;YACpB,MAAM,IAAA,uBAAU,EAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAA;QACtE,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/storage/types.d.ts

@@ -0,0 +1,77 @@
+export interface StorageStats {
+    dev: number | bigint;
+    ino: number | bigint;
+    size: number;
+    /** Hard-link count; tree primitives reject any file reporting more than one. */
+    nlink?: number;
+    /** Modification time, compared across hashing when the adapter reports it. */
+    mtimeMs?: number;
+    isSymbolicLink(): boolean;
+    isDirectory(): boolean;
+    isFile(): boolean;
+}
+/** Historical internal alias for {@link StorageStats}. */
+export type StorageStat = StorageStats;
+export interface StorageReadResult {
+    bytesRead: number;
+}
+export interface StorageWriteResult {
+    bytesWritten: number;
+}
+export interface StorageMkdirOptions {
+    mode?: number;
+}
+export interface StorageRmOptions {
+    recursive: boolean;
+    force: boolean;
+}
+export interface StorageStatFs {
+    bavail: number | bigint;
+    bsize: number | bigint;
+}
+export interface StorageFileHandle {
+    stat(): Promise<StorageStats>;
+    write(bytes: Uint8Array, offset: number, length: number, position: number | null): Promise<number | StorageWriteResult>;
+    read(bytes: Uint8Array, offset: number, length: number, position: number | null): Promise<number | StorageReadResult>;
+    sync(): Promise<void>;
+    close(): Promise<void>;
+}
+export interface StorageAdapter {
+    readFile(path: string, encoding: 'utf8'): Promise<string | Uint8Array>;
+    lstat(path: string): Promise<StorageStats>;
+    open(path: string, flags: string | number, mode?: number): Promise<StorageFileHandle>;
+    mkdir(path: string, options?: StorageMkdirOptions): Promise<void>;
+    rm(path: string, options?: Partial<StorageRmOptions>): Promise<void>;
+    rename(source: string, destination: string): Promise<void>;
+    link(existingPath: string, newPath: string): Promise<void>;
+    unlink(path: string): Promise<void>;
+    rmdir(path: string): Promise<void>;
+    readdir(path: string): Promise<string[]>;
+    statfs?(path: string): Promise<StorageStatFs>;
+    /** Required only when symlink rules are configured. */
+    symlink?(target: string, path: string): Promise<void>;
+    readlink?(path: string): Promise<string>;
+}
+export type SymlinkCapableStorage = StorageAdapter & {
+    symlink(target: string, path: string): Promise<void>;
+    readlink(path: string): Promise<string>;
+};
+export interface StorageLayout {
+    root: string;
+    internal: string;
+    staging: string;
+    sessions: string;
+    commits: string;
+    journals: string;
+    /** Private destinations for replacement publications before they are visible. */
+    publications: string;
+    /** Private managed-symlink ownership records. */
+    links: string;
+    /** Private destination a managed directory is renamed into before deletion. */
+    trash: string;
+    lock: string;
+}
+export interface StorageIdentity {
+    dev: number | bigint;
+    ino: number | bigint;
+}

package/dist/storage/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/storage/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/storage/types.ts"],"names":[],"mappings":""}

package/dist/symlinks.d.ts

@@ -0,0 +1,36 @@
+import { type CommitRecord } from './storage/commit-journal.js';
+import type { ArtifactKind } from './types.js';
+export declare const MAX_SYMLINK_SELECTOR_BYTES = 200;
+export interface SymlinkRule {
+    /** An exact managed artifact basename, or `/pattern/` with no flags. */
+    selector: string;
+    /** The safe basename of the managed link, a sibling of its target. */
+    name: string;
+}
+export interface CompiledSymlinkRule {
+    readonly selector: string;
+    readonly name: string;
+    /** The exact target basename, or `null` for a regular-expression selector. */
+    readonly exact: string | null;
+    matches(name: string): boolean;
+}
+export interface DesiredLink {
+    name: string;
+    /** Always exactly the selected record's basename. */
+    target: string;
+    transferId: string;
+    targetKind: ArtifactKind;
+}
+/**
+ * Validates and snapshots operator symlink rules. The regex source is bounded,
+ * has no flags, and runs only against validated 100-byte artifact basenames; it
+ * is trusted operator configuration, and an invalid one is a startup error.
+ */
+export declare function compileSymlinkRules(rules: Iterable<SymlinkRule> | null | undefined): readonly CompiledSymlinkRule[];
+export declare function symlinkRuleNames(rules: readonly CompiledSymlinkRule[]): ReadonlySet<string>;
+/**
+ * Computes the desired links from validated commit records only. A rule with no
+ * match is dormant. Replacement history names never match, and a candidate
+ * whose name equals its own link name is skipped.
+ */
+export declare function selectDesiredLinks(rules: readonly CompiledSymlinkRule[], records: readonly CommitRecord[]): DesiredLink[];

package/dist/symlinks.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_SYMLINK_SELECTOR_BYTES = void 0;
+exports.compileSymlinkRules = compileSymlinkRules;
+exports.symlinkRuleNames = symlinkRuleNames;
+exports.selectDesiredLinks = selectDesiredLinks;
+const b4a_1 = __importDefault(require("b4a"));
+const errors_js_1 = require("./errors.js");
+const files_js_1 = require("./files.js");
+const commit_journal_js_1 = require("./storage/commit-journal.js");
+exports.MAX_SYMLINK_SELECTOR_BYTES = 200;
+function invalid(message, cause = null) {
+    return new errors_js_1.SwarmDeployError(errors_js_1.ERRORS.PROTOCOL_INVALID, message, cause);
+}
+function assertLinkName(value) {
+    if (typeof value !== 'string') {
+        throw new errors_js_1.SwarmDeployError(errors_js_1.ERRORS.INVALID_FILENAME, 'Invalid symlink name');
+    }
+    const name = (0, files_js_1.validateBasename)(value);
+    if ((0, files_js_1.isReservedHistoryName)(name)) {
+        throw new errors_js_1.SwarmDeployError(errors_js_1.ERRORS.INVALID_FILENAME, 'Reserved symlink name');
+    }
+    return name;
+}
+/**
+ * Validates and snapshots operator symlink rules. The regex source is bounded,
+ * has no flags, and runs only against validated 100-byte artifact basenames; it
+ * is trusted operator configuration, and an invalid one is a startup error.
+ */
+function compileSymlinkRules(rules) {
+    if (rules === null || rules === undefined)
+        return Object.freeze([]);
+    if (typeof rules === 'string' ||
+        typeof rules !== 'object' ||
+        typeof rules[Symbol.iterator] !== 'function') {
+        throw invalid('Invalid symlink rules');
+    }
+    const compiled = [];
+    const names = new Set();
+    for (const rule of rules) {
+        if (!rule || typeof rule !== 'object' || Array.isArray(rule)) {
+            throw invalid('Invalid symlink rule');
+        }
+        const keys = Object.keys(rule).sort();
+        if (keys.length !== 2 || keys[0] !== 'name' || keys[1] !== 'selector') {
+            throw invalid('Invalid symlink rule');
+        }
+        const { selector, name: rawName } = rule;
+        const name = assertLinkName(rawName);
+        if (names.has(name))
+            throw invalid('Duplicate symlink name');
+        names.add(name);
+        if (typeof selector !== 'string' || selector.length === 0) {
+            throw invalid('Invalid symlink selector');
+        }
+        if (b4a_1.default.from(selector).byteLength > exports.MAX_SYMLINK_SELECTOR_BYTES) {
+            throw invalid('Invalid symlink selector');
+        }
+        if (selector.length >= 2 && selector.startsWith('/') && selector.endsWith('/')) {
+            const source = selector.slice(1, -1);
+            if (source.length === 0)
+                throw invalid('Invalid symlink selector');
+            let pattern;
+            try {
+                pattern = new RegExp(source);
+            }
+            catch (error) {
+                throw invalid('Invalid symlink selector', error);
+            }
+            compiled.push(Object.freeze({
+                selector,
+                name,
+                exact: null,
+                matches: (candidate) => pattern.test(candidate)
+            }));
+            continue;
+        }
+        const exact = (0, files_js_1.validateBasename)(selector);
+        if ((0, files_js_1.isReservedHistoryName)(exact))
+            throw invalid('Reserved symlink selector');
+        if (exact === name)
+            throw invalid('Symlink selector equals its own name');
+        compiled.push(Object.freeze({
+            selector,
+            name,
+            exact,
+            matches: (candidate) => candidate === exact
+        }));
+    }
+    return Object.freeze(compiled);
+}
+function symlinkRuleNames(rules) {
+    return new Set(rules.map((rule) => rule.name));
+}
+/**
+ * Computes the desired links from validated commit records only. A rule with no
+ * match is dormant. Replacement history names never match, and a candidate
+ * whose name equals its own link name is skipped.
+ */
+function selectDesiredLinks(rules, records) {
+    const desired = [];
+    for (const rule of rules) {
+        let selected = null;
+        for (const record of records) {
+            if ((0, files_js_1.isReservedHistoryName)(record.name))
+                continue;
+            if (record.name === rule.name)
+                continue;
+            if (!rule.matches(record.name))
+                continue;
+            if (selected === null || (0, commit_journal_js_1.compareCommitOrder)(record, selected) < 0)
+                selected = record;
+        }
+        if (selected === null)
+            continue;
+        desired.push({
+            name: rule.name,
+            target: selected.name,
+            transferId: selected.transferId,
+            targetKind: (0, commit_journal_js_1.commitRecordKind)(selected)
+        });
+    }
+    return desired;
+}
+//# sourceMappingURL=symlinks.js.map

package/dist/symlinks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"symlinks.js","sourceRoot":"","sources":["../src/symlinks.ts"],"names":[],"mappings":"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"}

package/dist/tar-protocol/controls.d.ts

@@ -0,0 +1,73 @@
+import { type ErrorCode } from '../errors.js';
+export declare const CONTROL_VERSION = 1;
+export declare const MAX_CONTROL_RECORD_BYTES: number;
+export interface MetadataRecord {
+    v: typeof CONTROL_VERSION;
+    name: string;
+    sourceParent?: string;
+    fileSize: number;
+    fileSha256: string;
+    tarSize: number;
+    tarSha256: string;
+    transferId: string;
+    reset: boolean;
+}
+/**
+ * A recursive directory offer. The key set is disjoint from the file record's,
+ * so an older server's `exactKeys()` check rejects it before touching storage.
+ */
+export interface TreeMetadataRecord {
+    v: typeof CONTROL_VERSION;
+    kind: 'directory';
+    name: string;
+    sourceParent?: string;
+    entryCount: number;
+    payloadBytes: number;
+    treeSha256: string;
+    tarSize: number;
+    tarSha256: string;
+    transferId: string;
+    reset: boolean;
+}
+export type AnyMetadataRecord = MetadataRecord | TreeMetadataRecord;
+export declare function isTreeMetadata(value: AnyMetadataRecord): value is TreeMetadataRecord;
+export type AdmissionRecord = {
+    v: typeof CONTROL_VERSION;
+    status: 'ACCEPT';
+    offset: 0;
+} | {
+    v: typeof CONTROL_VERSION;
+    status: 'RESUME';
+    offset: number;
+    prefixSha256: string;
+} | {
+    v: typeof CONTROL_VERSION;
+    status: 'VERIFIED';
+} | {
+    v: typeof CONTROL_VERSION;
+    status: 'ALREADY_COMMITTED';
+} | {
+    v: typeof CONTROL_VERSION;
+    status: 'REJECTED';
+    code: ErrorCode;
+};
+export type FinalRecord = {
+    v: typeof CONTROL_VERSION;
+    status: 'COMMITTED';
+} | {
+    v: typeof CONTROL_VERSION;
+    status: 'FAILED';
+    code: ErrorCode;
+};
+export declare function assertSourceParent(value: unknown): asserts value is string;
+export declare function encodeMetadataRecord(value: MetadataRecord): Buffer;
+export declare function decodeMetadataRecord(bytes: Uint8Array): MetadataRecord;
+export declare function encodeTreeMetadataRecord(value: TreeMetadataRecord): Buffer;
+export declare function decodeTreeMetadataRecord(bytes: Uint8Array): TreeMetadataRecord;
+export declare function encodeAnyMetadataRecord(value: AnyMetadataRecord): Buffer;
+export declare function decodeAnyMetadataRecord(bytes: Uint8Array): AnyMetadataRecord;
+export declare function encodeAdmissionRecord(value: AdmissionRecord): Buffer;
+export declare function decodeAdmissionRecord(bytes: Uint8Array): AdmissionRecord;
+export declare function encodeFinalRecord(value: FinalRecord): Buffer;
+export declare function decodeFinalRecord(bytes: Uint8Array): FinalRecord;
+export declare function encodeControlFrame(record: Uint8Array): Buffer;