@claude-flow/cli 3.32.2 → 3.32.3

package/dist/src/config-adapter.d.ts

@@ -1,15 +0,0 @@
-/**
- * Configuration Adapter
- * Converts between SystemConfig and V3Config types
- */
-import type { SystemConfig } from '@claude-flow/shared';
-import type { V3Config } from './types.js';
-/**
- * Convert SystemConfig to V3Config (CLI-specific format)
- */
-export declare function systemConfigToV3Config(systemConfig: SystemConfig): V3Config;
-/**
- * Convert V3Config to SystemConfig
- */
-export declare function v3ConfigToSystemConfig(v3Config: V3Config): Partial<SystemConfig>;
-//# sourceMappingURL=config-adapter.d.ts.map

package/dist/src/config-adapter.js

@@ -1,186 +0,0 @@
-/**
- * Configuration Adapter
- * Converts between SystemConfig and V3Config types
- */
-/**
- * Convert SystemConfig to V3Config (CLI-specific format)
- */
-export function systemConfigToV3Config(systemConfig) {
-    return {
-        version: '3.0.0',
-        projectRoot: systemConfig.orchestrator?.session?.dataDir || process.cwd(),
-        // Agent configuration
-        agents: {
-            defaultType: 'coder',
-            autoSpawn: false, // Not in SystemConfig
-            maxConcurrent: systemConfig.orchestrator?.lifecycle?.maxConcurrentAgents ?? 15,
-            timeout: systemConfig.orchestrator?.lifecycle?.spawnTimeout ?? 300000,
-            providers: [],
-        },
-        // Swarm configuration
-        swarm: {
-            topology: normalizeTopology(systemConfig.swarm?.topology),
-            maxAgents: systemConfig.swarm?.maxAgents ?? 15,
-            autoScale: systemConfig.swarm?.autoScale?.enabled ?? false,
-            coordinationStrategy: systemConfig.swarm?.coordination?.consensusRequired ? 'consensus' : 'leader',
-            healthCheckInterval: systemConfig.swarm?.coordination?.timeoutMs ?? 10000,
-        },
-        // Memory configuration
-        memory: {
-            backend: normalizeMemoryBackend(systemConfig.memory?.type),
-            persistPath: systemConfig.memory?.path || './data/memory',
-            cacheSize: systemConfig.memory?.maxSize ?? 1000000,
-            enableHNSW: systemConfig.memory?.agentdb?.indexType === 'hnsw',
-            vectorDimension: systemConfig.memory?.agentdb?.dimensions ?? 384, // Match all-MiniLM-L6-v2 output (#1395 Bug 5)
-        },
-        // MCP configuration
-        mcp: {
-            serverHost: systemConfig.mcp?.transport?.host || 'localhost',
-            serverPort: systemConfig.mcp?.transport?.port ?? 3000,
-            autoStart: false, // Not in SystemConfig
-            transportType: systemConfig.mcp?.transport?.type || 'stdio',
-            tools: [], // Not in SystemConfig
-        },
-        // CLI preferences
-        cli: {
-            colorOutput: true,
-            interactive: true,
-            verbosity: 'normal',
-            outputFormat: 'text',
-            progressStyle: 'spinner',
-        },
-        // Hooks configuration
-        hooks: {
-            enabled: false,
-            autoExecute: false,
-            hooks: [],
-        },
-    };
-}
-/**
- * Convert V3Config to SystemConfig
- */
-export function v3ConfigToSystemConfig(v3Config) {
-    return {
-        orchestrator: {
-            lifecycle: {
-                maxConcurrentAgents: v3Config.agents.maxConcurrent,
-                spawnTimeout: v3Config.agents.timeout,
-                terminateTimeout: 10000,
-                maxSpawnRetries: 3,
-            },
-            session: {
-                dataDir: v3Config.projectRoot,
-                persistSessions: true,
-                sessionRetentionMs: 3600000,
-            },
-            health: {
-                checkInterval: v3Config.swarm.healthCheckInterval,
-                historyLimit: 100,
-                degradedThreshold: 1,
-                unhealthyThreshold: 2,
-            },
-        },
-        swarm: {
-            topology: denormalizeTopology(v3Config.swarm.topology),
-            maxAgents: v3Config.swarm.maxAgents,
-            autoScale: {
-                enabled: v3Config.swarm.autoScale,
-                minAgents: 1,
-                maxAgents: v3Config.swarm.maxAgents,
-                scaleUpThreshold: 0.8,
-                scaleDownThreshold: 0.3,
-            },
-            coordination: {
-                consensusRequired: v3Config.swarm.coordinationStrategy === 'consensus',
-                timeoutMs: v3Config.swarm.healthCheckInterval,
-                retryPolicy: {
-                    maxRetries: 3,
-                    backoffMs: 500,
-                },
-            },
-            communication: {
-                protocol: 'events',
-                batchSize: 10,
-                flushIntervalMs: 100,
-            },
-        },
-        memory: {
-            type: denormalizeMemoryBackend(v3Config.memory.backend),
-            path: v3Config.memory.persistPath,
-            maxSize: v3Config.memory.cacheSize,
-            agentdb: {
-                dimensions: v3Config.memory.vectorDimension,
-                indexType: v3Config.memory.enableHNSW ? 'hnsw' : 'flat',
-                efConstruction: 200,
-                m: 16,
-                quantization: 'none',
-            },
-        },
-        mcp: {
-            name: 'ruflo',
-            version: '3.0.0',
-            transport: {
-                type: v3Config.mcp.transportType,
-                host: v3Config.mcp.serverHost,
-                port: v3Config.mcp.serverPort,
-            },
-            capabilities: {
-                tools: true,
-                resources: true,
-                prompts: true,
-                logging: true,
-            },
-        },
-    };
-}
-/**
- * Normalize topology from SystemConfig to V3Config
- */
-function normalizeTopology(topology) {
-    switch (topology) {
-        case 'hierarchical':
-        case 'mesh':
-        case 'ring':
-        case 'star':
-        case 'hybrid':
-        case 'hierarchical-mesh':
-            return topology;
-        case 'adaptive':
-            return 'hybrid';
-        default:
-            return 'hierarchical';
-    }
-}
-/**
- * Denormalize topology from V3Config to SystemConfig
- */
-function denormalizeTopology(topology) {
-    if (topology === 'hybrid') {
-        return 'hierarchical-mesh';
-    }
-    return topology;
-}
-/**
- * Normalize memory backend from SystemConfig to V3Config
- */
-function normalizeMemoryBackend(backend) {
-    switch (backend) {
-        case 'memory':
-        case 'sqlite':
-        case 'agentdb':
-        case 'hybrid':
-            return backend;
-        case 'redis':
-            return 'memory'; // Redis maps to memory for CLI purposes
-        default:
-            return 'hybrid';
-    }
-}
-/**
- * Denormalize memory backend from V3Config to SystemConfig
- */
-function denormalizeMemoryBackend(backend) {
-    return backend;
-}
-//# sourceMappingURL=config-adapter.js.map

package/dist/src/encryption/vault.d.ts

@@ -1,94 +0,0 @@
-/**
- * Encryption-at-rest vault primitives (ADR-096 Phase 1).
- *
- * Goal: provide deterministic encrypt/decrypt of arbitrary Buffers with a
- * symmetric key, using a magic-byte format so readers of older plaintext
- * stores can detect-then-pass-through during the migration window.
- *
- * Phase 1 deliberately ships only the cipher primitives + the env-var key
- * source. Keychain (keytar) and interactive passphrase resolution land in
- * a follow-up iteration so the blast radius of this commit is limited to
- * a single self-contained module with no native dependencies.
- *
- * Wire format (output of encryptBuffer):
- *
- *   +---------+-----------+----------------+--------+
- *   | magic 4 |   iv 12   |  ciphertext N  | tag 16 |
- *   +---------+-----------+----------------+--------+
- *      "RFE1"   random       AES-256-GCM     GCM
- *
- * The magic distinguishes encrypted blobs from plaintext during the
- * incremental migration: readers call isEncryptedBlob() and either
- * decryptBuffer() or treat the bytes as plaintext, so existing
- * .claude-flow/sessions/*.json files keep working unchanged.
- */
-/** ASCII "RFE1" — Ruflo File Encrypted v1. 4 bytes. */
-export declare const MAGIC: Buffer<ArrayBuffer>;
-/**
- * True when at-rest encryption should be applied to writes.
- *
- * Truthy values: "1", "true", "yes", "on" (case-insensitive). Anything else
- * — including unset — keeps the legacy plaintext path. This is the gate
- * that lets the 1865-test baseline keep passing unchanged while users opt
- * into encryption.
- */
-export declare function isEncryptionEnabled(): boolean;
-/**
- * Resolve a 32-byte encryption key from CLAUDE_FLOW_ENCRYPTION_KEY.
- *
- * Phase 1 supports only the env-var source; keychain and passphrase
- * resolution are deferred to a follow-up iteration (see ADR-096). When
- * encryption is enabled but no key resolves, this throws with a clear
- * message rather than silently falling back to plaintext (fail-closed).
- *
- * Accepted encodings (auto-detected by length):
- *   - 64-char hex (32 bytes)
- *   - 44-char base64 (32 bytes + padding)
- *   - exactly 32 raw bytes (rare; for callers that pre-decode)
- *
- * Anything else is rejected — we'd rather fail loudly than encrypt with a
- * truncated key.
- */
-export declare function getKey(): Buffer;
-/**
- * Decode a key string. Exposed for testing and for the future passphrase
- * resolver, which will scrypt-derive a Buffer and hand it back through here
- * to share the same length-check.
- */
-export declare function decodeKey(raw: string): Buffer;
-/**
- * Encrypt a plaintext Buffer with AES-256-GCM. Returns the wire-format
- * blob: magic(4) || iv(12) || ciphertext(N) || tag(16).
- *
- * The IV is freshly randomized per call. Reusing a (key, iv) pair under
- * GCM is catastrophic — every call MUST produce a different IV. Node's
- * randomBytes is csprng-backed so this is automatic; the function takes
- * no IV input deliberately.
- */
-export declare function encryptBuffer(plaintext: Buffer, key: Buffer): Buffer;
-/**
- * Decrypt a wire-format blob. Verifies the magic byte (sanity), parses
- * iv + ciphertext + tag, runs AES-256-GCM decrypt, and lets the GCM
- * auth tag fail loudly on tamper (Node throws "Unsupported state or
- * unable to authenticate data" — we let that propagate).
- *
- * Pre-condition: caller has already determined this is an encrypted
- * blob via isEncryptedBlob(). decryptBuffer throws on bad magic so a
- * mistaken plaintext blob still fails loudly rather than producing
- * garbage.
- */
-export declare function decryptBuffer(blob: Buffer, key: Buffer): Buffer;
-/**
- * Magic-byte sniff. True iff the blob starts with the RFE1 magic AND is
- * long enough to be a valid encrypted blob. Used by readers during the
- * incremental migration: legacy plaintext files return false and flow
- * through the existing read path unchanged.
- *
- * Note: this is a heuristic. A plaintext file that happens to start with
- * "RFE1" would be misdetected — we accept that vanishingly small risk
- * because (a) the four bytes 0x52,0x46,0x45,0x31 are an unusual prefix
- * for JSON (`{`, `[`) or SQLite (`SQLite format 3`), and (b) decryption
- * will then fail with a clear error rather than silently corrupt.
- */
-export declare function isEncryptedBlob(blob: Buffer): boolean;
-//# sourceMappingURL=vault.d.ts.map

package/dist/src/encryption/vault.js

@@ -1,172 +0,0 @@
-/**
- * Encryption-at-rest vault primitives (ADR-096 Phase 1).
- *
- * Goal: provide deterministic encrypt/decrypt of arbitrary Buffers with a
- * symmetric key, using a magic-byte format so readers of older plaintext
- * stores can detect-then-pass-through during the migration window.
- *
- * Phase 1 deliberately ships only the cipher primitives + the env-var key
- * source. Keychain (keytar) and interactive passphrase resolution land in
- * a follow-up iteration so the blast radius of this commit is limited to
- * a single self-contained module with no native dependencies.
- *
- * Wire format (output of encryptBuffer):
- *
- *   +---------+-----------+----------------+--------+
- *   | magic 4 |   iv 12   |  ciphertext N  | tag 16 |
- *   +---------+-----------+----------------+--------+
- *      "RFE1"   random       AES-256-GCM     GCM
- *
- * The magic distinguishes encrypted blobs from plaintext during the
- * incremental migration: readers call isEncryptedBlob() and either
- * decryptBuffer() or treat the bytes as plaintext, so existing
- * .claude-flow/sessions/*.json files keep working unchanged.
- */
-import { createCipheriv, createDecipheriv, randomBytes, timingSafeEqual, } from 'node:crypto';
-// ── Constants ────────────────────────────────────────────────────────────────
-/** ASCII "RFE1" — Ruflo File Encrypted v1. 4 bytes. */
-export const MAGIC = Buffer.from([0x52, 0x46, 0x45, 0x31]); // "RFE1"
-const MAGIC_LEN = MAGIC.length; // 4
-const IV_LEN = 12; // GCM-recommended nonce size
-const TAG_LEN = 16; // GCM auth tag
-const KEY_LEN = 32; // AES-256
-const ALG = 'aes-256-gcm';
-const MIN_BLOB_LEN = MAGIC_LEN + IV_LEN + TAG_LEN; // empty plaintext still has these
-const ENV_ENABLE_FLAG = 'CLAUDE_FLOW_ENCRYPT_AT_REST';
-const ENV_KEY_VAR = 'CLAUDE_FLOW_ENCRYPTION_KEY';
-// ── Public API ───────────────────────────────────────────────────────────────
-/**
- * True when at-rest encryption should be applied to writes.
- *
- * Truthy values: "1", "true", "yes", "on" (case-insensitive). Anything else
- * — including unset — keeps the legacy plaintext path. This is the gate
- * that lets the 1865-test baseline keep passing unchanged while users opt
- * into encryption.
- */
-export function isEncryptionEnabled() {
-    const v = process.env[ENV_ENABLE_FLAG];
-    if (typeof v !== 'string')
-        return false;
-    const norm = v.trim().toLowerCase();
-    return norm === '1' || norm === 'true' || norm === 'yes' || norm === 'on';
-}
-/**
- * Resolve a 32-byte encryption key from CLAUDE_FLOW_ENCRYPTION_KEY.
- *
- * Phase 1 supports only the env-var source; keychain and passphrase
- * resolution are deferred to a follow-up iteration (see ADR-096). When
- * encryption is enabled but no key resolves, this throws with a clear
- * message rather than silently falling back to plaintext (fail-closed).
- *
- * Accepted encodings (auto-detected by length):
- *   - 64-char hex (32 bytes)
- *   - 44-char base64 (32 bytes + padding)
- *   - exactly 32 raw bytes (rare; for callers that pre-decode)
- *
- * Anything else is rejected — we'd rather fail loudly than encrypt with a
- * truncated key.
- */
-export function getKey() {
-    const raw = process.env[ENV_KEY_VAR];
-    if (!raw) {
-        throw new Error(`${ENV_ENABLE_FLAG} is set but ${ENV_KEY_VAR} is not. ` +
-            `Provide a 32-byte key as 64-char hex or 44-char base64. ` +
-            `See ADR-096 for keychain/passphrase support (coming in a follow-up).`);
-    }
-    return decodeKey(raw);
-}
-/**
- * Decode a key string. Exposed for testing and for the future passphrase
- * resolver, which will scrypt-derive a Buffer and hand it back through here
- * to share the same length-check.
- */
-export function decodeKey(raw) {
-    const trimmed = raw.trim();
-    // Hex first — strict 64 chars [0-9a-fA-F]
-    if (/^[0-9a-fA-F]{64}$/.test(trimmed)) {
-        return Buffer.from(trimmed, 'hex');
-    }
-    // Base64 — accept padded 44-char or unpadded 43-char forms
-    if (/^[A-Za-z0-9+/]{43}=?$/.test(trimmed)) {
-        const buf = Buffer.from(trimmed, 'base64');
-        if (buf.length === KEY_LEN)
-            return buf;
-    }
-    throw new Error(`Invalid ${ENV_KEY_VAR}: expected 32-byte key as 64-char hex or 44-char base64`);
-}
-/**
- * Encrypt a plaintext Buffer with AES-256-GCM. Returns the wire-format
- * blob: magic(4) || iv(12) || ciphertext(N) || tag(16).
- *
- * The IV is freshly randomized per call. Reusing a (key, iv) pair under
- * GCM is catastrophic — every call MUST produce a different IV. Node's
- * randomBytes is csprng-backed so this is automatic; the function takes
- * no IV input deliberately.
- */
-export function encryptBuffer(plaintext, key) {
-    if (!Buffer.isBuffer(plaintext)) {
-        throw new TypeError('encryptBuffer: plaintext must be a Buffer');
-    }
-    if (!Buffer.isBuffer(key) || key.length !== KEY_LEN) {
-        throw new TypeError(`encryptBuffer: key must be a ${KEY_LEN}-byte Buffer`);
-    }
-    const iv = randomBytes(IV_LEN);
-    const cipher = createCipheriv(ALG, key, iv);
-    const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
-    const tag = cipher.getAuthTag();
-    return Buffer.concat([MAGIC, iv, ciphertext, tag]);
-}
-/**
- * Decrypt a wire-format blob. Verifies the magic byte (sanity), parses
- * iv + ciphertext + tag, runs AES-256-GCM decrypt, and lets the GCM
- * auth tag fail loudly on tamper (Node throws "Unsupported state or
- * unable to authenticate data" — we let that propagate).
- *
- * Pre-condition: caller has already determined this is an encrypted
- * blob via isEncryptedBlob(). decryptBuffer throws on bad magic so a
- * mistaken plaintext blob still fails loudly rather than producing
- * garbage.
- */
-export function decryptBuffer(blob, key) {
-    if (!Buffer.isBuffer(blob)) {
-        throw new TypeError('decryptBuffer: blob must be a Buffer');
-    }
-    if (!Buffer.isBuffer(key) || key.length !== KEY_LEN) {
-        throw new TypeError(`decryptBuffer: key must be a ${KEY_LEN}-byte Buffer`);
-    }
-    if (blob.length < MIN_BLOB_LEN) {
-        throw new Error(`decryptBuffer: blob too short (${blob.length}B; need >= ${MIN_BLOB_LEN}B)`);
-    }
-    const magic = blob.subarray(0, MAGIC_LEN);
-    // timingSafeEqual to avoid an oracle on the magic bytes specifically;
-    // not strictly required (the magic isn't secret) but cheap and correct.
-    if (!timingSafeEqual(magic, MAGIC)) {
-        throw new Error('decryptBuffer: bad magic — blob is not Ruflo-encrypted (RFE1)');
-    }
-    const iv = blob.subarray(MAGIC_LEN, MAGIC_LEN + IV_LEN);
-    const tag = blob.subarray(blob.length - TAG_LEN);
-    const ciphertext = blob.subarray(MAGIC_LEN + IV_LEN, blob.length - TAG_LEN);
-    const decipher = createDecipheriv(ALG, key, iv);
-    decipher.setAuthTag(tag);
-    return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
-}
-/**
- * Magic-byte sniff. True iff the blob starts with the RFE1 magic AND is
- * long enough to be a valid encrypted blob. Used by readers during the
- * incremental migration: legacy plaintext files return false and flow
- * through the existing read path unchanged.
- *
- * Note: this is a heuristic. A plaintext file that happens to start with
- * "RFE1" would be misdetected — we accept that vanishingly small risk
- * because (a) the four bytes 0x52,0x46,0x45,0x31 are an unusual prefix
- * for JSON (`{`, `[`) or SQLite (`SQLite format 3`), and (b) decryption
- * will then fail with a clear error rather than silently corrupt.
- */
-export function isEncryptedBlob(blob) {
-    if (!Buffer.isBuffer(blob))
-        return false;
-    if (blob.length < MIN_BLOB_LEN)
-        return false;
-    return timingSafeEqual(blob.subarray(0, MAGIC_LEN), MAGIC);
-}
-//# sourceMappingURL=vault.js.map

package/dist/src/fs-secure.d.ts

@@ -1,86 +0,0 @@
-/**
- * Restricted-permission file helpers.
- *
- * audit_1776853149979: session/memory/terminal stores were written with the
- * process umask, which on most macOS/Linux setups leaves them world-readable
- * (mode 0644). They contain conversation snapshots, agent prompts, and
- * terminal command history — anyone else on the host can read them.
- *
- * These helpers write atomically and force mode 0600 (files) / 0700 (dirs).
- * chmod fails silently on Windows, where POSIX modes don't apply — that's
- * fine, the OS-level ACL surface there is different.
- *
- * ADR-096 Phase 2: optional opt-in encryption-at-rest. When the caller
- * passes `encrypt: true` AND the env-gated vault is enabled, payloads are
- * AES-256-GCM-encrypted before hitting disk. Reads use the magic-byte
- * sniff so legacy plaintext files keep working unchanged during the
- * incremental migration.
- */
-/**
- * Crash-safe atomic file write (issue #2584).
- *
- * A plain `writeFileSync(dbPath, db.export())` of a large sql.js image is NOT
- * crash-safe: a kill/OOM mid-write — or a second process rewriting the same
- * path concurrently — leaves a half-written image, and reopening it yields
- * `database disk image is malformed`. The corruption window scales with file
- * size, so a 185 MB monolithic flush is especially exposed.
- *
- * This writes to a unique temp sibling, fsyncs the bytes to disk, then
- * `rename()`s over the target. rename() is atomic on POSIX within one
- * filesystem, so a reader/reopen sees either the old complete image or the new
- * complete image — never a torn one. The directory entry is best-effort fsynced
- * so the rename itself survives a crash. On any failure the temp file is
- * removed and the original is left untouched.
- */
-export declare function writeFileAtomic(path: string, data: Buffer, opts?: {
-    mode?: number;
-}): void;
-/**
- * Create a directory tree with mode 0700 (owner-only). No-op if exists.
- * Uses recursive: true so missing parents are created with the same mode.
- */
-export declare function mkdirRestricted(path: string): void;
-/**
- * Options for writeFileRestricted. Object form so we can grow the API
- * without churning every call site.
- */
-export interface WriteOptions {
-    /** Buffer encoding when `data` is a string. Ignored for Buffer payloads. */
-    encoding?: BufferEncoding;
-    /**
-     * If true AND encryption is globally enabled (CLAUDE_FLOW_ENCRYPT_AT_REST),
-     * encrypt the payload with AES-256-GCM before writing. If encryption is
-     * NOT enabled, this flag is silently ignored — the legacy plaintext path
-     * runs unchanged. Default: false.
-     */
-    encrypt?: boolean;
-}
-/**
- * Write a file and tighten its permissions to mode 0600 (owner read/write).
- *
- * Two call signatures, both supported (the legacy positional one keeps
- * existing call sites working without churn):
- *
- *   writeFileRestricted(path, data)                      // plaintext, utf-8
- *   writeFileRestricted(path, data, 'utf-8')             // legacy: encoding only
- *   writeFileRestricted(path, data, { encrypt: true })   // opt-in encryption
- */
-export declare function writeFileRestricted(path: string, data: string | Buffer, optsOrEncoding?: BufferEncoding | WriteOptions): void;
-/**
- * Read a file and transparently decrypt if it carries the RFE1 magic.
- *
- * Returns a string when the caller asks for one (default utf-8). Returns
- * a Buffer when `encoding` is null. This matches Node's readFileSync
- * shape so the function is a near-drop-in replacement.
- *
- * Migration semantics:
- *   - If the file IS encrypted, decrypt and return.
- *   - If the file is NOT encrypted, return its raw bytes (string-decoded
- *     under `encoding` if requested).
- *
- * That means a reader can be migrated *first*, before its writer flips
- * `encrypt: true`, without breaking on the legacy plaintext path.
- */
-export declare function readFileMaybeEncrypted(path: string, encoding?: BufferEncoding): string;
-export declare function readFileMaybeEncrypted(path: string, encoding: null): Buffer;
-//# sourceMappingURL=fs-secure.d.ts.map

package/dist/src/fs-secure.js

@@ -1,133 +0,0 @@
-/**
- * Restricted-permission file helpers.
- *
- * audit_1776853149979: session/memory/terminal stores were written with the
- * process umask, which on most macOS/Linux setups leaves them world-readable
- * (mode 0644). They contain conversation snapshots, agent prompts, and
- * terminal command history — anyone else on the host can read them.
- *
- * These helpers write atomically and force mode 0600 (files) / 0700 (dirs).
- * chmod fails silently on Windows, where POSIX modes don't apply — that's
- * fine, the OS-level ACL surface there is different.
- *
- * ADR-096 Phase 2: optional opt-in encryption-at-rest. When the caller
- * passes `encrypt: true` AND the env-gated vault is enabled, payloads are
- * AES-256-GCM-encrypted before hitting disk. Reads use the magic-byte
- * sniff so legacy plaintext files keep working unchanged during the
- * incremental migration.
- */
-import { chmodSync, closeSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeSync, } from 'node:fs';
-import { basename, dirname, join } from 'node:path';
-import { decryptBuffer, encryptBuffer, getKey, isEncryptedBlob, isEncryptionEnabled, } from './encryption/vault.js';
-/**
- * Crash-safe atomic file write (issue #2584).
- *
- * A plain `writeFileSync(dbPath, db.export())` of a large sql.js image is NOT
- * crash-safe: a kill/OOM mid-write — or a second process rewriting the same
- * path concurrently — leaves a half-written image, and reopening it yields
- * `database disk image is malformed`. The corruption window scales with file
- * size, so a 185 MB monolithic flush is especially exposed.
- *
- * This writes to a unique temp sibling, fsyncs the bytes to disk, then
- * `rename()`s over the target. rename() is atomic on POSIX within one
- * filesystem, so a reader/reopen sees either the old complete image or the new
- * complete image — never a torn one. The directory entry is best-effort fsynced
- * so the rename itself survives a crash. On any failure the temp file is
- * removed and the original is left untouched.
- */
-export function writeFileAtomic(path, data, opts = {}) {
-    const mode = opts.mode ?? 0o600;
-    const dir = dirname(path);
-    const tmp = join(dir, `.${basename(path)}.tmp-${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`);
-    let fd;
-    try {
-        fd = openSync(tmp, 'wx', mode);
-        if (data.length > 0)
-            writeSync(fd, data, 0, data.length, 0);
-        fsyncSync(fd); // durability: force bytes to disk BEFORE the rename
-        closeSync(fd);
-        fd = undefined;
-        renameSync(tmp, path); // atomic swap — readers never see a torn image
-        try {
-            chmodSync(path, mode);
-        }
-        catch {
-            // Windows / FS without POSIX modes — silently skip.
-        }
-        // Best-effort: fsync the directory so the rename survives a power loss.
-        try {
-            const dfd = openSync(dir, 'r');
-            try {
-                fsyncSync(dfd);
-            }
-            finally {
-                closeSync(dfd);
-            }
-        }
-        catch {
-            // Directory fsync unsupported (e.g. Windows) — the rename is still atomic.
-        }
-    }
-    catch (e) {
-        if (fd !== undefined) {
-            try {
-                closeSync(fd);
-            }
-            catch {
-                /* already closed */
-            }
-        }
-        try {
-            unlinkSync(tmp);
-        }
-        catch {
-            /* temp never created / already gone */
-        }
-        throw e;
-    }
-}
-/**
- * Create a directory tree with mode 0700 (owner-only). No-op if exists.
- * Uses recursive: true so missing parents are created with the same mode.
- */
-export function mkdirRestricted(path) {
-    mkdirSync(path, { recursive: true, mode: 0o700 });
-}
-/**
- * Write a file and tighten its permissions to mode 0600 (owner read/write).
- *
- * Two call signatures, both supported (the legacy positional one keeps
- * existing call sites working without churn):
- *
- *   writeFileRestricted(path, data)                      // plaintext, utf-8
- *   writeFileRestricted(path, data, 'utf-8')             // legacy: encoding only
- *   writeFileRestricted(path, data, { encrypt: true })   // opt-in encryption
- */
-export function writeFileRestricted(path, data, optsOrEncoding = 'utf-8') {
-    const opts = typeof optsOrEncoding === 'string'
-        ? { encoding: optsOrEncoding }
-        : optsOrEncoding;
-    const encoding = opts.encoding ?? 'utf-8';
-    let payload = data;
-    if (opts.encrypt && isEncryptionEnabled()) {
-        const plaintext = Buffer.isBuffer(data) ? data : Buffer.from(data, encoding);
-        payload = encryptBuffer(plaintext, getKey());
-    }
-    // Atomic write (temp → fsync → rename) so a torn/concurrent flush can never
-    // leave a half-written file — the failure mode behind issue #2584. Buffers go
-    // straight through; strings are encoded first (default utf-8).
-    const buf = Buffer.isBuffer(payload) ? payload : Buffer.from(payload, encoding);
-    writeFileAtomic(path, buf, { mode: 0o600 });
-}
-export function readFileMaybeEncrypted(path, encoding = 'utf-8') {
-    const raw = readFileSync(path);
-    let plain;
-    if (isEncryptedBlob(raw)) {
-        plain = decryptBuffer(raw, getKey());
-    }
-    else {
-        plain = raw;
-    }
-    return encoding === null ? plain : plain.toString(encoding);
-}
-//# sourceMappingURL=fs-secure.js.map