pushwork 2.0.0-preview → 2.0.0-preview.3

package/src/repo.ts

@@ -1,76 +0,0 @@
-import {
-	Repo,
-	initSubduction,
-	type DocHandle,
-	type NetworkAdapterInterface,
-} from "@automerge/automerge-repo";
-import { WebSocketClientAdapter } from "@automerge/automerge-repo-network-websocket";
-import { NodeFSStorageAdapter } from "@automerge/automerge-repo-storage-nodefs";
-import type { Backend } from "./config.js";
-import { log } from "./log.js";
-
-const dlog = log("repo");
-
-const DEFAULT_LEGACY = "wss://sync3.automerge.org";
-const DEFAULT_SUBDUCTION = "wss://subduction.sync.inkandswitch.com";
-
-export const legacyUrl = () =>
-	process.env.PUSHWORK_LEGACY_SERVER || DEFAULT_LEGACY;
-export const subductionUrl = () =>
-	process.env.PUSHWORK_SUBDUCTION_SERVER || DEFAULT_SUBDUCTION;
-
-export async function openRepo(
-	backend: Backend,
-	storageDir: string,
-	opts: { offline?: boolean } = {},
-): Promise<Repo> {
-	dlog("openRepo backend=%s storage=%s offline=%s", backend, storageDir, !!opts.offline);
-	await initSubduction();
-	const storage = new NodeFSStorageAdapter(storageDir);
-	if (opts.offline) {
-		return new Repo({ storage, network: [] });
-	}
-	if (backend === "legacy") {
-		const endpoint = legacyUrl();
-		dlog("legacy ws endpoint=%s", endpoint);
-		const adapter = new WebSocketClientAdapter(
-			endpoint,
-		) as unknown as NetworkAdapterInterface;
-		return new Repo({ storage, network: [adapter] });
-	}
-	const endpoint = subductionUrl();
-	dlog("subduction ws endpoint=%s", endpoint);
-	return new Repo({
-		storage,
-		network: [],
-		subductionWebsocketEndpoints: [endpoint],
-	});
-}
-
-const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
-
-export async function waitForSync<T>(
-	handle: DocHandle<T>,
-	{ minMs = 0, idleMs = 1500, maxMs = 15000, pollMs = 200 } = {},
-): Promise<void> {
-	dlog("waitForSync url=%s minMs=%d idleMs=%d maxMs=%d", handle.url, minMs, idleMs, maxMs);
-	const headsKey = () => JSON.stringify(handle.heads());
-	let last = headsKey();
-	let lastChange = Date.now();
-	const start = Date.now();
-	while (Date.now() - start < maxMs) {
-		await sleep(pollMs);
-		const next = headsKey();
-		if (next !== last) {
-			last = next;
-			lastChange = Date.now();
-		} else if (
-			Date.now() - lastChange >= idleMs &&
-			Date.now() - start >= minMs
-		) {
-			dlog("waitForSync settled url=%s elapsed=%dms", handle.url, Date.now() - start);
-			return;
-		}
-	}
-	dlog("waitForSync timed out url=%s after %dms", handle.url, maxMs);
-}

package/src/shapes/custom.ts

@@ -1,29 +0,0 @@
-import * as path from "path";
-import { pathToFileURL } from "url";
-import { log } from "../log.js";
-import type { Shape } from "./types.js";
-
-const dlog = log("shapes:custom");
-
-export async function loadCustomShape(filePath: string): Promise<Shape> {
-	const absolute = path.isAbsolute(filePath)
-		? filePath
-		: path.resolve(process.cwd(), filePath);
-	dlog("loading custom shape from %s", absolute);
-	const url = pathToFileURL(absolute).href;
-	const mod = (await import(url)) as {
-		default?: Partial<Shape>;
-	};
-	const candidate = mod.default;
-	if (
-		!candidate ||
-		typeof candidate.encode !== "function" ||
-		typeof candidate.decode !== "function"
-	) {
-		throw new Error(
-			`shape ${filePath} must export default { encode, decode }`,
-		);
-	}
-	dlog("custom shape loaded ok");
-	return candidate as Shape;
-}

package/src/shapes/file.ts

@@ -1,115 +0,0 @@
-import * as path from "path";
-import mime from "mime-types";
-import {
-	ImmutableString,
-	isImmutableString,
-	parseAutomergeUrl,
-	stringifyAutomergeUrl,
-	type AutomergeUrl,
-	type DocHandle,
-	type Repo,
-} from "@automerge/automerge-repo";
-import type { UnixFileEntry } from "./types.js";
-
-export type Content = string | Uint8Array | ImmutableString;
-
-export function bytesToContent(
-	bytes: Uint8Array,
-	isArtifact: boolean,
-): Content {
-	if (bytes.includes(0)) return bytes;
-	let text: string;
-	try {
-		text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-	} catch {
-		return bytes;
-	}
-	const reencoded = new TextEncoder().encode(text);
-	if (reencoded.length !== bytes.length) return bytes;
-	for (let i = 0; i < bytes.length; i++) {
-		if (reencoded[i] !== bytes[i]) return bytes;
-	}
-	return isArtifact ? new ImmutableString(text) : text;
-}
-
-export function contentToBytes(content: Content): Uint8Array {
-	if (typeof content === "string") return new TextEncoder().encode(content);
-	if (isImmutableString(content)) {
-		return new TextEncoder().encode(String(content));
-	}
-	return content instanceof Uint8Array ? content : new Uint8Array(content);
-}
-
-export function contentEquals(a: Content, b: Content): boolean {
-	const av = a instanceof Uint8Array ? a : contentToBytes(a);
-	const bv = b instanceof Uint8Array ? b : contentToBytes(b);
-	if (av.length !== bv.length) return false;
-	for (let i = 0; i < av.length; i++) if (av[i] !== bv[i]) return false;
-	return true;
-}
-
-export function makeFileEntry(
-	relativePath: string,
-	bytes: Uint8Array,
-	isArtifact: boolean,
-): UnixFileEntry {
-	const name = path.posix.basename(relativePath);
-	const ext = path.posix.extname(name).replace(/^\./, "");
-	return {
-		"@patchwork": { type: "file" },
-		content: bytesToContent(bytes, isArtifact),
-		extension: ext,
-		mimeType: mime.lookup(name) || "application/octet-stream",
-		name,
-	};
-}
-
-export function readFileEntry(handle: DocHandle<unknown>): {
-	bytes: Uint8Array;
-	entry: UnixFileEntry;
-} {
-	const doc = handle.doc() as Partial<UnixFileEntry> | undefined;
-	if (!doc || typeof doc !== "object" || !("content" in doc)) {
-		throw new Error(`document ${handle.url} is not a UnixFileEntry`);
-	}
-	const entry = doc as UnixFileEntry;
-	return { bytes: contentToBytes(entry.content), entry };
-}
-
-export async function findFileEntry(
-	repo: Repo,
-	url: AutomergeUrl,
-): Promise<{ handle: DocHandle<UnixFileEntry>; bytes: Uint8Array }> {
-	const handle = await repo.find<UnixFileEntry>(url);
-	const { bytes } = readFileEntry(handle as DocHandle<unknown>);
-	return { handle, bytes };
-}
-
-export function stripHeads(url: AutomergeUrl): AutomergeUrl {
-	const { documentId } = parseAutomergeUrl(url);
-	return stringifyAutomergeUrl({ documentId });
-}
-
-export function pinUrl(handle: DocHandle<unknown>): AutomergeUrl {
-	const { documentId } = parseAutomergeUrl(handle.url);
-	return stringifyAutomergeUrl({ documentId, heads: handle.heads() });
-}
-
-export function normalizeArtifactDir(dir: string): string {
-	let out = dir.replace(/\\/g, "/");
-	while (out.startsWith("./")) out = out.slice(2);
-	while (out.endsWith("/")) out = out.slice(0, -1);
-	return out;
-}
-
-export function isInArtifactDir(
-	posixPath: string,
-	artifactDirs: readonly string[],
-): boolean {
-	for (const d of artifactDirs) {
-		if (!d) continue;
-		if (posixPath === d) return true;
-		if (posixPath.startsWith(d + "/")) return true;
-	}
-	return false;
-}

package/src/shapes/index.ts

@@ -1,19 +0,0 @@
-import { loadCustomShape } from "./custom.js";
-import { patchworkFolderShape } from "./patchwork-folder.js";
-import { vfsShape } from "./vfs.js";
-import type { Shape } from "./types.js";
-
-export type ShapeName = "vfs" | "patchwork-folder" | string;
-
-export const isBuiltinShape = (name: string): boolean =>
-	name === "vfs" || name === "patchwork-folder";
-
-export async function resolveShape(name: ShapeName): Promise<Shape> {
-	if (name === "vfs") return vfsShape;
-	if (name === "patchwork-folder") return patchworkFolderShape;
-	return loadCustomShape(name);
-}
-
-export { vfsShape, patchworkFolderShape };
-export * from "./types.js";
-export * from "./file.js";

package/src/shapes/patchwork-folder.ts

@@ -1,156 +0,0 @@
-import * as path from "path";
-import {
-	isValidAutomergeUrl,
-	type AutomergeUrl,
-	type DocHandle,
-	type Repo,
-} from "@automerge/automerge-repo";
-import { log } from "../log.js";
-import { newDir, type Shape, type VfsNode } from "./types.js";
-
-const dlog = log("shapes:folder");
-
-const META = "@patchwork";
-
-type DocLink = {
-	name: string;
-	type: string;
-	url: AutomergeUrl;
-	icon?: string;
-};
-
-type FolderDoc = {
-	"@patchwork": { type: "folder" };
-	title: string;
-	docs: DocLink[];
-	lastSyncAt?: number;
-};
-
-const isFolderDoc = (doc: unknown): doc is FolderDoc => {
-	if (!doc || typeof doc !== "object") return false;
-	const meta = (doc as Record<string, unknown>)[META];
-	return (
-		!!meta &&
-		typeof meta === "object" &&
-		(meta as Record<string, unknown>).type === "folder"
-	);
-};
-
-const linkFileType = (filename: string): string => {
-	const ext = path.posix.extname(filename).replace(/^\./, "");
-	return ext || "file";
-};
-
-export const patchworkFolderShape: Shape = {
-	async encode({ repo, tree, previousRoot }) {
-		if (tree.kind !== "dir") throw new Error("folder: root must be a dir");
-
-		if (previousRoot) {
-			dlog("encode reusing root=%s", previousRoot.url);
-			const handle = previousRoot as DocHandle<FolderDoc>;
-			await syncFolder(repo, handle, tree);
-			return handle.url;
-		}
-		dlog("encode creating new root");
-		const handle = await createFolder(repo, tree, "pushwork");
-		dlog("encode new root=%s", handle.url);
-		return handle.url;
-	},
-
-	async decode({ repo, root }) {
-		const doc = root.doc();
-		if (!isFolderDoc(doc)) {
-			throw new Error(`expected folder doc at ${root.url}`);
-		}
-		dlog("decode root=%s", root.url);
-		return readFolder(repo, root as DocHandle<FolderDoc>);
-	},
-};
-
-async function createFolder(
-	repo: Repo,
-	tree: VfsNode,
-	title: string,
-): Promise<DocHandle<FolderDoc>> {
-	if (tree.kind !== "dir") throw new Error("createFolder: not a dir");
-	const links: DocLink[] = [];
-	for (const [name, child] of tree.entries) {
-		if (child.kind === "file") {
-			links.push({ name, type: linkFileType(name), url: child.url });
-		} else {
-			const sub = await createFolder(repo, child, name);
-			links.push({ name, type: "folder", url: sub.url });
-		}
-	}
-	const handle = repo.create<FolderDoc>({
-		"@patchwork": { type: "folder" },
-		title,
-		docs: links,
-	});
-	dlog("createFolder title=%s docs=%d url=%s", title, links.length, handle.url);
-	return handle;
-}
-
-async function syncFolder(
-	repo: Repo,
-	handle: DocHandle<FolderDoc>,
-	tree: VfsNode,
-): Promise<void> {
-	if (tree.kind !== "dir") throw new Error("syncFolder: not a dir");
-
-	const desired = new Map<string, VfsNode>(tree.entries);
-	const existingLinks = new Map<string, DocLink>();
-	for (const link of handle.doc().docs) existingLinks.set(link.name, link);
-
-	const nextLinks: DocLink[] = [];
-
-	for (const [name, child] of desired) {
-		const existing = existingLinks.get(name);
-		if (child.kind === "file") {
-			nextLinks.push({ name, type: linkFileType(name), url: child.url });
-			continue;
-		}
-		// child is a dir
-		if (existing && existing.type === "folder") {
-			const subHandle = await repo.find<FolderDoc>(existing.url);
-			if (isFolderDoc(subHandle.doc())) {
-				await syncFolder(repo, subHandle, child);
-				nextLinks.push({ name, type: "folder", url: subHandle.url });
-				continue;
-			}
-		}
-		const sub = await createFolder(repo, child, name);
-		nextLinks.push({ name, type: "folder", url: sub.url });
-	}
-
-	handle.change((d: FolderDoc) => {
-		if (!d["@patchwork"]) d["@patchwork"] = { type: "folder" };
-		if (typeof d.title !== "string") d.title = "pushwork";
-		d.docs = nextLinks;
-	});
-}
-
-async function readFolder(
-	repo: Repo,
-	handle: DocHandle<FolderDoc>,
-): Promise<VfsNode> {
-	const doc = handle.doc();
-	const tree: VfsNode = newDir();
-	if (!doc?.docs) return tree;
-	for (const link of doc.docs) {
-		if (!link?.name) continue;
-		if (!isValidAutomergeUrl(link.url)) continue;
-		if (link.type === "folder") {
-			const sub = await repo.find<FolderDoc>(link.url);
-			if (isFolderDoc(sub.doc())) {
-				const subTree = await readFolder(repo, sub);
-				if (tree.kind === "dir") tree.entries.set(link.name, subTree);
-			}
-		} else {
-			if (tree.kind === "dir") {
-				tree.entries.set(link.name, { kind: "file", url: link.url });
-			}
-		}
-	}
-	return tree;
-}

package/src/shapes/types.ts

@@ -1,79 +0,0 @@
-import type {
-	AutomergeUrl,
-	DocHandle,
-	ImmutableString,
-	Repo,
-} from "@automerge/automerge-repo";
-
-export type VfsNode =
-	| { kind: "dir"; entries: Map<string, VfsNode> }
-	| { kind: "file"; url: AutomergeUrl };
-
-export type UnixFileEntry = {
-	"@patchwork": { type: "file" };
-	content: string | Uint8Array | ImmutableString;
-	extension: string;
-	mimeType: string;
-	name: string;
-};
-
-export interface Shape {
-	encode(args: {
-		repo: Repo;
-		tree: VfsNode;
-		previousRoot?: DocHandle<unknown>;
-	}): Promise<AutomergeUrl>;
-	decode(args: {
-		repo: Repo;
-		root: DocHandle<unknown>;
-	}): Promise<VfsNode>;
-}
-
-export const newDir = (): VfsNode => ({ kind: "dir", entries: new Map() });
-
-export function* walkLeaves(
-	node: VfsNode,
-	prefix: string[] = [],
-): Generator<{ path: string[]; url: AutomergeUrl }> {
-	if (node.kind === "file") {
-		yield { path: prefix, url: node.url };
-		return;
-	}
-	for (const [name, child] of node.entries) {
-		yield* walkLeaves(child, [...prefix, name]);
-	}
-}
-
-export function flattenLeaves(node: VfsNode): Map<string, AutomergeUrl> {
-	const out = new Map<string, AutomergeUrl>();
-	for (const { path, url } of walkLeaves(node)) out.set(path.join("/"), url);
-	return out;
-}
-
-export function ensureDirAt(root: VfsNode, segments: string[]): VfsNode {
-	if (root.kind !== "dir") throw new Error("ensureDirAt: root must be a dir");
-	let current: VfsNode = root;
-	for (const seg of segments) {
-		if (current.kind !== "dir") throw new Error(`not a dir: ${seg}`);
-		const existing = current.entries.get(seg);
-		if (existing && existing.kind === "dir") {
-			current = existing;
-		} else {
-			const fresh = newDir();
-			current.entries.set(seg, fresh);
-			current = fresh;
-		}
-	}
-	return current;
-}
-
-export function setFileAt(
-	root: VfsNode,
-	path: string[],
-	url: AutomergeUrl,
-): void {
-	if (path.length === 0) throw new Error("setFileAt: empty path");
-	const parent = ensureDirAt(root, path.slice(0, -1));
-	if (parent.kind !== "dir") throw new Error("setFileAt: parent not a dir");
-	parent.entries.set(path[path.length - 1], { kind: "file", url });
-}

package/src/shapes/vfs.ts

@@ -1,93 +0,0 @@
-import {
-	isValidAutomergeUrl,
-	type AutomergeUrl,
-	type DocHandle,
-} from "@automerge/automerge-repo";
-import { log } from "../log.js";
-import { flattenLeaves, newDir, type Shape, type VfsNode } from "./types.js";
-
-const dlog = log("shapes:vfs");
-
-const META = "@patchwork";
-
-type DirectoryDoc = {
-	"@patchwork": { type: "directory" };
-	lastSyncAt?: number;
-	[key: string]: unknown;
-};
-
-const isDirectoryDoc = (doc: unknown): doc is DirectoryDoc => {
-	if (!doc || typeof doc !== "object") return false;
-	const meta = (doc as Record<string, unknown>)[META];
-	return (
-		!!meta &&
-		typeof meta === "object" &&
-		(meta as Record<string, unknown>).type === "directory"
-	);
-};
-
-const RESERVED = new Set([META, "lastSyncAt"]);
-
-export const vfsShape: Shape = {
-	async encode({ repo, tree, previousRoot }) {
-		if (tree.kind !== "dir") throw new Error("vfs: root must be a dir");
-		const flat = flattenLeaves(tree);
-		dlog("encode keys=%d previousRoot=%s", flat.size, previousRoot?.url ?? "<new>");
-
-		const handle = (previousRoot as DocHandle<DirectoryDoc> | undefined) ??
-			repo.create<DirectoryDoc>({ "@patchwork": { type: "directory" } });
-
-		handle.change((d: DirectoryDoc) => {
-			if (!d["@patchwork"]) d["@patchwork"] = { type: "directory" };
-			for (const k of Object.keys(d)) {
-				if (RESERVED.has(k)) continue;
-				if (!flat.has(k)) delete d[k];
-			}
-			for (const [k, url] of flat) {
-				d[k] = url;
-			}
-		});
-
-		dlog("encode complete url=%s", handle.url);
-		return handle.url;
-	},
-
-	async decode({ root }) {
-		const doc = root.doc();
-		if (!isDirectoryDoc(doc)) {
-			throw new Error(`expected directory doc at ${root.url}`);
-		}
-		const tree: VfsNode = newDir();
-		let count = 0;
-		for (const [key, value] of Object.entries(doc)) {
-			if (RESERVED.has(key)) continue;
-			if (typeof value !== "string") continue;
-			if (!isValidAutomergeUrl(value)) continue;
-			const segments = key.split("/").filter(Boolean);
-			if (segments.length === 0) continue;
-			setLeaf(tree, segments, value as AutomergeUrl);
-			count++;
-		}
-		dlog("decode url=%s leaves=%d", root.url, count);
-		return tree;
-	},
-};
-
-function setLeaf(root: VfsNode, segments: string[], url: AutomergeUrl): void {
-	if (root.kind !== "dir") throw new Error("setLeaf: root must be a dir");
-	let cur: VfsNode = root;
-	for (let i = 0; i < segments.length - 1; i++) {
-		if (cur.kind !== "dir") return;
-		const name = segments[i];
-		const existing = cur.entries.get(name);
-		if (existing && existing.kind === "dir") {
-			cur = existing;
-		} else {
-			const fresh = newDir();
-			cur.entries.set(name, fresh);
-			cur = fresh;
-		}
-	}
-	if (cur.kind !== "dir") return;
-	cur.entries.set(segments[segments.length - 1], { kind: "file", url });
-}

package/src/stash.ts

@@ -1,106 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { log } from "./log.js";
-
-const dlog = log("stash");
-
-export type StashKind = "modified" | "added" | "deleted";
-
-export interface StashEntry {
-	path: string;
-	kind: StashKind;
-	contentBase64?: string; // omitted for deleted
-}
-
-export interface Stash {
-	id: number;
-	name?: string;
-	branch: string | null;
-	createdAt: number;
-	entries: StashEntry[];
-}
-
-const SNARF_DIR = path.join(".pushwork", "snarf");
-const SNARF_INDEX = path.join(SNARF_DIR, "index.json");
-
-async function readStashes(root: string): Promise<Stash[]> {
-	try {
-		const text = await fs.readFile(path.join(root, SNARF_INDEX), "utf8");
-		const parsed = JSON.parse(text) as Stash[];
-		if (!Array.isArray(parsed)) return [];
-		return parsed;
-	} catch (err) {
-		if ((err as NodeJS.ErrnoException).code === "ENOENT") return [];
-		throw err;
-	}
-}
-
-async function writeStashes(root: string, stashes: Stash[]): Promise<void> {
-	await fs.mkdir(path.join(root, SNARF_DIR), { recursive: true });
-	await fs.writeFile(
-		path.join(root, SNARF_INDEX),
-		JSON.stringify(stashes, null, 2) + "\n",
-	);
-}
-
-function nextId(stashes: Stash[]): number {
-	let max = 0;
-	for (const s of stashes) if (s.id > max) max = s.id;
-	return max + 1;
-}
-
-export async function listStashes(root: string): Promise<Stash[]> {
-	const stashes = await readStashes(root);
-	stashes.sort((a, b) => b.id - a.id); // newest first
-	return stashes;
-}
-
-export async function appendStash(
-	root: string,
-	args: { name?: string; branch: string | null; entries: StashEntry[] },
-): Promise<Stash> {
-	const stashes = await readStashes(root);
-	const id = nextId(stashes);
-	const stash: Stash = {
-		id,
-		name: args.name,
-		branch: args.branch,
-		createdAt: Date.now(),
-		entries: args.entries,
-	};
-	stashes.push(stash);
-	await writeStashes(root, stashes);
-	dlog("appendStash id=%d name=%s entries=%d", id, args.name ?? "(unnamed)", args.entries.length);
-	return stash;
-}
-
-export async function takeStash(
-	root: string,
-	selector?: string,
-): Promise<Stash | null> {
-	const stashes = await readStashes(root);
-	if (stashes.length === 0) return null;
-	let idx: number;
-	if (!selector) {
-		// most recent
-		idx = stashes.reduce((best, s, i) => (s.id > stashes[best].id ? i : best), 0);
-	} else {
-		const asInt = Number(selector);
-		idx = stashes.findIndex((s) =>
-			(!Number.isNaN(asInt) && s.id === asInt) || s.name === selector,
-		);
-		if (idx < 0) return null;
-	}
-	const [taken] = stashes.splice(idx, 1);
-	await writeStashes(root, stashes);
-	dlog("takeStash id=%d name=%s", taken.id, taken.name ?? "(unnamed)");
-	return taken;
-}
-
-export function encodeBytes(bytes: Uint8Array): string {
-	return Buffer.from(bytes).toString("base64");
-}
-
-export function decodeBytes(b64: string): Uint8Array {
-	return new Uint8Array(Buffer.from(b64, "base64"));
-}