pushwork 2.0.0-preview → 2.0.0-preview.3

package/dist/commands.js

@@ -0,0 +1,975 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+exports.sync = sync;
+exports.diff = diff;
+exports.status = status;
+exports.log = log;
+exports.checkout = checkout;
+exports.clone = clone;
+exports.url = url;
+exports.rm = rm;
+exports.commit = commit;
+exports.ls = ls;
+exports.config = config;
+exports.watch = watch;
+exports.root = root;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises"));
+const fsSync = __importStar(require("fs"));
+const diffLib = __importStar(require("diff"));
+const child_process_1 = require("child_process");
+const config_1 = require("./types/config");
+const core_1 = require("./core");
+const utils_1 = require("./utils");
+const config_2 = require("./core/config");
+const repo_factory_1 = require("./utils/repo-factory");
+const output_1 = require("./utils/output");
+const network_sync_1 = require("./utils/network-sync");
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Initialize repository directory structure and configuration
+ * Shared logic for init and clone commands
+ */
+async function initializeRepository(resolvedPath, overrides, sub = false) {
+    // Create .pushwork directory structure
+    const syncToolDir = path.join(resolvedPath, config_2.ConfigManager.CONFIG_DIR);
+    await (0, utils_1.ensureDirectoryExists)(syncToolDir);
+    await (0, utils_1.ensureDirectoryExists)(path.join(syncToolDir, "automerge"));
+    // Persist Subduction mode + server in config so subsequent commands pick
+    // them up. Without persisting sync_server here, `.pushwork/config.json`
+    // would retain the default WebSocket server even in --sub mode, and
+    // `pushwork config` / `status` would misreport the endpoint.
+    if (sub) {
+        const { sync_server_storage_id: _discarded, ...rest } = overrides;
+        overrides = {
+            ...rest,
+            subduction: true,
+            sync_server: rest.sync_server ?? config_1.DEFAULT_SUBDUCTION_SERVER,
+        };
+    }
+    // Create configuration with overrides
+    const configManager = new config_2.ConfigManager(resolvedPath);
+    let config = await configManager.initializeWithOverrides(overrides);
+    if (sub && config.sync_server_storage_id !== undefined) {
+        config = { ...config, sync_server_storage_id: undefined };
+        await configManager.save(config);
+    }
+    // Create repository and sync engine
+    const repo = await (0, repo_factory_1.createRepo)(resolvedPath, config, sub);
+    const syncEngine = new core_1.SyncEngine(repo, resolvedPath, config);
+    return { config, repo, syncEngine };
+}
+/**
+ * Shared pre-action that ensures repository and sync engine are properly initialized
+ * This function always works, with or without network connectivity
+ */
+async function setupCommandContext(workingDir = process.cwd(), options) {
+    const resolvedPath = path.resolve(workingDir);
+    // Check if initialized
+    const syncToolDir = path.join(resolvedPath, config_2.ConfigManager.CONFIG_DIR);
+    if (!(await (0, utils_1.pathExists)(syncToolDir))) {
+        throw new Error('Directory not initialized for sync. Run "pushwork init" first.');
+    }
+    // Load configuration
+    const configManager = new config_2.ConfigManager(resolvedPath);
+    let config;
+    if (options?.forceDefaults) {
+        // Force mode: use defaults, only preserving backend-selection keys from
+        // local config (root_directory_url, subduction flag, and the sync
+        // endpoint the user originally chose). Everything else (exclude
+        // patterns, artifact dirs, move threshold, etc.) is reset to defaults.
+        const localConfig = await configManager.load();
+        config = configManager.getDefaultDirectoryConfig();
+        if (localConfig?.root_directory_url) {
+            config.root_directory_url = localConfig.root_directory_url;
+        }
+        if (localConfig?.subduction) {
+            config.subduction = localConfig.subduction;
+            config.sync_server = localConfig.sync_server ?? config_1.DEFAULT_SUBDUCTION_SERVER;
+            // sync_server_storage_id is meaningless in Subduction mode; drop it
+            // so the in-memory config reflects reality.
+            config.sync_server_storage_id = undefined;
+        }
+        else {
+            // WebSocket mode: preserve the user's custom server + storage id
+            // if they configured one. Without this, `pushwork sync` (default
+            // force mode) would silently reset a custom --sync-server back to
+            // DEFAULT_SYNC_SERVER on every run.
+            if (localConfig?.sync_server) {
+                config.sync_server = localConfig.sync_server;
+            }
+            if (localConfig?.sync_server_storage_id) {
+                config.sync_server_storage_id = localConfig.sync_server_storage_id;
+            }
+        }
+    }
+    else {
+        config = await configManager.getMerged();
+    }
+    // Override sync_enabled if explicitly specified (e.g., for local-only operations)
+    if (options?.syncEnabled !== undefined) {
+        config = { ...config, sync_enabled: options.syncEnabled };
+    }
+    const sub = config.subduction ?? false;
+    if (sub) {
+        // Default to the Subduction endpoint only if the user hasn't
+        // configured one. Respect any explicit sync_server value (including
+        // custom Subduction endpoints set via `init --sub --sync-server ...`).
+        if (!config.sync_server) {
+            config.sync_server = config_1.DEFAULT_SUBDUCTION_SERVER;
+        }
+        // sync_server_storage_id is a WebSocket-mode concept; clear it so
+        // the in-memory config reflects what waitForSync actually uses
+        // (head-stability polling, not getSyncInfo verification).
+        config.sync_server_storage_id = undefined;
+    }
+    // Create repo with config
+    const repo = await (0, repo_factory_1.createRepo)(resolvedPath, config, sub);
+    // Create sync engine
+    const syncEngine = new core_1.SyncEngine(repo, resolvedPath, config);
+    return {
+        repo,
+        syncEngine,
+        config,
+        workingDir: resolvedPath,
+    };
+}
+/**
+ * Safely shutdown a repository with proper error handling
+ */
+async function safeRepoShutdown(repo) {
+    // TEMPORARY WORKAROUND: pushwork's Subduction sync-verification only
+    // watches local head stability, which doesn't actually confirm the
+    // server received anything. Give any in-flight `syncWithAllPeers`
+    // calls a chance to finish (and the scheduler time to heal transient
+    // failures) before we tear the repo down. Remove once awaitSynced()
+    // (or equivalent) lands in @automerge/automerge-repo@subduction.
+    const graceMsEnv = process.env.PUSHWORK_SYNC_GRACE_MS;
+    const graceMs = graceMsEnv !== undefined ? Number(graceMsEnv) : 3000;
+    if (Number.isFinite(graceMs) && graceMs > 0) {
+        await new Promise((resolve) => setTimeout(resolve, graceMs));
+    }
+    // Handle uncaught WebSocket errors that occur during shutdown
+    const uncaughtErrorHandler = (err) => {
+        if (err.message.includes("WebSocket")) {
+            // Silently suppress WebSocket errors during shutdown
+            return;
+        }
+        // Re-throw non-WebSocket errors
+        throw err;
+    };
+    // Add the error handler before shutdown
+    process.on("uncaughtException", uncaughtErrorHandler);
+    try {
+        await repo.shutdown();
+    }
+    catch (shutdownError) {
+        // WebSocket errors during shutdown are common and non-critical
+        // Silently ignore them - they don't affect data integrity
+        const errorMessage = shutdownError instanceof Error
+            ? shutdownError.message
+            : String(shutdownError);
+        // Ignore WebSocket-related errors entirely
+        if (errorMessage.includes("WebSocket")) {
+            // Silently ignore WebSocket shutdown errors
+            return;
+        }
+    }
+    finally {
+        process.off("uncaughtException", uncaughtErrorHandler);
+    }
+}
+/**
+ * Initialize sync in a directory
+ */
+async function init(targetPath, options = {}) {
+    const resolvedPath = path.resolve(targetPath);
+    const sub = options.sub ?? false;
+    output_1.out.task(`Initializing`);
+    if (sub) {
+        output_1.out.taskLine("Using Subduction sync backend", true);
+    }
+    await (0, utils_1.ensureDirectoryExists)(resolvedPath);
+    // Check if already initialized
+    const syncToolDir = path.join(resolvedPath, config_2.ConfigManager.CONFIG_DIR);
+    if (await (0, utils_1.pathExists)(syncToolDir)) {
+        output_1.out.error("Directory already initialized for sync");
+        output_1.out.exit(1);
+    }
+    // Initialize repository with optional CLI overrides
+    output_1.out.update("Setting up repository");
+    const { repo, syncEngine, config } = await initializeRepository(resolvedPath, {
+        sync_server: options.syncServer,
+        sync_server_storage_id: options.syncServerStorageId,
+    }, sub);
+    // Create new root directory document
+    output_1.out.update("Creating root directory");
+    const dirName = path.basename(resolvedPath);
+    const rootDoc = {
+        "@patchwork": { type: "folder" },
+        name: dirName,
+        title: dirName,
+        docs: [],
+    };
+    const rootHandle = repo.create(rootDoc);
+    // Set root directory URL in snapshot
+    await syncEngine.setRootDirectoryUrl(rootHandle.url);
+    // Wait for root document to sync to server if sync is enabled.
+    // With Subduction, we skip StorageId-based sync verification —
+    // the SubductionSource handles sync internally.
+    if (config.sync_enabled && !sub) {
+        if (config.sync_server_storage_id) {
+            output_1.out.update("Syncing to server");
+            const { failed } = await (0, network_sync_1.waitForSync)([rootHandle], config.sync_server_storage_id);
+            if (failed.length > 0) {
+                output_1.out.taskLine("Root document failed to sync to server", true);
+                // Continue anyway - the document is created locally and will sync later
+            }
+        }
+        else {
+            // WebSocket mode without a storage id can't verify delivery via
+            // getSyncInfo. Warn loudly so users don't silently end up with
+            // data that never reached the server.
+            output_1.out.taskLine("Warning: sync_server_storage_id is not set; skipping post-init sync verification", true);
+        }
+    }
+    // Run initial sync to capture existing files
+    output_1.out.update("Running initial sync");
+    const result = await syncEngine.sync({ sub });
+    output_1.out.update("Writing to disk");
+    await safeRepoShutdown(repo);
+    output_1.out.done("Initialized");
+    output_1.out.successBlock("INITIALIZED", rootHandle.url);
+    if (result.filesChanged > 0) {
+        output_1.out.info(`Synced ${result.filesChanged} ${plural("file", result.filesChanged)}`);
+    }
+    process.exit();
+}
+/**
+ * Run bidirectional sync
+ */
+async function sync(targetPath = ".", options) {
+    output_1.out.task(options.nuclear
+        ? "Nuclear syncing"
+        : options.gentle
+            ? "Gentle syncing"
+            : "Syncing");
+    const { repo, syncEngine, config } = await setupCommandContext(targetPath, {
+        forceDefaults: !options.gentle,
+    });
+    const sub = config.subduction ?? false;
+    if (sub) {
+        output_1.out.taskLine("Using Subduction sync backend (from config)", true);
+    }
+    if (options.nuclear) {
+        await syncEngine.nuclearReset();
+    }
+    if (options.dryRun) {
+        output_1.out.update("Analyzing changes");
+        const preview = await syncEngine.previewChanges();
+        if (preview.changes.length === 0 && preview.moves.length === 0) {
+            output_1.out.done("Already synced");
+            return;
+        }
+        output_1.out.done();
+        output_1.out.infoBlock("CHANGES");
+        output_1.out.obj({
+            Changes: preview.changes.length.toString(),
+            Moves: preview.moves.length > 0 ? preview.moves.length.toString() : undefined,
+        });
+        output_1.out.log("");
+        output_1.out.log("Files:");
+        for (const change of preview.changes.slice(0, 10)) {
+            const prefix = change.changeType === "local_only"
+                ? "[local]  "
+                : change.changeType === "remote_only"
+                    ? "[remote] "
+                    : "[conflict]";
+            output_1.out.log(`  ${prefix} ${change.path}`);
+        }
+        if (preview.changes.length > 10) {
+            output_1.out.log(`  ... and ${preview.changes.length - 10} more`);
+        }
+        if (preview.moves.length > 0) {
+            output_1.out.log("");
+            output_1.out.log("Moves:");
+            for (const move of preview.moves.slice(0, 5)) {
+                output_1.out.log(`  ${move.fromPath} → ${move.toPath}`);
+            }
+            if (preview.moves.length > 5) {
+                output_1.out.log(`  ... and ${preview.moves.length - 5} more`);
+            }
+        }
+        output_1.out.log("");
+        output_1.out.log("Run without --dry-run to apply these changes");
+    }
+    else {
+        const result = await syncEngine.sync({ sub });
+        output_1.out.taskLine("Writing to disk");
+        await safeRepoShutdown(repo);
+        if (result.success) {
+            output_1.out.done("Synced");
+            if (result.filesChanged === 0 && result.directoriesChanged === 0) {
+            }
+            else {
+                output_1.out.successBlock("SYNCED", `${result.filesChanged} ${plural("file", result.filesChanged)}`);
+            }
+            if (result.warnings.length > 0) {
+                output_1.out.log("");
+                output_1.out.warnBlock("WARNINGS", `${result.warnings.length} warnings`);
+                for (const warning of result.warnings.slice(0, 5)) {
+                    output_1.out.log(`  ${warning}`);
+                }
+                if (result.warnings.length > 5) {
+                    output_1.out.log(`  ... and ${result.warnings.length - 5} more`);
+                }
+            }
+        }
+        else {
+            output_1.out.done("partial", false);
+            output_1.out.warnBlock("PARTIAL", `${result.filesChanged} updated, ${result.errors.length} errors`);
+            output_1.out.obj({
+                Files: result.filesChanged,
+                Errors: result.errors.length,
+            });
+            result.errors
+                .slice(0, 5)
+                .forEach((error) => output_1.out.error(`${error.path}: ${error.error.message}`));
+            if (result.errors.length > 5) {
+                output_1.out.warn(`... and ${result.errors.length - 5} more errors`);
+            }
+        }
+        // Always print the root URL
+        const rootUrl = await syncEngine.getRootDirectoryUrl();
+        if (rootUrl) {
+            output_1.out.info(`Root: ${rootUrl}`);
+        }
+    }
+    process.exit();
+}
+/**
+ * Show differences between local and remote
+ */
+async function diff(targetPath = ".", options) {
+    output_1.out.task("Analyzing changes");
+    const { repo, syncEngine } = await setupCommandContext(targetPath, { syncEnabled: false });
+    const preview = await syncEngine.previewChanges();
+    output_1.out.done();
+    if (options.nameOnly) {
+        for (const change of preview.changes) {
+            output_1.out.log(change.path);
+        }
+        return;
+    }
+    if (preview.changes.length === 0) {
+        output_1.out.success("No changes detected");
+        await safeRepoShutdown(repo);
+        output_1.out.exit();
+        return;
+    }
+    output_1.out.warn(`${preview.changes.length} changes detected`);
+    for (const change of preview.changes) {
+        const prefix = change.changeType === "local_only"
+            ? "[local]  "
+            : change.changeType === "remote_only"
+                ? "[remote] "
+                : "[conflict]";
+        try {
+            // Get old content (from snapshot/remote)
+            const oldContent = change.remoteContent || "";
+            // Get new content (current local)
+            const newContent = change.localContent || "";
+            // Convert binary content to string representation if needed
+            const oldText = typeof oldContent === "string"
+                ? oldContent
+                : `<binary content: ${oldContent.length} bytes>`;
+            const newText = typeof newContent === "string"
+                ? newContent
+                : `<binary content: ${newContent.length} bytes>`;
+            // Generate unified diff
+            const diffResult = diffLib.createPatch(change.path, oldText, newText, "previous", "current");
+            // Skip the header lines and process the diff
+            const lines = diffResult.split("\n").slice(4); // Skip index, ===, ---, +++ lines
+            if (lines.length === 0 || (lines.length === 1 && lines[0] === "")) {
+                output_1.out.log(`${prefix}${change.path} (content identical)`, "cyan");
+                continue;
+            }
+            // Extract first hunk header and show inline with path
+            let firstHunk = "";
+            let diffLines = lines;
+            if (lines[0]?.startsWith("@@")) {
+                firstHunk = ` ${lines[0]}`;
+                diffLines = lines.slice(1);
+            }
+            output_1.out.log(`${prefix}${change.path}${firstHunk}`, "cyan");
+            for (const line of diffLines) {
+                if (line.startsWith("@@")) {
+                    // Additional hunk headers
+                    output_1.out.log(line, "dim");
+                }
+                else if (line.startsWith("+")) {
+                    // Added line
+                    output_1.out.log(line, "green");
+                }
+                else if (line.startsWith("-")) {
+                    // Removed line
+                    output_1.out.log(line, "red");
+                }
+                else if (line.startsWith(" ") || line === "") {
+                    // Context line or empty
+                    output_1.out.log(line, "dim");
+                }
+            }
+        }
+        catch (error) {
+            output_1.out.log(`${prefix}${change.path} (diff error: ${error})`, "cyan");
+        }
+    }
+    await safeRepoShutdown(repo);
+}
+/**
+ * Show sync status
+ */
+async function status(targetPath = ".", options = {}) {
+    const { repo, syncEngine, config } = await setupCommandContext(targetPath, { syncEnabled: false });
+    const syncStatus = await syncEngine.getStatus();
+    output_1.out.infoBlock("STATUS");
+    const statusInfo = {};
+    const fileCount = syncStatus.snapshot?.files.size || 0;
+    statusInfo["URL"] = syncStatus.snapshot?.rootDirectoryUrl;
+    statusInfo["Files"] = syncStatus.snapshot
+        ? `${fileCount} tracked`
+        : undefined;
+    statusInfo["Backend"] = config?.subduction ? "subduction" : "websocket";
+    statusInfo["Sync"] = config?.sync_server;
+    // Add more detailed info in verbose mode
+    if (options.verbose && syncStatus.snapshot?.rootDirectoryUrl) {
+        try {
+            const rootHandle = await repo.find(syncStatus.snapshot.rootDirectoryUrl);
+            const rootDoc = await rootHandle.doc();
+            if (rootDoc) {
+                statusInfo["Entries"] = rootDoc.docs.length;
+                statusInfo["Directories"] = syncStatus.snapshot.directories.size;
+                if (rootDoc.lastSyncAt) {
+                    const lastSyncDate = new Date(rootDoc.lastSyncAt);
+                    statusInfo["Last sync"] = lastSyncDate.toISOString();
+                }
+            }
+        }
+        catch (error) {
+            output_1.out.warn(`Warning: Could not load detailed info: ${error}`);
+        }
+    }
+    statusInfo["Changes"] = syncStatus.hasChanges
+        ? `${syncStatus.changeCount} pending`
+        : undefined;
+    statusInfo["Status"] = !syncStatus.hasChanges ? "up to date" : undefined;
+    output_1.out.obj(statusInfo);
+    // Show verbose details if requested
+    if (options.verbose && syncStatus.snapshot?.rootDirectoryUrl) {
+        const rootHandle = await repo.find(syncStatus.snapshot.rootDirectoryUrl);
+        const rootDoc = await rootHandle.doc();
+        if (rootDoc) {
+            output_1.out.infoBlock("HEADS");
+            output_1.out.arr(rootHandle.heads());
+            if (syncStatus.snapshot && syncStatus.snapshot.files.size > 0) {
+                output_1.out.infoBlock("TRACKED FILES");
+                const filesObj = {};
+                syncStatus.snapshot.files.forEach((entry, filePath) => {
+                    filesObj[filePath] = entry.url;
+                });
+                output_1.out.obj(filesObj);
+            }
+        }
+    }
+    if (syncStatus.hasChanges && !options.verbose) {
+        output_1.out.info("Run 'pushwork diff' to see changes");
+    }
+    await safeRepoShutdown(repo);
+}
+/**
+ * Show sync history
+ */
+async function log(targetPath = ".", _options) {
+    const { repo: logRepo, workingDir } = await setupCommandContext(targetPath, { syncEnabled: false });
+    // TODO: Implement history tracking
+    const snapshotPath = path.join(workingDir, config_2.ConfigManager.CONFIG_DIR, "snapshot.json");
+    if (await (0, utils_1.pathExists)(snapshotPath)) {
+        const stats = await fs.stat(snapshotPath);
+        output_1.out.infoBlock("HISTORY", "Sync history (stub)");
+        output_1.out.obj({ "Last sync": stats.mtime.toISOString() });
+    }
+    else {
+        output_1.out.info("No sync history found");
+    }
+    await safeRepoShutdown(logRepo);
+}
+/**
+ * Checkout/restore from previous sync
+ */
+async function checkout(syncId, targetPath = ".", _options) {
+    const { workingDir } = await setupCommandContext(targetPath);
+    // TODO: Implement checkout functionality
+    output_1.out.warnBlock("NOT IMPLEMENTED", "Checkout not yet implemented");
+    output_1.out.obj({
+        "Sync ID": syncId,
+        Path: workingDir,
+    });
+}
+/**
+ * Clone an existing synced directory from an AutomergeUrl
+ */
+async function clone(rootUrl, targetPath, options) {
+    // Validate that rootUrl is actually an Automerge URL
+    if (!rootUrl.startsWith("automerge:")) {
+        output_1.out.error(`Invalid Automerge URL: ${rootUrl}\n` +
+            `Expected format: automerge:XXXXX\n` +
+            `Usage: pushwork clone <automerge-url> <path>`);
+        output_1.out.exit(1);
+    }
+    const resolvedPath = path.resolve(targetPath);
+    const sub = options.sub ?? false;
+    output_1.out.task(`Cloning ${rootUrl}`);
+    if (sub) {
+        output_1.out.taskLine("Using Subduction sync backend", true);
+    }
+    // Check if directory exists and handle --force
+    if (await (0, utils_1.pathExists)(resolvedPath)) {
+        const files = await fs.readdir(resolvedPath);
+        if (files.length > 0 && !options.force) {
+            output_1.out.error("Target directory is not empty. Use --force to overwrite");
+            output_1.out.exit(1);
+        }
+    }
+    else {
+        await (0, utils_1.ensureDirectoryExists)(resolvedPath);
+    }
+    // Check if already initialized
+    const syncToolDir = path.join(resolvedPath, config_2.ConfigManager.CONFIG_DIR);
+    if (await (0, utils_1.pathExists)(syncToolDir)) {
+        if (!options.force) {
+            output_1.out.error("Directory already initialized. Use --force to overwrite");
+            output_1.out.exit(1);
+        }
+        await fs.rm(syncToolDir, { recursive: true, force: true });
+    }
+    // Initialize repository with optional CLI overrides
+    output_1.out.update("Setting up repository");
+    const { config, repo, syncEngine } = await initializeRepository(resolvedPath, {
+        sync_server: options.syncServer,
+        sync_server_storage_id: options.syncServerStorageId,
+    }, sub);
+    // Connect to existing root directory and download files
+    output_1.out.update("Downloading files");
+    await syncEngine.setRootDirectoryUrl(rootUrl);
+    const result = await syncEngine.sync({ sub });
+    output_1.out.update("Writing to disk");
+    await safeRepoShutdown(repo);
+    output_1.out.done();
+    output_1.out.obj({
+        Path: resolvedPath,
+        Files: `${result.filesChanged} downloaded`,
+        Backend: config.subduction ? "subduction" : "websocket",
+        Sync: config.sync_server,
+    });
+    output_1.out.successBlock("CLONED", rootUrl);
+    process.exit();
+}
+/**
+ * Get the root URL for the current pushwork repository
+ */
+async function url(targetPath = ".") {
+    const resolvedPath = path.resolve(targetPath);
+    const syncToolDir = path.join(resolvedPath, config_2.ConfigManager.CONFIG_DIR);
+    if (!(await (0, utils_1.pathExists)(syncToolDir))) {
+        output_1.out.error("Directory not initialized for sync");
+        output_1.out.exit(1);
+    }
+    const snapshotPath = path.join(syncToolDir, "snapshot.json");
+    if (!(await (0, utils_1.pathExists)(snapshotPath))) {
+        output_1.out.error("No snapshot found");
+        output_1.out.exit(1);
+    }
+    const snapshotData = await fs.readFile(snapshotPath, "utf-8");
+    const snapshot = JSON.parse(snapshotData);
+    if (snapshot.rootDirectoryUrl) {
+        // Output just the URL for easy use in scripts
+        output_1.out.log(snapshot.rootDirectoryUrl);
+    }
+    else {
+        output_1.out.error("No root URL found in snapshot");
+        output_1.out.exit(1);
+    }
+}
+/**
+ * Remove local pushwork data and log URL for recovery
+ */
+async function rm(targetPath = ".") {
+    const resolvedPath = path.resolve(targetPath);
+    const syncToolDir = path.join(resolvedPath, config_2.ConfigManager.CONFIG_DIR);
+    if (!(await (0, utils_1.pathExists)(syncToolDir))) {
+        output_1.out.error("Directory not initialized for sync");
+        output_1.out.exit(1);
+    }
+    // Read the URL before deletion for recovery
+    let recoveryUrl = "";
+    const snapshotPath = path.join(syncToolDir, "snapshot.json");
+    if (await (0, utils_1.pathExists)(snapshotPath)) {
+        try {
+            const snapshotData = await fs.readFile(snapshotPath, "utf-8");
+            const snapshot = JSON.parse(snapshotData);
+            recoveryUrl = snapshot.rootDirectoryUrl || null;
+        }
+        catch (error) {
+            output_1.out.error(`Remove failed: ${error}`);
+            output_1.out.exit(1);
+            return;
+        }
+    }
+    output_1.out.task("Removing local pushwork data");
+    await fs.rm(syncToolDir, { recursive: true, force: true });
+    output_1.out.done();
+    output_1.out.warnBlock("REMOVED", recoveryUrl);
+    process.exit();
+}
+async function commit(targetPath, _options = {}) {
+    output_1.out.task("Committing local changes");
+    const { repo, syncEngine } = await setupCommandContext(targetPath, { syncEnabled: false });
+    const result = await syncEngine.commitLocal();
+    await safeRepoShutdown(repo);
+    output_1.out.done();
+    if (result.errors.length > 0) {
+        output_1.out.errorBlock("ERROR", `${result.errors.length} errors`);
+        result.errors.forEach((error) => output_1.out.error(error));
+        output_1.out.exit(1);
+    }
+    output_1.out.successBlock("COMMITTED", `${result.filesChanged} files`);
+    output_1.out.obj({
+        Files: result.filesChanged,
+        Directories: result.directoriesChanged,
+    });
+    if (result.warnings.length > 0) {
+        result.warnings.forEach((warning) => output_1.out.warn(warning));
+    }
+    process.exit();
+}
+/**
+ * List tracked files
+ */
+async function ls(targetPath = ".", options = {}) {
+    const { repo, syncEngine } = await setupCommandContext(targetPath, { syncEnabled: false });
+    const syncStatus = await syncEngine.getStatus();
+    if (!syncStatus.snapshot) {
+        output_1.out.error("No snapshot found");
+        await safeRepoShutdown(repo);
+        output_1.out.exit(1);
+        return;
+    }
+    const files = Array.from(syncStatus.snapshot.files.entries()).sort(([pathA], [pathB]) => pathA.localeCompare(pathB));
+    if (files.length === 0) {
+        output_1.out.info("No tracked files");
+        await safeRepoShutdown(repo);
+        return;
+    }
+    if (options.verbose) {
+        // Long format with URLs
+        for (const [filePath, entry] of files) {
+            const url = entry?.url || "unknown";
+            output_1.out.log(`${filePath} -> ${url}`);
+        }
+    }
+    else {
+        // Simple list
+        for (const [filePath] of files) {
+            output_1.out.log(filePath);
+        }
+    }
+    await safeRepoShutdown(repo);
+}
+/**
+ * View or edit configuration
+ */
+async function config(targetPath = ".", options = {}) {
+    const resolvedPath = path.resolve(targetPath);
+    const syncToolDir = path.join(resolvedPath, config_2.ConfigManager.CONFIG_DIR);
+    if (!(await (0, utils_1.pathExists)(syncToolDir))) {
+        output_1.out.error("Directory not initialized for sync");
+        output_1.out.exit(1);
+    }
+    const configManager = new config_2.ConfigManager(resolvedPath);
+    const config = await configManager.getMerged();
+    if (options.list) {
+        // List all configuration
+        output_1.out.infoBlock("CONFIGURATION", "Full configuration");
+        output_1.out.log(JSON.stringify(config, null, 2));
+    }
+    else if (options.get) {
+        // Get specific config value
+        const keys = options.get.split(".");
+        let value = config;
+        for (const key of keys) {
+            value = value?.[key];
+        }
+        if (value !== undefined) {
+            output_1.out.log(typeof value === "object" ? JSON.stringify(value, null, 2) : value);
+        }
+        else {
+            output_1.out.error(`Config key not found: ${options.get}`);
+            output_1.out.exit(1);
+        }
+    }
+    else {
+        // Show basic config info
+        output_1.out.infoBlock("CONFIGURATION");
+        output_1.out.obj({
+            Backend: config.subduction ? "subduction" : "websocket",
+            "Sync server": config.sync_server || "default",
+            "Sync enabled": config.sync_enabled ? "yes" : "no",
+            Exclusions: config.exclude_patterns?.length,
+        });
+        output_1.out.log("");
+        output_1.out.log("Use --list to see full configuration");
+    }
+}
+/**
+ * Watch a directory and sync after build script completes
+ */
+async function watch(targetPath = ".", options = {}) {
+    const script = options.script || "pnpm build";
+    const watchDir = options.watchDir || "src"; // Default to watching 'src' directory
+    const verbose = options.verbose || false;
+    const { repo, syncEngine, config, workingDir } = await setupCommandContext(targetPath);
+    const sub = config.subduction ?? false;
+    const absoluteWatchDir = path.resolve(workingDir, watchDir);
+    // Check if watch directory exists
+    if (!(await (0, utils_1.pathExists)(absoluteWatchDir))) {
+        output_1.out.error(`Watch directory does not exist: ${watchDir}`);
+        await safeRepoShutdown(repo);
+        output_1.out.exit(1);
+        return;
+    }
+    output_1.out.spicyBlock("WATCHING", `${chalk_1.default.underline((0, utils_1.formatRelativePath)(watchDir))} for changes...`);
+    if (sub) {
+        output_1.out.info("Using Subduction sync backend (from config)");
+    }
+    output_1.out.info(`Build script: ${script}`);
+    output_1.out.info(`Working directory: ${workingDir}`);
+    let isProcessing = false;
+    let pendingChange = false;
+    // Function to run build and sync
+    const runBuildAndSync = async () => {
+        if (isProcessing) {
+            pendingChange = true;
+            return;
+        }
+        isProcessing = true;
+        pendingChange = false;
+        try {
+            output_1.out.spicy(`[${new Date().toLocaleTimeString()}] Changes detected...`);
+            // Run build script
+            const buildResult = await runScript(script, workingDir, verbose);
+            if (!buildResult.success) {
+                output_1.out.warn("Build script failed");
+                if (buildResult.output) {
+                    output_1.out.log("");
+                    output_1.out.log(buildResult.output);
+                }
+                isProcessing = false;
+                if (pendingChange) {
+                    setImmediate(() => runBuildAndSync());
+                }
+                return;
+            }
+            output_1.out.info("Build completed...");
+            // Run sync
+            output_1.out.task("Syncing");
+            const result = await syncEngine.sync({ sub });
+            if (result.success) {
+                if (result.filesChanged === 0 && result.directoriesChanged === 0) {
+                    output_1.out.done("Already synced");
+                }
+                else {
+                    output_1.out.done(`Synced ${result.filesChanged} ${plural("file", result.filesChanged)}`);
+                }
+            }
+            else {
+                output_1.out.warn(`⚠ Partial sync: ${result.filesChanged} updated, ${result.errors.length} errors`);
+                result.errors
+                    .slice(0, 3)
+                    .forEach((error) => output_1.out.error(`  ${error.path}: ${error.error.message}`));
+                if (result.errors.length > 3) {
+                    output_1.out.warn(`  ... and ${result.errors.length - 3} more errors`);
+                }
+            }
+            if (result.warnings.length > 0) {
+                result.warnings
+                    .slice(0, 3)
+                    .forEach((warning) => output_1.out.warn(`  ${warning}`));
+                if (result.warnings.length > 3) {
+                    output_1.out.warn(`  ... and ${result.warnings.length - 3} more warnings`);
+                }
+            }
+        }
+        catch (error) {
+            output_1.out.error(`Error during build/sync: ${error}`);
+        }
+        finally {
+            isProcessing = false;
+            // If changes occurred while we were processing, run again
+            if (pendingChange) {
+                setImmediate(() => runBuildAndSync());
+            }
+        }
+    };
+    // Set up file watcher - watches everything in the specified directory
+    const watcher = fsSync.watch(absoluteWatchDir, { recursive: true }, (_eventType, filename) => {
+        if (filename) {
+            runBuildAndSync();
+        }
+    });
+    // Handle graceful shutdown
+    const shutdown = async () => {
+        output_1.out.log("");
+        output_1.out.info("Shutting down...");
+        watcher.close();
+        await safeRepoShutdown(repo);
+        output_1.out.rainbow("Goodbye!");
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    // Run initial build and sync
+    await runBuildAndSync();
+    // Keep process alive
+    await new Promise(() => { }); // Never resolves, keeps watching
+}
+/**
+ * Run a shell script and wait for completion
+ */
+async function runScript(script, cwd, verbose) {
+    return new Promise((resolve) => {
+        const [command, ...args] = script.split(" ");
+        const child = (0, child_process_1.spawn)(command, args, {
+            cwd,
+            stdio: verbose ? "inherit" : "pipe", // Show output directly if verbose, otherwise capture
+            shell: true,
+        });
+        let output = "";
+        // Capture output if not verbose (so we can show it on error)
+        if (!verbose) {
+            child.stdout?.on("data", (data) => {
+                output += data.toString();
+            });
+            child.stderr?.on("data", (data) => {
+                output += data.toString();
+            });
+        }
+        child.on("close", (code) => {
+            resolve({
+                success: code === 0,
+                output: !verbose ? output : undefined,
+            });
+        });
+        child.on("error", (error) => {
+            output_1.out.error(`Failed to run script: ${error.message}`);
+            resolve({
+                success: false,
+                output: !verbose ? output : undefined,
+            });
+        });
+    });
+}
+/**
+ * Set root directory URL for an existing or new pushwork directory
+ */
+async function root(rootUrl, targetPath = ".", options = {}) {
+    if (!rootUrl.startsWith("automerge:")) {
+        output_1.out.error(`Invalid Automerge URL: ${rootUrl}\n` +
+            `Expected format: automerge:XXXXX`);
+        output_1.out.exit(1);
+    }
+    const resolvedPath = path.resolve(targetPath);
+    const syncToolDir = path.join(resolvedPath, config_2.ConfigManager.CONFIG_DIR);
+    const sub = options.sub ?? false;
+    if (await (0, utils_1.pathExists)(syncToolDir)) {
+        if (!options.force) {
+            output_1.out.error("Directory already initialized for pushwork. Use --force to overwrite");
+            output_1.out.exit(1);
+        }
+    }
+    await (0, utils_1.ensureDirectoryExists)(syncToolDir);
+    await (0, utils_1.ensureDirectoryExists)(path.join(syncToolDir, "automerge"));
+    // Create minimal snapshot with just the root URL
+    const snapshotPath = path.join(syncToolDir, "snapshot.json");
+    const snapshot = {
+        timestamp: Date.now(),
+        rootPath: resolvedPath,
+        rootDirectoryUrl: rootUrl,
+        files: [],
+        directories: [],
+    };
+    await fs.writeFile(snapshotPath, JSON.stringify(snapshot, null, 2), "utf-8");
+    // Ensure config exists. In Subduction mode, persist the backend choice
+    // and the correct server so subsequent `sync` runs use the right endpoint.
+    const configManager = new config_2.ConfigManager(resolvedPath);
+    if (sub) {
+        let cfg = await configManager.initializeWithOverrides({
+            subduction: true,
+            sync_server: config_1.DEFAULT_SUBDUCTION_SERVER,
+        });
+        // Strip dead-baggage storage_id that getDefaultDirectoryConfig seeded.
+        if (cfg.sync_server_storage_id !== undefined) {
+            cfg = { ...cfg, sync_server_storage_id: undefined };
+            await configManager.save(cfg);
+        }
+    }
+    else {
+        await configManager.initializeWithOverrides({});
+    }
+    output_1.out.successBlock("ROOT SET", rootUrl);
+    if (sub) {
+        output_1.out.info("Using Subduction sync backend");
+    }
+    process.exit();
+}
+function plural(word, count) {
+    return count === 1 ? word : `${word}s`;
+}
+//# sourceMappingURL=commands.js.map