@mod-computer/cli 0.2.4 → 0.2.5

package/dist/daemon/share-policy.js

@@ -1,83 +0,0 @@
-// glassware[type="implementation", id="impl-cli-share-policy--044307eb", specifications="specification-spec-no-permissive-bootstrap--2fc35117,specification-spec-strict-allowlist--44f56951,specification-spec-user-doc-init--f355cebf,specification-spec-workspace-allowlist--e668c367,specification-spec-file-allowlist--1bf67504,specification-spec-folder-allowlist--1cc8923c,specification-spec-cleanup-allowlist--9f816ed3,specification-spec-export-share-policy--4371539e,specification-spec-export-workspace-connect--431e5527"]
-/**
- * CLI SharePolicy - strict allowlist approach (aligned with mod-app-new browser).
- * NO permissive bootstrap - all documents must be explicitly added to allowlist.
- * Prevents CLI from accumulating docs from all workspaces.
- */
-// Set of document IDs we're allowed to sync
-const allowedDocs = new Set();
-// Track logged denials (one log per doc)
-const deniedLogged = new Set();
-/**
- * SharePolicy for CLI: strict allowlist, NO permissive bootstrap.
- * Only sync docs explicitly added to allowedDocs set.
- */
-export const cliSharePolicy = async (_peerId, documentId) => {
-    if (!documentId)
-        return false;
-    // STRICT: Only allow documents explicitly in allowlist
-    // NO permissive bootstrap (aligned with mod-app-new browser approach)
-    const allowed = allowedDocs.has(documentId);
-    if (!allowed && !deniedLogged.has(documentId)) {
-        deniedLogged.add(documentId);
-        // Debug log removed - not user-facing
-    }
-    return allowed;
-};
-/**
- * Add user document to allowlist on authentication.
- * Call during auth flow, BEFORE repo operations.
- */
-export function addUserToSharePolicy(userDocId) {
-    allowedDocs.add(userDocId);
-}
-/**
- * Add workspace to allowlist when connecting.
- * Call BEFORE repo.find(workspaceId).
- */
-export function addWorkspaceToSharePolicy(workspaceId) {
-    allowedDocs.add(workspaceId);
-}
-/**
- * Add a single file document to the sharePolicy.
- * Call when a file is tracked for sync.
- */
-export function addFileToSharePolicy(fileId) {
-    allowedDocs.add(fileId);
-}
-/**
- * Add multiple file/folder documents to the sharePolicy.
- * Call BEFORE loading file documents.
- */
-export function addFilesToSharePolicy(fileIds) {
-    fileIds.forEach(id => allowedDocs.add(id));
-}
-/**
- * Remove a single file document from the sharePolicy.
- * Call when a file is deleted.
- */
-export function removeFileFromSharePolicy(fileId) {
-    allowedDocs.delete(fileId);
-}
-/**
- * Remove workspace and all associated documents from allowlist.
- * Call when disconnecting from a workspace.
- */
-export function removeWorkspaceFromSharePolicy(workspaceId, fileIds, folderIds) {
-    allowedDocs.delete(workspaceId);
-    fileIds.forEach(id => allowedDocs.delete(id));
-    folderIds.forEach(id => allowedDocs.delete(id));
-}
-/**
- * Get count of allowed docs (for debugging/testing).
- */
-export function getSharePolicyDocCount() {
-    return allowedDocs.size;
-}
-/**
- * Reset sharePolicy state (for testing).
- */
-export function resetSharePolicyState() {
-    allowedDocs.clear();
-    deniedLogged.clear();
-}

package/dist/daemon/wasm-errors.js

@@ -1,189 +0,0 @@
-// glassware[type="implementation", id="impl-wasm-errors--8c42ad5f", requirements="requirement-cli-sync-wasm-detect--5517bb61,requirement-cli-sync-wasm-recover--ca8c0cb6"]
-/**
- * WASM error handling utilities for Automerge operations.
- * Detects WASM panics and provides graceful error recovery.
- */
-/**
- * Patterns that indicate a WASM panic error.
- */
-const WASM_ERROR_PATTERNS = [
-    'panic',
-    'recursive use of an object',
-    'unsafe aliasing',
-    'RuntimeError',
-    'unreachable',
-    'memory access out of bounds',
-    'table index is out of bounds',
-    'indirect call signature mismatch',
-];
-/**
- * Check if an error is a WASM panic error.
- * @param err - The error to check
- * @returns true if the error is a WASM panic
- */
-export function isWasmError(err) {
-    if (!err)
-        return false;
-    const message = String(err?.message || err || '');
-    const name = String(err?.name || '');
-    const stack = String(err?.stack || '');
-    const combined = `${name} ${message} ${stack}`.toLowerCase();
-    return WASM_ERROR_PATTERNS.some(pattern => combined.includes(pattern.toLowerCase()));
-}
-/**
- * Log a WASM error with document context.
- * @param documentId - The document ID that caused the error
- * @param err - The error that occurred
- */
-export function logWasmError(documentId, err) {
-    const timestamp = new Date().toISOString();
-    const message = err?.message || String(err);
-    const stack = err?.stack || '';
-    console.error(`[WASM] ${timestamp} Error in document ${documentId}:`, message);
-    if (stack) {
-        console.error(`[WASM] Stack:`, stack);
-    }
-}
-/**
- * WasmErrorRecovery - manages retry logic for WASM errors.
- */
-export class WasmErrorRecovery {
-    constructor(options = {}) {
-        this.retryQueue = new Map();
-        this.processInterval = null;
-        this.maxRetries = options.maxRetries ?? 3;
-        this.baseDelayMs = options.baseDelayMs ?? 100;
-        this.log = options.logger ?? console.log;
-    }
-    /**
-     * Execute an operation with WASM error recovery.
-     * @param documentId - Document ID for the operation
-     * @param operation - The operation to execute
-     * @returns Result of the operation, or null if all retries failed
-     */
-    async executeWithRecovery(documentId, operation) {
-        try {
-            return await operation();
-        }
-        catch (err) {
-            if (isWasmError(err)) {
-                logWasmError(documentId, err);
-                this.queueRetry(documentId, operation, err);
-                return null;
-            }
-            throw err; // Re-throw non-WASM errors
-        }
-    }
-    /**
-     * Queue an operation for retry.
-     */
-    queueRetry(documentId, operation, error) {
-        const existing = this.retryQueue.get(documentId);
-        if (existing && existing.attempts >= this.maxRetries) {
-            this.log(`[wasm-recovery] Giving up on ${documentId} after ${this.maxRetries} attempts`);
-            this.retryQueue.delete(documentId);
-            return;
-        }
-        this.retryQueue.set(documentId, {
-            documentId,
-            operation,
-            attempts: (existing?.attempts ?? 0) + 1,
-            lastError: error,
-            createdAt: existing?.createdAt ?? new Date().toISOString(),
-        });
-        this.log(`[wasm-recovery] Queued retry for ${documentId} (attempt ${(existing?.attempts ?? 0) + 1})`);
-    }
-    /**
-     * Process the retry queue, attempting to execute queued operations.
-     */
-    async processRetryQueue() {
-        let succeeded = 0;
-        let failed = 0;
-        const entries = Array.from(this.retryQueue.values());
-        for (const entry of entries) {
-            if (entry.attempts >= this.maxRetries) {
-                this.log(`[wasm-recovery] Max retries reached for ${entry.documentId}`);
-                this.retryQueue.delete(entry.documentId);
-                failed++;
-                continue;
-            }
-            // Exponential backoff delay
-            const delay = this.baseDelayMs * Math.pow(2, entry.attempts - 1);
-            await sleep(delay);
-            try {
-                await entry.operation();
-                this.retryQueue.delete(entry.documentId);
-                succeeded++;
-                this.log(`[wasm-recovery] Retry succeeded for ${entry.documentId}`);
-            }
-            catch (err) {
-                if (isWasmError(err)) {
-                    entry.attempts++;
-                    entry.lastError = err;
-                    logWasmError(entry.documentId, err);
-                }
-                else {
-                    // Non-WASM error, remove from queue
-                    this.retryQueue.delete(entry.documentId);
-                    failed++;
-                    this.log(`[wasm-recovery] Non-WASM error for ${entry.documentId}, removing from queue`);
-                }
-            }
-        }
-        return {
-            succeeded,
-            failed,
-            remaining: this.retryQueue.size,
-        };
-    }
-    /**
-     * Start periodic processing of the retry queue.
-     * @param intervalMs - How often to process the queue (default: 1000ms)
-     */
-    startPeriodicProcessing(intervalMs = 1000) {
-        if (this.processInterval) {
-            return; // Already running
-        }
-        this.processInterval = setInterval(async () => {
-            if (this.retryQueue.size > 0) {
-                await this.processRetryQueue();
-            }
-        }, intervalMs);
-        this.log(`[wasm-recovery] Started periodic processing every ${intervalMs}ms`);
-    }
-    /**
-     * Stop periodic processing.
-     */
-    stopPeriodicProcessing() {
-        if (this.processInterval) {
-            clearInterval(this.processInterval);
-            this.processInterval = null;
-            this.log('[wasm-recovery] Stopped periodic processing');
-        }
-    }
-    /**
-     * Get the number of pending retries.
-     */
-    getPendingCount() {
-        return this.retryQueue.size;
-    }
-    /**
-     * Get all pending retry entries (for debugging).
-     */
-    getPendingEntries() {
-        return Array.from(this.retryQueue.values());
-    }
-    /**
-     * Clear all pending retries.
-     */
-    clearPending() {
-        this.retryQueue.clear();
-        this.log('[wasm-recovery] Cleared all pending retries');
-    }
-}
-/**
- * Sleep helper for backoff delays.
- */
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}