@mod-computer/cli 0.1.1 → 0.2.2

package/dist/daemon/share-policy.js

@@ -0,0 +1,83 @@
+// 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

@@ -0,0 +1,189 @@
+// 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));
+}