pushwork 1.1.6 → 1.2.2

package/test/integration/sub-flag.test.ts

@@ -0,0 +1,187 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as tmp from "tmp";
+import { execSync, execFile as execFileCb } from "child_process";
+import { promisify } from "util";
+import { SnapshotManager } from "../../src/core";
+
+const execFile = promisify(execFileCb);
+
+describe("--sub flag integration", () => {
+  let tmpDir: string;
+  let cleanup: () => void;
+  const cliPath = path.join(__dirname, "../../dist/cli.js");
+
+  beforeAll(() => {
+    execSync("pnpm build", { cwd: path.join(__dirname, "../.."), stdio: "pipe" });
+  });
+
+  beforeEach(() => {
+    const tmpObj = tmp.dirSync({ unsafeCleanup: true });
+    tmpDir = tmpObj.name;
+    cleanup = tmpObj.removeCallback;
+  });
+
+  afterEach(() => {
+    cleanup();
+  });
+
+  /**
+   * Run pushwork CLI command and return stdout.
+   * Throws on non-zero exit code.
+   */
+  async function pushwork(args: string[], timeoutMs = 30000): Promise<string> {
+    const { stdout } = await execFile("node", [cliPath, ...args], {
+      timeout: timeoutMs,
+      env: { ...process.env, NO_COLOR: "1" },
+    });
+    return stdout;
+  }
+
+  describe("init --sub", () => {
+    it("should initialize a directory with --sub flag", async () => {
+      await fs.writeFile(path.join(tmpDir, "hello.txt"), "Hello from sub!");
+
+      await pushwork(["init", "--sub", tmpDir]);
+
+      // Verify .pushwork was created
+      const pushworkDir = path.join(tmpDir, ".pushwork");
+      const stat = await fs.stat(pushworkDir);
+      expect(stat.isDirectory()).toBe(true);
+
+      // Verify snapshot exists and tracks the file
+      const snapshotManager = new SnapshotManager(tmpDir);
+      const snapshot = await snapshotManager.load();
+      expect(snapshot).not.toBeNull();
+      expect(snapshot!.rootDirectoryUrl).toBeDefined();
+      expect(snapshot!.rootDirectoryUrl).toMatch(/^automerge:/);
+      expect(snapshot!.files.has("hello.txt")).toBe(true);
+    }, 60000);
+
+    it("should track files in subdirectories", async () => {
+      await fs.mkdir(path.join(tmpDir, "src"), { recursive: true });
+      await fs.writeFile(path.join(tmpDir, "src", "index.ts"), "export default {}");
+      await fs.writeFile(path.join(tmpDir, "package.json"), '{"name": "test"}');
+
+      await pushwork(["init", "--sub", tmpDir]);
+
+      const snapshotManager = new SnapshotManager(tmpDir);
+      const snapshot = await snapshotManager.load();
+      expect(snapshot).not.toBeNull();
+      expect(snapshot!.files.has("src/index.ts")).toBe(true);
+      expect(snapshot!.files.has("package.json")).toBe(true);
+    }, 60000);
+
+    it("should respect default exclude patterns with --sub", async () => {
+      await fs.writeFile(path.join(tmpDir, "included.txt"), "keep me");
+      await fs.mkdir(path.join(tmpDir, "node_modules"));
+      await fs.writeFile(path.join(tmpDir, "node_modules", "dep.js"), "module");
+      await fs.mkdir(path.join(tmpDir, ".git"));
+      await fs.writeFile(path.join(tmpDir, ".git", "HEAD"), "ref: refs/heads/main");
+
+      await pushwork(["init", "--sub", tmpDir]);
+
+      const snapshotManager = new SnapshotManager(tmpDir);
+      const snapshot = await snapshotManager.load();
+      expect(snapshot).not.toBeNull();
+      expect(snapshot!.files.has("included.txt")).toBe(true);
+      expect(snapshot!.files.has("node_modules/dep.js")).toBe(false);
+      expect(snapshot!.files.has(".git/HEAD")).toBe(false);
+    }, 60000);
+  });
+
+  describe("sync --sub", () => {
+    it("should sync after init --sub", async () => {
+      await fs.writeFile(path.join(tmpDir, "file1.txt"), "initial content");
+
+      // Init with --sub
+      await pushwork(["init", "--sub", tmpDir]);
+
+      // Add a new file
+      await fs.writeFile(path.join(tmpDir, "file2.txt"), "new file");
+
+      // Sync with --sub
+      await pushwork(["sync", "--sub", tmpDir]);
+
+      // Verify the new file is now tracked
+      const snapshotManager = new SnapshotManager(tmpDir);
+      const snapshot = await snapshotManager.load();
+      expect(snapshot).not.toBeNull();
+      expect(snapshot!.files.has("file1.txt")).toBe(true);
+      expect(snapshot!.files.has("file2.txt")).toBe(true);
+    }, 60000);
+
+    it("should detect file modifications on sync --sub", async () => {
+      await fs.writeFile(path.join(tmpDir, "mutable.txt"), "version 1");
+
+      await pushwork(["init", "--sub", tmpDir]);
+
+      // Record initial heads
+      const snapshotManager = new SnapshotManager(tmpDir);
+      const snapshot1 = await snapshotManager.load();
+      const initialHead = snapshot1!.files.get("mutable.txt")!.head;
+
+      // Modify the file
+      await fs.writeFile(path.join(tmpDir, "mutable.txt"), "version 2");
+
+      // Sync
+      await pushwork(["sync", "--sub", tmpDir]);
+
+      // Heads should have changed
+      const snapshot2 = await snapshotManager.load();
+      const updatedHead = snapshot2!.files.get("mutable.txt")!.head;
+      expect(updatedHead).not.toEqual(initialHead);
+    }, 60000);
+
+    it("should handle file deletions on sync --sub", async () => {
+      await fs.writeFile(path.join(tmpDir, "ephemeral.txt"), "delete me");
+      await fs.writeFile(path.join(tmpDir, "keeper.txt"), "keep me");
+
+      await pushwork(["init", "--sub", tmpDir]);
+
+      // Delete a file
+      await fs.unlink(path.join(tmpDir, "ephemeral.txt"));
+
+      // Sync
+      await pushwork(["sync", "--sub", tmpDir]);
+
+      // Deleted file should be gone from snapshot
+      const snapshotManager = new SnapshotManager(tmpDir);
+      const snapshot = await snapshotManager.load();
+      expect(snapshot).not.toBeNull();
+      expect(snapshot!.files.has("ephemeral.txt")).toBe(false);
+      expect(snapshot!.files.has("keeper.txt")).toBe(true);
+    }, 60000);
+  });
+
+  describe("url after init --sub", () => {
+    it("should print a valid automerge URL", async () => {
+      await pushwork(["init", "--sub", tmpDir]);
+
+      const stdout = await pushwork(["url", tmpDir]);
+      expect(stdout.trim()).toMatch(/^automerge:/);
+    }, 60000);
+  });
+
+  describe("status after init --sub", () => {
+    it("should report status without errors", async () => {
+      await fs.writeFile(path.join(tmpDir, "test.txt"), "status check");
+      await pushwork(["init", "--sub", tmpDir]);
+
+      // status should not throw
+      const stdout = await pushwork(["status", tmpDir]);
+      expect(stdout).toBeDefined();
+    }, 60000);
+  });
+
+  describe("diff after init --sub", () => {
+    it("should show no changes immediately after init", async () => {
+      await fs.writeFile(path.join(tmpDir, "stable.txt"), "no changes");
+      await pushwork(["init", "--sub", tmpDir]);
+
+      const stdout = await pushwork(["diff", tmpDir]);
+      // After a fresh init+sync, there should be no pending changes
+      expect(stdout).not.toContain("modified");
+    }, 60000);
+  });
+});

package/test/unit/artifact-nuke-reinsert.test.ts

@@ -0,0 +1,80 @@
+/**
+ * Test that nukeAndRebuildDocs (the actual production function used by
+ * batchUpdateDirectory for artifact directories) doesn't throw
+ * "Cannot create a reference to an existing document object" when
+ * unchanged entries are spliced out and pushed back.
+ */
+
+import * as A from "@automerge/automerge"
+import { AutomergeUrl } from "@automerge/automerge-repo"
+import { nukeAndRebuildDocs } from "../../src/core/sync-engine"
+import { DirectoryDocument } from "../../src/types/documents"
+
+describe("nukeAndRebuildDocs", () => {
+	let doc: A.Doc<DirectoryDocument>
+
+	beforeEach(() => {
+		doc = A.from({
+			"@patchwork": {type: "folder"},
+			name: "dist",
+			title: "dist",
+			docs: [
+				{name: "index.js", type: "file", url: "automerge:abc123"},
+				{name: "utils.js", type: "file", url: "automerge:def456"},
+				{name: "styles.css", type: "file", url: "automerge:ghi789"},
+			],
+		}) as A.Doc<DirectoryDocument>
+	})
+
+	it("does not throw when some entries are unchanged", () => {
+		// Update only 1 of 3 entries — the other 2 are unchanged and must be
+		// spread into plain objects to avoid the Automerge proxy reinsert error.
+		const newUrl = "automerge:newurl123" as AutomergeUrl
+		doc = A.change(doc, d => {
+			nukeAndRebuildDocs(
+				d,
+				"dist",
+				[],
+				[{name: "index.js", url: newUrl}],
+				[],
+				[],
+			)
+		})
+
+		expect(doc.docs).toHaveLength(3)
+		expect(doc.docs[0].name).toBe("index.js")
+		expect(doc.docs[0].url).toBe(newUrl)
+		expect(doc.docs[1].name).toBe("utils.js")
+		expect(doc.docs[1].url).toBe("automerge:def456")
+		expect(doc.docs[2].name).toBe("styles.css")
+		expect(doc.docs[2].url).toBe("automerge:ghi789")
+	})
+
+	it("handles deletes mixed with unchanged entries", () => {
+		doc = A.change(doc, d => {
+			nukeAndRebuildDocs(d, "dist", [], [], ["utils.js"], [])
+		})
+
+		expect(doc.docs).toHaveLength(2)
+		expect(doc.docs[0].name).toBe("index.js")
+		expect(doc.docs[1].name).toBe("styles.css")
+	})
+
+	it("handles new entries alongside unchanged entries", () => {
+		const newUrl = "automerge:new999" as AutomergeUrl
+		doc = A.change(doc, d => {
+			nukeAndRebuildDocs(
+				d,
+				"dist",
+				[{name: "app.js", url: newUrl}],
+				[],
+				[],
+				[],
+			)
+		})
+
+		expect(doc.docs).toHaveLength(4)
+		expect(doc.docs[3].name).toBe("app.js")
+		expect(doc.docs[3].url).toBe(newUrl)
+	})
+})

package/test/unit/network-sync-sub.test.ts

@@ -0,0 +1,144 @@
+import { waitForSync } from "../../src/utils/network-sync";
+import { DocHandle, StorageId } from "@automerge/automerge-repo";
+
+/**
+ * Create a mock DocHandle with controllable heads.
+ *
+ * @param headSequence - An array of head values the handle returns on
+ *   successive calls to heads(). Once exhausted, the last value repeats.
+ *   This lets us simulate heads that change (sync in progress) and then
+ *   stabilize (sync complete).
+ */
+function mockHandle(headSequence: string[][]): DocHandle<unknown> {
+  let callCount = 0;
+
+  return {
+    url: `automerge:mock-${Math.random().toString(36).slice(2)}`,
+    heads: () => {
+      const idx = Math.min(callCount++, headSequence.length - 1);
+      return headSequence[idx];
+    },
+    // getSyncInfo is only called in the StorageId path, not the head-stability path
+    getSyncInfo: jest.fn(),
+    on: jest.fn(),
+    off: jest.fn(),
+  } as unknown as DocHandle<unknown>;
+}
+
+describe("waitForSync (Subduction / head-stability mode)", () => {
+  // When syncServerStorageId is undefined, waitForSync should use the
+  // head-stability polling path instead of the getSyncInfo-based path.
+
+  it("should return immediately for empty handle list", async () => {
+    const result = await waitForSync([], undefined);
+    expect(result.failed).toHaveLength(0);
+  });
+
+  it("should resolve when handle heads are already stable", async () => {
+    // Heads never change — stable from the start
+    const handle = mockHandle([["head-a", "head-b"]]);
+    const result = await waitForSync([handle], undefined, 5000);
+
+    expect(result.failed).toHaveLength(0);
+    // getSyncInfo should never be called in head-stability mode
+    expect(handle.getSyncInfo).not.toHaveBeenCalled();
+  });
+
+  it("should resolve after heads stabilize", async () => {
+    // Heads change for the first few polls, then stabilize
+    const handle = mockHandle([
+      ["head-1"],   // poll 1: initial
+      ["head-2"],   // poll 2: changed (reset stable count)
+      ["head-3"],   // poll 3: changed again
+      ["head-3"],   // poll 4: stable check 1
+      ["head-3"],   // poll 5: stable check 2
+      ["head-3"],   // poll 6: stable check 3 → converged
+    ]);
+
+    const result = await waitForSync([handle], undefined, 10000);
+    expect(result.failed).toHaveLength(0);
+  });
+
+  it("should report handle as failed on timeout", async () => {
+    // Heads keep changing — never stabilize
+    let counter = 0;
+    const neverStable = {
+      url: "automerge:never-stable",
+      heads: () => [`head-${counter++}`],
+      getSyncInfo: jest.fn(),
+      on: jest.fn(),
+      off: jest.fn(),
+    } as unknown as DocHandle<unknown>;
+
+    const result = await waitForSync([neverStable], undefined, 500);
+    expect(result.failed).toHaveLength(1);
+    expect(result.failed[0]).toBe(neverStable);
+  });
+
+  it("should handle a mix of stable and unstable handles", async () => {
+    const stable = mockHandle([["stable-head"]]);
+
+    let counter = 0;
+    const unstable = {
+      url: "automerge:unstable",
+      heads: () => [`changing-${counter++}`],
+      getSyncInfo: jest.fn(),
+      on: jest.fn(),
+      off: jest.fn(),
+    } as unknown as DocHandle<unknown>;
+
+    const result = await waitForSync([stable, unstable], undefined, 500);
+
+    // The stable handle should succeed, the unstable one should fail
+    expect(result.failed).toHaveLength(1);
+    expect(result.failed[0]).toBe(unstable);
+  });
+
+  it("should not use getSyncInfo when no StorageId is provided", async () => {
+    const handle = mockHandle([["head-a"]]);
+    await waitForSync([handle], undefined, 5000);
+
+    // The head-stability path does not call getSyncInfo at all
+    expect(handle.getSyncInfo).not.toHaveBeenCalled();
+  });
+});
+
+describe("waitForSync (WebSocket / StorageId mode)", () => {
+  // When a StorageId IS provided, waitForSync should use getSyncInfo-based
+  // verification instead of head-stability polling.
+
+  it("should use getSyncInfo when StorageId is provided", async () => {
+    const storageId = "test-storage-id" as StorageId;
+    const heads = ["head-a"];
+
+    const handle = {
+      url: "automerge:ws-handle",
+      heads: () => heads,
+      getSyncInfo: jest.fn().mockReturnValue({ lastHeads: heads }),
+      on: jest.fn(),
+      off: jest.fn(),
+    } as unknown as DocHandle<unknown>;
+
+    const result = await waitForSync([handle], storageId, 5000);
+
+    expect(result.failed).toHaveLength(0);
+    expect(handle.getSyncInfo).toHaveBeenCalledWith(storageId);
+  });
+
+  it("should detect already-synced handles via getSyncInfo", async () => {
+    const storageId = "test-storage-id" as StorageId;
+    const heads = ["same-head"];
+
+    const handle = {
+      url: "automerge:already-synced",
+      heads: () => heads,
+      // getSyncInfo returns matching heads → already synced
+      getSyncInfo: jest.fn().mockReturnValue({ lastHeads: heads }),
+      on: jest.fn(),
+      off: jest.fn(),
+    } as unknown as DocHandle<unknown>;
+
+    const result = await waitForSync([handle], storageId, 5000);
+    expect(result.failed).toHaveLength(0);
+  });
+});

package/test/unit/repo-factory.test.ts

@@ -0,0 +1,111 @@
+/**
+ * Tests for repo-factory.ts Subduction configuration.
+ *
+ * The actual Repo construction requires Wasm initialization via real ESM
+ * dynamic imports. We test by invoking the CLI as a subprocess (which runs
+ * in a real Node.js context) and inspecting the results.
+ *
+ * Non-sub (WebSocket) init is tested elsewhere (init-sync.test.ts).
+ * These tests focus on the --sub path.
+ */
+
+import * as path from "path";
+import * as fs from "fs/promises";
+import * as tmp from "tmp";
+import { execSync } from "child_process";
+
+describe("createRepo with --sub", () => {
+  let tmpDir: string;
+  let cleanup: () => void;
+  const cliPath = path.join(__dirname, "../../dist/cli.js");
+
+  beforeAll(() => {
+    execSync("pnpm build", { cwd: path.join(__dirname, "../.."), stdio: "pipe" });
+  });
+
+  beforeEach(async () => {
+    const tmpObj = tmp.dirSync({ unsafeCleanup: true });
+    tmpDir = tmpObj.name;
+    cleanup = tmpObj.removeCallback;
+  });
+
+  afterEach(() => {
+    cleanup();
+  });
+
+  it("should create a working repo with --sub flag", async () => {
+    await fs.writeFile(path.join(tmpDir, "test.txt"), "hello");
+
+    execSync(`node "${cliPath}" init --sub "${tmpDir}"`, {
+      stdio: "pipe",
+      timeout: 30000,
+    });
+
+    const snapshotPath = path.join(tmpDir, ".pushwork", "snapshot.json");
+    const stat = await fs.stat(snapshotPath);
+    expect(stat.isFile()).toBe(true);
+  });
+
+  it("should produce a valid automerge URL", async () => {
+    await fs.writeFile(path.join(tmpDir, "test.txt"), "hello");
+
+    execSync(`node "${cliPath}" init --sub "${tmpDir}"`, {
+      stdio: "pipe",
+      timeout: 30000,
+    });
+
+    const url = execSync(`node "${cliPath}" url "${tmpDir}"`, {
+      encoding: "utf8",
+      timeout: 10000,
+    }).trim();
+
+    expect(url).toMatch(/^automerge:/);
+  });
+
+  it("should track files in the snapshot", async () => {
+    await fs.writeFile(path.join(tmpDir, "a.txt"), "aaa");
+    await fs.mkdir(path.join(tmpDir, "sub"), { recursive: true });
+    await fs.writeFile(path.join(tmpDir, "sub", "b.txt"), "bbb");
+
+    execSync(`node "${cliPath}" init --sub "${tmpDir}"`, {
+      stdio: "pipe",
+      timeout: 30000,
+    });
+
+    const ls = execSync(`node "${cliPath}" ls "${tmpDir}"`, {
+      encoding: "utf8",
+      timeout: 10000,
+    });
+
+    expect(ls).toContain("a.txt");
+    expect(ls).toContain("b.txt");
+  });
+
+  it("should be able to sync after init", async () => {
+    await fs.writeFile(path.join(tmpDir, "initial.txt"), "first");
+
+    execSync(`node "${cliPath}" init --sub "${tmpDir}"`, {
+      stdio: "pipe",
+      timeout: 30000,
+    });
+
+    // Add a new file
+    await fs.writeFile(path.join(tmpDir, "added.txt"), "second");
+
+    // Sync should not throw. The `sync` command has no --sub flag — it
+    // reads the backend choice from .pushwork/config.json (persisted by
+    // the init --sub above).
+    execSync(`node "${cliPath}" sync "${tmpDir}"`, {
+      stdio: "pipe",
+      timeout: 30000,
+    });
+
+    const ls = execSync(`node "${cliPath}" ls "${tmpDir}"`, {
+      encoding: "utf8",
+      timeout: 10000,
+    });
+
+    expect(ls).toContain("initial.txt");
+    expect(ls).toContain("added.txt");
+  });
+});

package/test/unit/subduction-config.test.ts

@@ -0,0 +1,69 @@
+import * as path from "path";
+import * as fs from "fs/promises";
+import * as tmp from "tmp";
+import { ConfigManager } from "../../src/core/config";
+import { DEFAULT_SUBDUCTION_SERVER, DEFAULT_SYNC_SERVER } from "../../src/types/config";
+
+describe("Subduction configuration", () => {
+  let tmpDir: string;
+  let cleanup: () => void;
+
+  beforeEach(async () => {
+    const tmpObj = tmp.dirSync({ unsafeCleanup: true });
+    tmpDir = tmpObj.name;
+    cleanup = tmpObj.removeCallback;
+
+    // Set up .pushwork directory structure
+    await fs.mkdir(path.join(tmpDir, ".pushwork", "automerge"), { recursive: true });
+  });
+
+  afterEach(() => {
+    cleanup();
+  });
+
+  describe("DEFAULT_SUBDUCTION_SERVER", () => {
+    it("should be the subduction sync endpoint", () => {
+      expect(DEFAULT_SUBDUCTION_SERVER).toBe("wss://subduction.sync.inkandswitch.com");
+    });
+
+    it("should differ from the default WebSocket sync server", () => {
+      expect(DEFAULT_SUBDUCTION_SERVER).not.toBe(DEFAULT_SYNC_SERVER);
+    });
+  });
+
+  describe("ConfigManager defaults", () => {
+    it("should use the WebSocket server as default sync_server", async () => {
+      const configManager = new ConfigManager(tmpDir);
+      const config = configManager.getDefaultDirectoryConfig();
+      expect(config.sync_server).toBe(DEFAULT_SYNC_SERVER);
+    });
+
+    it("should not default to the subduction server", async () => {
+      const configManager = new ConfigManager(tmpDir);
+      const config = configManager.getDefaultDirectoryConfig();
+      expect(config.sync_server).not.toBe(DEFAULT_SUBDUCTION_SERVER);
+    });
+  });
+
+  describe("sub flag option types", () => {
+    // These tests verify that the option interfaces accept `sub` on the
+    // commands that actually have a --sub flag (init and clone). The flag
+    // is NOT on SyncOptions or WatchOptions because sync/watch read the
+    // backend choice from persisted config (see `setupCommandContext`).
+    // If the type definitions are wrong, these will fail at compile time.
+    it("should accept sub on InitOptions", () => {
+      const opts: import("../../src/types/config").InitOptions = { sub: true };
+      expect(opts.sub).toBe(true);
+    });
+
+    it("should accept sub on CloneOptions", () => {
+      const opts: import("../../src/types/config").CloneOptions = { sub: true };
+      expect(opts.sub).toBe(true);
+    });
+
+    it("should default sub to undefined (not required) on InitOptions", () => {
+      const opts: import("../../src/types/config").InitOptions = {};
+      expect(opts.sub).toBeUndefined();
+    });
+  });
+});

package/dist/cli/commands.d.ts

@@ -1,71 +0,0 @@
-import { Repo } from "@automerge/automerge-repo";
-import { CloneOptions, SyncOptions, DiffOptions, LogOptions, CheckoutOptions, DirectoryConfig } from "../types";
-import { SyncEngine } from "../core";
-/**
- * Shared context that commands can use
- */
-export interface CommandContext {
-    repo: Repo;
-    syncEngine: SyncEngine;
-    config: DirectoryConfig;
-    workingDir: string;
-}
-/**
- * Shared pre-action that ensures repository and sync engine are properly initialized
- * This function always works, with or without network connectivity
- */
-export declare function setupCommandContext(workingDir?: string, customSyncServer?: string, customStorageId?: string, enableNetwork?: boolean): Promise<CommandContext>;
-/**
- * Safely shutdown a repository with proper error handling
- */
-export declare function safeRepoShutdown(repo: Repo, context?: string): Promise<void>;
-/**
- * Common progress message helpers
- */
-export declare const ProgressMessages: {
-    directoryFound: () => void;
-    configLoaded: () => void;
-    repoConnected: () => void;
-    syncServer: (server: string) => void;
-    storageId: (id: string) => void;
-    rootUrl: (url: string) => void;
-    changesWritten: () => void;
-    syncCompleted: (duration: number) => void;
-    directoryStructureCreated: () => void;
-    configSaved: () => void;
-    repoCreated: () => void;
-};
-/**
- * Initialize sync in a directory
- */
-export declare function init(targetPath: string, syncServer?: string, syncServerStorageId?: string): Promise<void>;
-/**
- * Run bidirectional sync
- */
-export declare function sync(options: SyncOptions): Promise<void>;
-/**
- * Show differences between local and remote
- */
-export declare function diff(targetPath: string | undefined, options: DiffOptions): Promise<void>;
-/**
- * Show sync status
- */
-export declare function status(): Promise<void>;
-/**
- * Show sync history
- */
-export declare function log(targetPath: string | undefined, options: LogOptions): Promise<void>;
-/**
- * Checkout/restore from previous sync
- */
-export declare function checkout(syncId: string, targetPath: string | undefined, options: CheckoutOptions): Promise<void>;
-/**
- * Clone an existing synced directory from an AutomergeUrl
- */
-export declare function clone(rootUrl: string, targetPath: string, options: CloneOptions): Promise<void>;
-/**
- * Get the root URL for the current pushwork repository
- */
-export declare function url(targetPath?: string): Promise<void>;
-export declare function commit(targetPath: string, dryRun?: boolean): Promise<void>;
-//# sourceMappingURL=commands.d.ts.map

package/dist/cli/commands.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../src/cli/commands.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAA2B,MAAM,2BAA2B,CAAC;AAI1E,OAAO,EAEL,YAAY,EACZ,WAAW,EACX,WAAW,EACX,UAAU,EACV,eAAe,EACf,eAAe,EAEhB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAMrC;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,IAAI,CAAC;IACX,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,EAAE,eAAe,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,UAAU,GAAE,MAAsB,EAClC,gBAAgB,CAAC,EAAE,MAAM,EACzB,eAAe,CAAC,EAAE,MAAM,EACxB,aAAa,GAAE,OAAc,GAC5B,OAAO,CAAC,cAAc,CAAC,CAqCzB;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,IAAI,EACV,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC,CAqBf;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;yBAON,MAAM;oBAEX,MAAM;mBACP,MAAM;;8BAKK,MAAM;;;;CAOjC,CAAC;AA+DF;;GAEG;AACH,wBAAsB,IAAI,CACxB,UAAU,EAAE,MAAM,EAClB,UAAU,CAAC,EAAE,MAAM,EACnB,mBAAmB,CAAC,EAAE,MAAM,GAC3B,OAAO,CAAC,IAAI,CAAC,CA6Hf;AAED;;GAEG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAgM9D;AAED;;GAEG;AACH,wBAAsB,IAAI,CACxB,UAAU,oBAAM,EAChB,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,IAAI,CAAC,CA6Df;AAED;;GAEG;AACH,wBAAsB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CA6H5C;AAED;;GAEG;AACH,wBAAsB,GAAG,CACvB,UAAU,oBAAM,EAChB,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,IAAI,CAAC,CA2Cf;AAED;;GAEG;AACH,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,MAAM,EACd,UAAU,oBAAM,EAChB,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,IAAI,CAAC,CAkBf;AAED;;GAEG;AACH,wBAAsB,KAAK,CACzB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,IAAI,CAAC,CA6Hf;AAED;;GAEG;AACH,wBAAsB,GAAG,CAAC,UAAU,SAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAuCzD;AAED,wBAAsB,MAAM,CAC1B,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,OAAe,GACtB,OAAO,CAAC,IAAI,CAAC,CAgEf"}