pushwork 2.0.0-a.sub.1 → 2.0.0-preview

package/src/utils/mime-types.ts

@@ -1,244 +0,0 @@
-import * as mimeTypes from "mime-types";
-
-/**
- * Custom MIME type definitions for developer files
- * Based on patchwork-cli's approach
- */
-const CUSTOM_MIME_TYPES: Record<string, string> = {
-  // TypeScript files - override the incorrect video/mp2t detection
-  ".ts": "text/typescript",
-  ".tsx": "text/tsx",
-
-  // Config file formats
-  ".json": "application/json",
-  ".yaml": "text/yaml",
-  ".yml": "text/yaml",
-  ".toml": "application/toml",
-  ".ini": "text/plain",
-  ".conf": "text/plain",
-  ".config": "text/plain",
-
-  // Vue.js single file components
-  ".vue": "text/vue",
-
-  // Modern CSS preprocessors
-  ".scss": "text/scss",
-  ".sass": "text/sass",
-  ".less": "text/less",
-  ".styl": "text/stylus",
-
-  // Modern JavaScript variants
-  ".mjs": "application/javascript",
-  ".cjs": "application/javascript",
-
-  // React JSX
-  ".jsx": "text/jsx",
-
-  // Svelte components
-  ".svelte": "text/svelte",
-
-  // Web assembly
-  ".wasm": "application/wasm",
-
-  // Other common dev files
-  ".d.ts": "text/typescript",
-  ".map": "application/json", // Source maps
-  ".env": "text/plain",
-  ".gitignore": "text/plain",
-  ".gitattributes": "text/plain",
-  ".editorconfig": "text/plain",
-  ".prettierrc": "application/json",
-  ".eslintrc": "application/json",
-  ".babelrc": "application/json",
-
-  // Documentation formats
-  ".mdx": "text/markdown",
-  ".rst": "text/x-rst",
-
-  // Docker files
-  Dockerfile: "text/plain",
-  ".dockerignore": "text/plain",
-
-  // Package manager files
-  "package.json": "application/json",
-  "package-lock.json": "application/json",
-  "yarn.lock": "text/plain",
-  "pnpm-lock.yaml": "text/yaml",
-  "composer.json": "application/json",
-  Pipfile: "text/plain",
-  "requirements.txt": "text/plain",
-
-  // Build tool configs
-  "webpack.config.js": "application/javascript",
-  "vite.config.js": "application/javascript",
-  "rollup.config.js": "application/javascript",
-  "tsconfig.json": "application/json",
-  "jsconfig.json": "application/json",
-};
-
-/**
- * File extensions that should always be treated as text
- * regardless of MIME type detection
- */
-const FORCE_TEXT_EXTENSIONS = new Set([
-  ".ts",
-  ".tsx",
-  ".jsx",
-  ".vue",
-  ".svelte",
-  ".scss",
-  ".sass",
-  ".less",
-  ".styl",
-  ".env",
-  ".gitignore",
-  ".gitattributes",
-  ".editorconfig",
-  ".d.ts",
-  ".map",
-  ".mdx",
-  ".rst",
-  ".toml",
-  ".ini",
-  ".conf",
-  ".config",
-  ".lock",
-]);
-
-/**
- * Get enhanced MIME type for file with custom dev file support
- */
-export function getEnhancedMimeType(filePath: string): string {
-  const normalized = normalizePathSeparators(filePath);
-  const filename = normalized.split("/").pop() || "";
-  const extension = getFileExtension(normalized);
-
-  // Check custom definitions first (by extension)
-  if (extension && CUSTOM_MIME_TYPES[extension]) {
-    return CUSTOM_MIME_TYPES[extension];
-  }
-
-  // Check custom definitions by full filename
-  if (CUSTOM_MIME_TYPES[filename]) {
-    return CUSTOM_MIME_TYPES[filename];
-  }
-
-  // Fall back to standard mime-types library
-  const standardMime = mimeTypes.lookup(normalized);
-  if (standardMime) {
-    return standardMime;
-  }
-
-  // Final fallback
-  return "application/octet-stream";
-}
-
-/**
- * Check if file extension should be forced to text type
- */
-export function shouldForceAsText(filePath: string): boolean {
-  const extension = getFileExtension(filePath);
-  return extension ? FORCE_TEXT_EXTENSIONS.has(extension) : false;
-}
-
-/**
- * Get file extension including the dot (internal helper)
- */
-function getFileExtension(filePath: string): string {
-  const match = filePath.match(/\.[^.]*$/);
-  return match ? match[0].toLowerCase() : "";
-}
-
-/**
- * Normalize path separators to forward slashes for cross-platform consistency
- */
-function normalizePathSeparators(p: string): string {
-  return p.replace(/\\/g, "/");
-}
-
-/**
- * Enhanced text file detection with developer file support
- */
-export async function isEnhancedTextFile(filePath: string): Promise<boolean> {
-  // Force certain extensions to be treated as text
-  if (shouldForceAsText(filePath)) {
-    return true;
-  }
-
-  // Check MIME type
-  const mimeType = getEnhancedMimeType(filePath);
-  if (isTextMimeType(mimeType)) {
-    return true;
-  }
-
-  // If it's a known binary type (but not the generic fallback), don't fall back to content detection
-  if (isBinaryMimeType(mimeType) && mimeType !== "application/octet-stream") {
-    return false;
-  }
-
-  // For generic octet-stream or unknown types, use content-based detection
-  return isTextByContent(filePath);
-}
-
-/**
- * Check if MIME type indicates text content
- */
-function isTextMimeType(mimeType: string): boolean {
-  return (
-    mimeType.startsWith("text/") ||
-    mimeType === "application/json" ||
-    mimeType === "application/xml" ||
-    mimeType === "application/javascript" ||
-    mimeType === "application/typescript" ||
-    mimeType === "application/toml" ||
-    mimeType.includes("javascript") ||
-    mimeType.includes("typescript") ||
-    mimeType.includes("json") ||
-    mimeType.includes("xml")
-  );
-}
-
-/**
- * Check if MIME type indicates binary content
- */
-function isBinaryMimeType(mimeType: string): boolean {
-  return (
-    mimeType.startsWith("image/") ||
-    mimeType.startsWith("video/") ||
-    mimeType.startsWith("audio/") ||
-    mimeType.startsWith("font/") ||
-    mimeType === "application/zip" ||
-    mimeType === "application/pdf" ||
-    mimeType === "application/octet-stream" ||
-    mimeType === "application/wasm" ||
-    mimeType.includes("binary")
-  );
-}
-
-/**
- * Content-based text detection (fallback method)
- */
-async function isTextByContent(filePath: string): Promise<boolean> {
-  try {
-    const fs = await import("fs/promises");
-
-    // Sample first 8KB to detect binary content
-    const handle = await fs.open(filePath, "r");
-    const stats = await handle.stat();
-    const sampleSize = Math.min(8192, stats.size);
-
-    if (sampleSize === 0) {
-      await handle.close();
-      return true; // Empty file is text
-    }
-
-    const buffer = Buffer.alloc(sampleSize);
-    await handle.read(buffer, 0, sampleSize, 0);
-    await handle.close();
-
-    // Check for null bytes which indicate binary content
-    return !buffer.includes(0);
-  } catch {
-    return false;
-  }
-}

package/src/utils/network-sync.ts

@@ -1,319 +0,0 @@
-import {
-  DocHandle,
-  Repo,
-  AutomergeUrl,
-} from "@automerge/automerge-repo";
-import { out } from "./output.js";
-import { DirectoryDocument } from "../types/index.js";
-import { getPlainUrl } from "./directory.js";
-
-const isDebug = !!process.env.DEBUG;
-function debug(...args: any[]) {
-  if (isDebug) console.error("[pushwork:sync]", ...args);
-}
-
-/**
- * Wait for bidirectional sync to stabilize.
- * This function waits until document heads stop changing, indicating that
- * both outgoing and incoming sync has completed.
- *
- * With Subduction, sync is handled automatically by the transport layer.
- * We poll heads until they stabilize to confirm sync completion.
- *
- * @param repo - The Automerge repository
- * @param rootDirectoryUrl - The root directory URL to start traversal from
- * @param options - Configuration options
- */
-export async function waitForBidirectionalSync(
-  repo: Repo,
-  rootDirectoryUrl: AutomergeUrl | undefined,
-  options: {
-    timeoutMs?: number;
-    pollIntervalMs?: number;
-    stableChecksRequired?: number;
-    handles?: DocHandle<unknown>[];
-  } = {},
-): Promise<void> {
-  const {
-    timeoutMs = 10000,
-    pollIntervalMs = 100,
-    stableChecksRequired = 3,
-    handles,
-  } = options;
-
-  if (!rootDirectoryUrl) {
-    return;
-  }
-
-  const startTime = Date.now();
-  let lastSeenHeads = new Map<string, string>();
-  let stableCount = 0;
-  let pollCount = 0;
-  let dynamicTimeoutMs = timeoutMs;
-
-  debug(`waitForBidirectionalSync: starting (timeout=${timeoutMs}ms, stableChecks=${stableChecksRequired}${handles ? `, tracking ${handles.length} handles` : ', full tree scan'})`);
-
-  while (Date.now() - startTime < dynamicTimeoutMs) {
-    pollCount++;
-    // Get current heads: use provided handles if available, otherwise full tree scan
-    const currentHeads = handles
-      ? getHandleHeads(handles)
-      : await getAllDocumentHeads(repo, rootDirectoryUrl);
-
-    // After first scan: scale timeout to tree size and reset the clock.
-    // The first scan is just establishing a baseline — its duration
-    // shouldn't count against the stability-wait timeout.
-    if (pollCount === 1) {
-      const scanDuration = Date.now() - startTime;
-      dynamicTimeoutMs = Math.max(timeoutMs, 5000 + currentHeads.size * 50) + scanDuration;
-      debug(`waitForBidirectionalSync: first scan took ${scanDuration}ms, timeout now ${dynamicTimeoutMs}ms for ${currentHeads.size} docs`);
-    }
-
-    // Check if heads are stable (no changes since last check)
-    const isStable = headsMapEqual(lastSeenHeads, currentHeads);
-
-    if (isStable) {
-      stableCount++;
-      debug(`waitForBidirectionalSync: stable check ${stableCount}/${stableChecksRequired} (${currentHeads.size} docs, poll #${pollCount})`);
-      if (stableCount >= stableChecksRequired) {
-        const elapsed = Date.now() - startTime;
-        debug(`waitForBidirectionalSync: converged in ${elapsed}ms after ${pollCount} polls (${currentHeads.size} docs)`);
-        out.taskLine(`Bidirectional sync converged (${currentHeads.size} docs, ${elapsed}ms)`);
-        return; // Converged!
-      }
-    } else {
-      // Find which docs changed
-      if (lastSeenHeads.size > 0) {
-        const changedDocs: string[] = [];
-        for (const [url, heads] of currentHeads) {
-          if (lastSeenHeads.get(url) !== heads) {
-            changedDocs.push(url);
-          }
-        }
-        const newDocs = currentHeads.size - lastSeenHeads.size;
-        if (newDocs > 0) {
-          debug(`waitForBidirectionalSync: ${newDocs} new docs discovered, ${changedDocs.length} docs changed heads (poll #${pollCount})`);
-        } else if (changedDocs.length > 0) {
-          debug(`waitForBidirectionalSync: ${changedDocs.length} docs changed heads: ${changedDocs.slice(0, 5).join(", ")}${changedDocs.length > 5 ? ` ...and ${changedDocs.length - 5} more` : ""} (poll #${pollCount})`);
-        }
-      } else {
-        debug(`waitForBidirectionalSync: initial scan found ${currentHeads.size} docs (poll #${pollCount})`);
-      }
-      if (stableCount > 0) {
-        debug(`waitForBidirectionalSync: heads changed after ${stableCount} stable checks, resetting`);
-      }
-      stableCount = 0;
-      lastSeenHeads = currentHeads;
-    }
-
-    await new Promise((r) => setTimeout(r, pollIntervalMs));
-  }
-
-  // Timeout - but don't throw, just log a warning
-  // The sync may still work, we just couldn't confirm stability
-  const elapsed = Date.now() - startTime;
-  debug(`waitForBidirectionalSync: timed out after ${elapsed}ms (${pollCount} polls, ${lastSeenHeads.size} docs tracked, reached ${stableCount}/${stableChecksRequired} stable checks)`);
-  out.taskLine(`Bidirectional sync timed out after ${(elapsed / 1000).toFixed(1)}s - document heads were still changing after ${pollCount} checks across ${lastSeenHeads.size} docs (reached ${stableCount}/${stableChecksRequired} stability checks). This may mean another peer is actively editing, or the sync server is slow to relay changes. The sync will continue but some remote changes may not be reflected yet.`, true);
-}
-
-/**
- * Get heads from a pre-collected set of handles (cheap, synchronous reads).
- * Used for post-push stabilization where we already know which documents changed.
- */
-function getHandleHeads(
-  handles: DocHandle<unknown>[],
-): Map<string, string> {
-  const heads = new Map<string, string>();
-  for (const handle of handles) {
-    heads.set(getPlainUrl(handle.url), JSON.stringify(handle.heads()));
-  }
-  return heads;
-}
-
-/**
- * Get all document heads in the directory hierarchy.
- * Returns a map of document URL -> serialized heads.
- * Uses plain URLs (without heads) to ensure we see current document state.
- */
-async function getAllDocumentHeads(
-  repo: Repo,
-  rootDirectoryUrl: AutomergeUrl,
-): Promise<Map<string, string>> {
-  const heads = new Map<string, string>();
-  // Pass URL as-is; collectHeadsRecursive will strip heads
-  await collectHeadsRecursive(repo, rootDirectoryUrl, heads);
-  return heads;
-}
-
-/**
- * Recursively collect document heads from the directory hierarchy.
- * Uses getPlainUrl to strip heads and always see the CURRENT state of documents.
- */
-async function collectHeadsRecursive(
-  repo: Repo,
-  directoryUrl: AutomergeUrl,
-  heads: Map<string, string>,
-): Promise<void> {
-  try {
-    const plainUrl = getPlainUrl(directoryUrl);
-    const handle = await repo.find<DirectoryDocument>(plainUrl);
-    const doc = await handle.doc();
-
-    // Record this directory's heads (use plain URL as key for consistency)
-    heads.set(plainUrl, JSON.stringify(handle.heads()));
-
-    if (!doc || !doc.docs) {
-      return;
-    }
-
-    // Process all entries in the directory concurrently
-    await Promise.all(doc.docs.map(async (entry: { type: string; url: AutomergeUrl; name: string }) => {
-      if (entry.type === "folder") {
-        // Recurse into subdirectory (entry.url may have stale heads)
-        await collectHeadsRecursive(repo, entry.url, heads);
-      } else if (entry.type === "file") {
-        // Get file document heads (strip heads from entry.url)
-        try {
-          const fileUrl = getPlainUrl(entry.url);
-          const fileHandle = await repo.find(fileUrl);
-          heads.set(fileUrl, JSON.stringify(fileHandle.heads()));
-        } catch {
-          // File document may not exist yet
-        }
-      }
-    }));
-  } catch {
-    // Directory may not exist yet
-  }
-}
-
-/**
- * Compare two heads maps for equality.
- */
-function headsMapEqual(
-  a: Map<string, string>,
-  b: Map<string, string>,
-): boolean {
-  if (a.size !== b.size) {
-    return false;
-  }
-  for (const [key, value] of a) {
-    if (b.get(key) !== value) {
-      return false;
-    }
-  }
-  return true;
-}
-
-/**
- * Result of waitForSync — lists which handles failed to sync.
- */
-export interface SyncWaitResult {
-  failed: DocHandle<unknown>[];
-}
-
-/** Maximum documents to sync concurrently to avoid flooding the server */
-const SYNC_BATCH_SIZE = 10;
-
-/**
- * Wait for documents to sync by polling head stability.
- *
- * With Subduction, sync is automatic via the transport layer.
- * We wait for each handle's heads to stabilize (stop changing),
- * which indicates the sync layer has finished processing.
- *
- * Processes handles in batches to avoid overwhelming the system.
- */
-export async function waitForSync(
-  handlesToWaitOn: DocHandle<unknown>[],
-  timeoutMs: number = 60000,
-): Promise<SyncWaitResult> {
-  const startTime = Date.now();
-
-  if (handlesToWaitOn.length === 0) {
-    debug("waitForSync: no documents to sync");
-    return { failed: [] };
-  }
-
-  debug(`waitForSync: waiting for ${handlesToWaitOn.length} documents (timeout=${timeoutMs}ms, batchSize=${SYNC_BATCH_SIZE})`);
-  out.taskLine(`Uploading: waiting for ${handlesToWaitOn.length} documents to sync`);
-
-  // Process in batches to avoid flooding the server
-  const failed: DocHandle<unknown>[] = [];
-  let synced = 0;
-
-  for (let i = 0; i < handlesToWaitOn.length; i += SYNC_BATCH_SIZE) {
-    const batch = handlesToWaitOn.slice(i, i + SYNC_BATCH_SIZE);
-    const batchNum = Math.floor(i / SYNC_BATCH_SIZE) + 1;
-    const totalBatches = Math.ceil(handlesToWaitOn.length / SYNC_BATCH_SIZE);
-
-    if (totalBatches > 1) {
-      debug(`waitForSync: batch ${batchNum}/${totalBatches} (${batch.length} docs)`);
-      out.update(`Uploading batch ${batchNum}/${totalBatches} (${synced}/${handlesToWaitOn.length} done)`);
-    }
-
-    const results = await Promise.allSettled(
-      batch.map(handle => waitForHandleHeadStability(handle, timeoutMs, startTime))
-    );
-
-    for (const result of results) {
-      if (result.status === "rejected") {
-        failed.push(result.reason as DocHandle<unknown>);
-      } else {
-        synced++;
-      }
-    }
-  }
-
-  const elapsed = Date.now() - startTime;
-  if (failed.length > 0) {
-    debug(`waitForSync: ${failed.length} documents failed after ${elapsed}ms`);
-    out.taskLine(`Upload: ${synced} synced, ${failed.length} failed after ${(elapsed / 1000).toFixed(1)}s`, true);
-  } else {
-    debug(`waitForSync: all ${handlesToWaitOn.length} documents synced in ${elapsed}ms`);
-    out.taskLine(`All ${handlesToWaitOn.length} documents uploaded to server (${(elapsed / 1000).toFixed(1)}s)`);
-  }
-
-  return { failed };
-}
-
-/**
- * Wait for a single document handle's heads to stabilize.
- * Polls the handle's heads and waits until they remain unchanged
- * for several consecutive checks, indicating sync completion.
- *
- * Resolves with the handle on success, rejects with the handle on timeout.
- */
-function waitForHandleHeadStability(
-  handle: DocHandle<unknown>,
-  timeoutMs: number,
-  startTime: number,
-): Promise<DocHandle<unknown>> {
-  return new Promise<DocHandle<unknown>>((resolve, reject) => {
-    let lastHeads = JSON.stringify(handle.heads());
-    let stableCount = 0;
-    const stableRequired = 3;
-
-    const pollInterval = setInterval(() => {
-      const currentHeads = JSON.stringify(handle.heads());
-      if (currentHeads === lastHeads) {
-        stableCount++;
-        if (stableCount >= stableRequired) {
-          clearInterval(pollInterval);
-          clearTimeout(timeout);
-          debug(`waitForSync: ${handle.url}... converged in ${Date.now() - startTime}ms`);
-          resolve(handle);
-        }
-      } else {
-        stableCount = 0;
-        lastHeads = currentHeads;
-      }
-    }, 100);
-
-    const timeout = setTimeout(() => {
-      clearInterval(pollInterval);
-      debug(`waitForSync: ${handle.url}... timed out after ${timeoutMs}ms`);
-      reject(handle);
-    }, timeoutMs);
-  });
-}

package/src/utils/node-polyfills.ts

@@ -1,8 +0,0 @@
-/**
- * Polyfills for browser APIs required by @automerge/automerge-subduction.
- * Must be imported before any subduction code.
- *
- * The Subduction WASM module uses IndexedDB for key persistence
- * (via WebCryptoSigner). In Node.js we provide a fake-indexeddb polyfill.
- */
-import "fake-indexeddb/auto";