@1agh/maude 1.0.9 → 1.2.0

package/apps/studio/test/sync-supervisor.test.ts

@@ -1,262 +0,0 @@
-// The sync supervisor — the piece that makes "Connect" mean "syncing", not
-// "now go restart something".
-//
-// The runtime itself is injected here (a fake factory): what is under test is
-// the SUPERVISION — that a just-authorized link is adopted in memory and
-// applied by a real stop→start cycle, that two Connects can't interleave, and
-// that a refusal comes back as a sentence a person can act on instead of a
-// silent null.
-
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import * as Y from 'yjs';
-
-import { type Context, createBus, type DevServerConfig } from '../context.ts';
-import type { SyncProvider, SyncRuntime } from '../sync/index.ts';
-import { createSyncSupervisor } from '../sync/supervisor.ts';
-
-let hubsEnv: string | undefined;
-
-beforeEach(() => {
-  hubsEnv = process.env.HUBS_CONFIG_PATH;
-});
-
-afterEach(() => {
-  // Assigning undefined would store the literal string "undefined".
-  if (hubsEnv === undefined) delete process.env.HUBS_CONFIG_PATH;
-  else process.env.HUBS_CONFIG_PATH = hubsEnv;
-});
-
-function makeCtx(linkedHub?: DevServerConfig['linkedHub']): Context {
-  const dir = mkdtempSync(join(tmpdir(), 'sync-supervisor-'));
-  const designRoot = join(dir, '.design');
-  return {
-    cfg: {
-      name: 'test',
-      projectLabel: null,
-      designRoot: '.design',
-      canvasGroups: [{ label: 'Canvases', path: 'ui' }],
-      rootClass: 'app',
-      themeDefault: 'dark',
-      tokensCssRel: 'system/colors.css',
-      teamAccentDefault: null,
-      handoffTargets: [],
-      newCanvasDir: 'ui',
-      newComponentDir: 'ui/components',
-      linkedHub,
-      _source: 'defaults',
-    },
-    projectLabel: 'test',
-    paths: {
-      repoRoot: dir,
-      designRel: '.design',
-      designRoot,
-      serverInfoFile: join(designRoot, '_server.json'),
-      activeFile: join(designRoot, '_active.json'),
-      commentsDir: join(designRoot, '_comments'),
-      canvasStateDir: join(designRoot, '_canvas-state'),
-      historyDir: join(designRoot, '_history'),
-      tokensUrlRel: '.design/system/colors.css',
-      systemDirRel: 'system',
-    },
-    bus: createBus(),
-  };
-}
-
-/** A runtime that records its lifecycle and reports `size` canvases. */
-function fakeRuntime(log: string[], id: string, size = 3): SyncRuntime {
-  return {
-    start: async () => {
-      log.push(`start:${id}`);
-    },
-    stop: async () => {
-      log.push(`stop:${id}`);
-    },
-    adopt: async () => 0,
-    release: async () => 0,
-    rescanNow: async () => {},
-    pullRemoteNow: async () => {},
-    size: () => size,
-    agentFor: () => undefined,
-    status: () => null,
-    cancelAssetSweep: () => false,
-  };
-}
-
-describe('createSyncSupervisor', () => {
-  test('an unlinked project starts nothing and says so in words', async () => {
-    const ctx = makeCtx();
-    const sup = createSyncSupervisor(ctx, {}, () => null);
-    const out = await sup.start();
-    expect(out.syncing).toBe(false);
-    expect(out.reason).toBe('unlinked');
-    expect(out.detail).toMatch(/not linked/i);
-    expect(sup.current()).toBeNull();
-    rmSync(ctx.paths.repoRoot, { recursive: true, force: true });
-  });
-
-  test('restart adopts the link it is HANDED and cycles the runtime', async () => {
-    const ctx = makeCtx();
-    const log: string[] = [];
-    let n = 0;
-    const sup = createSyncSupervisor(ctx, {}, (c) =>
-      c.cfg.linkedHub ? fakeRuntime(log, `r${++n}`) : null
-    );
-
-    // Boot unlinked — solo mode, exactly as before.
-    expect((await sup.start()).syncing).toBe(false);
-    expect(log).toEqual([]);
-
-    // The attach lane hands the value it just wrote; the supervisor adopts it
-    // (never re-reading the committed config file) and starts syncing.
-    const link = { url: 'https://hub.example', linkedAt: 1, syncTsx: false };
-    const out = await sup.restart(link);
-    expect(out).toEqual({ syncing: true, canvases: 3 });
-    expect(ctx.cfg.linkedHub).toEqual(link);
-    expect(log).toEqual(['start:r1']);
-
-    // A second Connect tears the first runtime down before opening the next.
-    await sup.restart({ url: 'https://other.example', linkedAt: 2 });
-    expect(log).toEqual(['start:r1', 'stop:r1', 'start:r2']);
-    expect(ctx.cfg.linkedHub?.url).toBe('https://other.example');
-    rmSync(ctx.paths.repoRoot, { recursive: true, force: true });
-  });
-
-  test('two Connects in flight at once do not interleave stop with start', async () => {
-    const ctx = makeCtx({ url: 'https://hub.example', linkedAt: 1 });
-    const log: string[] = [];
-    let n = 0;
-    const sup = createSyncSupervisor(ctx, {}, () => fakeRuntime(log, `r${++n}`));
-    await sup.start();
-    await Promise.all([
-      sup.restart({ url: 'https://a.example', linkedAt: 2 }),
-      sup.restart({ url: 'https://b.example', linkedAt: 3 }),
-    ]);
-    expect(log).toEqual(['start:r1', 'stop:r1', 'start:r2', 'stop:r2', 'start:r3']);
-    rmSync(ctx.paths.repoRoot, { recursive: true, force: true });
-  });
-
-  test('linked but zero syncable canvases is reported, not mistaken for syncing', async () => {
-    const ctx = makeCtx({ url: 'https://hub.example', linkedAt: 1 });
-    const log: string[] = [];
-    const empty: SyncRuntime = {
-      ...fakeRuntime(log, 'empty', 0),
-      status: () => ({ reason: 'no canvases found under .design' }) as never,
-    };
-    const sup = createSyncSupervisor(ctx, {}, () => empty);
-    const out = await sup.start();
-    expect(out.syncing).toBe(false);
-    expect(out.reason).toBe('nothing-syncable');
-    // The runtime already wrote the full explanation into _sync.json — the
-    // panel repeats THAT, so the two can never drift apart.
-    expect(out.detail).toBe('no canvases found under .design');
-    rmSync(ctx.paths.repoRoot, { recursive: true, force: true });
-  });
-
-  test('END TO END with the REAL runtime: an unlinked server starts syncing on Connect', async () => {
-    // No fake runtime here — this is the actual `createSyncRuntime`, reached
-    // exactly as the attach lane reaches it: the server booted solo (no
-    // linkedHub anywhere), and one restart() with the value the cloud endpoint
-    // just wrote turns the project into a syncing one, in place.
-    const ctx = makeCtx();
-    mkdirSync(join(ctx.paths.designRoot, 'ui'), { recursive: true });
-    mkdirSync(ctx.paths.commentsDir, { recursive: true });
-    writeFileSync(join(ctx.paths.designRoot, 'ui', 'home.html'), '<main>home</main>');
-    writeFileSync(join(ctx.paths.designRoot, 'ui', 'pricing.html'), '<main>pricing</main>');
-
-    const url = 'https://hub.example.com';
-    process.env.HUBS_CONFIG_PATH = join(ctx.paths.repoRoot, 'hubs.json');
-    writeFileSync(
-      process.env.HUBS_CONFIG_PATH,
-      JSON.stringify({ hubs: { [url]: { token: 'mau_test', linkedAt: 1 } } })
-    );
-    chmodSync(process.env.HUBS_CONFIG_PATH, 0o600);
-
-    const opened: string[] = [];
-    const providerFactory = (args: { documentName: string; document?: Y.Doc }): SyncProvider => {
-      opened.push(args.documentName);
-      const document = args.document ?? new Y.Doc();
-      return { document, onceSynced: () => Promise.resolve(), destroy: () => {} };
-    };
-
-    const sup = createSyncSupervisor(ctx, { providerFactory });
-    expect((await sup.start()).syncing).toBe(false); // solo — nothing linked yet
-
-    const out = await sup.restart({ url, linkedAt: Date.now() });
-    expect(out).toEqual({ syncing: true, canvases: 2 });
-    expect(opened.sort()).toEqual(['ui-home', 'ui-pricing']);
-    expect(sup.current()).not.toBeNull();
-
-    await sup.stop();
-    rmSync(ctx.paths.repoRoot, { recursive: true, force: true });
-  });
-
-  // feature-sync-resync-and-out-of-process-sweep — `busy()` is what lets the
-  // Resync route answer 409 instead of quietly queueing a second full re-link
-  // of every canvas. It reports the chain; it must never BE the chain.
-  test('busy() reports a cycle in flight and clears when it settles', async () => {
-    const ctx = makeCtx({ url: 'https://hub.example', linkedAt: 1 });
-    let release: () => void = () => {};
-    const held = new Promise<void>((r) => {
-      release = r;
-    });
-    const sup = createSyncSupervisor(ctx, {}, () => ({
-      start: () => held,
-      stop: async () => {},
-      size: () => 1,
-      agentFor: () => undefined,
-      status: () => null,
-      cancelAssetSweep: () => false,
-    }));
-
-    expect(sup.busy()).toBe(false);
-    const cycle = sup.start();
-    expect(sup.busy()).toBe(true);
-    release();
-    await cycle;
-    expect(sup.busy()).toBe(false);
-    rmSync(ctx.paths.repoRoot, { recursive: true, force: true });
-  });
-
-  test('busy() clears after a cycle that THREW — Resync never wedges shut', async () => {
-    const ctx = makeCtx({ url: 'https://hub.example', linkedAt: 1 });
-    const sup = createSyncSupervisor(ctx, {}, () => ({
-      start: async () => {
-        throw new Error('nope');
-      },
-      stop: async () => {},
-      size: () => 0,
-      agentFor: () => undefined,
-      status: () => null,
-      cancelAssetSweep: () => false,
-    }));
-    await sup.start();
-    expect(sup.busy()).toBe(false);
-    rmSync(ctx.paths.repoRoot, { recursive: true, force: true });
-  });
-
-  test('a throwing start leaves the server up and answers with the reason', async () => {
-    const ctx = makeCtx({ url: 'https://hub.example', linkedAt: 1 });
-    const sup = createSyncSupervisor(ctx, {}, () => ({
-      start: async () => {
-        throw new Error('hub refused the handshake');
-      },
-      stop: async () => {},
-      size: () => 0,
-      agentFor: () => undefined,
-      status: () => null,
-      cancelAssetSweep: () => false,
-    }));
-    const out = await sup.start();
-    expect(out.syncing).toBe(false);
-    expect(out.reason).toBe('error');
-    expect(out.detail).toContain('hub refused the handshake');
-    // And the NEXT attach still runs — a failed cycle must not poison the chain.
-    const log: string[] = [];
-    expect((await sup.restart()).syncing).toBe(false);
-    expect(log).toEqual([]);
-    rmSync(ctx.paths.repoRoot, { recursive: true, force: true });
-  });
-});

package/apps/studio/test/sync-tombstone-apply.test.ts

@@ -1,111 +0,0 @@
-// Acting on a deletion the project stated — see sync/tombstone-apply.ts.
-//
-// The rule under test is the one that makes it acceptable for a hub signal to
-// remove local files at all: QUARANTINE, NEVER DELETE.
-
-import { describe, expect, test } from 'bun:test';
-import { existsSync, mkdirSync, mkdtempSync, readdirSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-
-import { quarantineCanvas } from '../sync/tombstone-apply.ts';
-
-function project(lanes: string[]): string {
-  const root = mkdtempSync(path.join(tmpdir(), 'maude-tombstone-'));
-  mkdirSync(path.join(root, 'ui'), { recursive: true });
-  for (const lane of lanes) {
-    const abs = path.join(root, lane);
-    mkdirSync(path.dirname(abs), { recursive: true });
-    writeFileSync(abs, `contents of ${lane}`);
-  }
-  return root;
-}
-
-function lanesFor(root: string) {
-  return {
-    html: path.join(root, 'ui/card.tsx'),
-    meta: path.join(root, 'ui/card.meta.json'),
-    css: path.join(root, 'ui/card.css'),
-    annotations: path.join(root, 'ui-card.annotations.svg'),
-  };
-}
-
-describe('quarantineCanvas', () => {
-  test('moves the canvas out of the tree and into _trash, never deleting it', () => {
-    const root = project([
-      'ui/card.tsx',
-      'ui/card.meta.json',
-      'ui/card.css',
-      'ui-card.annotations.svg',
-    ]);
-    const move = quarantineCanvas({
-      designRoot: root,
-      slug: 'ui-card',
-      lanes: lanesFor(root),
-      now: 1234,
-      log: () => {},
-    });
-
-    expect(move?.trashedTo).toBe('_trash/ui-card-deleted-1234');
-    // Gone from the tree...
-    expect(existsSync(path.join(root, 'ui/card.tsx'))).toBe(false);
-    // ...and recoverable, which is the whole point.
-    const trashed = readdirSync(path.join(root, '_trash/ui-card-deleted-1234')).sort();
-    expect(trashed).toEqual(['card.css', 'card.meta.json', 'card.tsx', 'ui-card.annotations.svg']);
-  });
-
-  test('the annotations sidecar travels with the body', () => {
-    // A body stripped of its annotations is not a restorable canvas — the
-    // sidecar lives at the design root under the flat slug, so it is the one
-    // lane a naive "move the folder" would leave behind.
-    const root = project(['ui/card.tsx', 'ui-card.annotations.svg']);
-    quarantineCanvas({
-      designRoot: root,
-      slug: 'ui-card',
-      lanes: lanesFor(root),
-      now: 1,
-      log: () => {},
-    });
-    expect(existsSync(path.join(root, 'ui-card.annotations.svg'))).toBe(false);
-    expect(existsSync(path.join(root, '_trash/ui-card-deleted-1/ui-card.annotations.svg'))).toBe(
-      true
-    );
-  });
-
-  test('a canvas already gone is a no-op, not an error', () => {
-    // The steady state once both peers have converged: every later poll repeats
-    // the same tombstone and must find nothing to do.
-    const root = project([]);
-    expect(
-      quarantineCanvas({ designRoot: root, slug: 'ui-card', lanes: lanesFor(root), log: () => {} })
-    ).toBeNull();
-    expect(existsSync(path.join(root, '_trash'))).toBe(false);
-  });
-
-  test('moves what it can when a lane is missing', () => {
-    const root = project(['ui/card.tsx']);
-    const move = quarantineCanvas({
-      designRoot: root,
-      slug: 'ui-card',
-      lanes: lanesFor(root),
-      now: 7,
-      log: () => {},
-    });
-    expect(move?.moved).toEqual(['ui/card.tsx']);
-  });
-
-  test('leaves per-machine runtime state alone', () => {
-    // `_history/`, `_comments/` and `_canvas-state/` are per-machine runtime
-    // state (DDR-115). Sweeping them would make a recoverable delete lossy.
-    const root = project(['ui/card.tsx', '_history/ui-card/1.tsx', '_comments/ui-card.json']);
-    quarantineCanvas({
-      designRoot: root,
-      slug: 'ui-card',
-      lanes: lanesFor(root),
-      now: 2,
-      log: () => {},
-    });
-    expect(existsSync(path.join(root, '_history/ui-card/1.tsx'))).toBe(true);
-    expect(existsSync(path.join(root, '_comments/ui-card.json'))).toBe(true);
-  });
-});

package/apps/studio/test/sync-trash.test.ts

@@ -1,132 +0,0 @@
-// feature-before-first-external-users Task 3 (F-6) — `_trash/` scanner,
-// restore, prune. The scanner derives everything from the on-disk shapes the
-// five real writers produce, so each fixture below mirrors one writer.
-
-import { describe, expect, test } from 'bun:test';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { listTrash, pruneTrash, restoreFromTrash } from '../sync/trash.ts';
-
-const DAY = 24 * 60 * 60 * 1000;
-
-function makeRoot(): string {
-  return mkdtempSync(join(tmpdir(), 'maude-trash-'));
-}
-
-function put(root: string, rel: string, body = 'x'): void {
-  const abs = join(root, rel);
-  mkdirSync(join(abs, '..'), { recursive: true });
-  writeFileSync(abs, body);
-}
-
-describe('listTrash — one entry per writer shape', () => {
-  test('empty / absent _trash/ lists nothing', () => {
-    expect(listTrash(makeRoot())).toEqual([]);
-  });
-
-  test('the file plane quarantine (`<stamp>/<rel>`) derives source + park time', () => {
-    const root = makeRoot();
-    put(root, '_trash/2026-08-20T14-11-19-940Z/ui/Hero.tsx', 'body');
-    const [e] = listTrash(root);
-    expect(e.sourceRel).toBe('ui/Hero.tsx');
-    expect(e.reason).toBe('removed');
-    expect(e.at).toBe(Date.parse('2026-08-20T14:11:19.940Z'));
-    expect(e.size).toBe(4);
-  });
-
-  test('an LWW conflict loser (`<rel>-conflict-<ts>`) derives its own path', () => {
-    const root = makeRoot();
-    put(root, '_trash/ui/Hero.tsx-conflict-1755700000000');
-    const [e] = listTrash(root);
-    expect(e.sourceRel).toBe('ui/Hero.tsx');
-    expect(e.reason).toBe('conflict');
-    expect(e.at).toBe(1755700000000);
-  });
-
-  test('moved / deleted / migration shapes are named and dated, source honest-null', () => {
-    const root = makeRoot();
-    put(root, '_trash/2026-08-20T10-00-00-000Z__moved-hero/hero.tsx');
-    put(root, '_trash/hero-deleted-1755700000001/hero.tsx');
-    put(root, '_trash/hero-flat-1755700000002');
-    const entries = listTrash(root);
-    expect(entries.map((e) => e.reason).sort()).toEqual(['deleted', 'migration', 'moved']);
-    for (const e of entries) expect(e.sourceRel).toBeNull();
-  });
-
-  test('an unrecognized shape still lists, as unknown — never invisible', () => {
-    const root = makeRoot();
-    put(root, '_trash/whatever.bin');
-    const [e] = listTrash(root);
-    expect(e.reason).toBe('unknown');
-    expect(e.sourceRel).toBeNull();
-  });
-});
-
-describe('restoreFromTrash', () => {
-  test('moves the file back to its derived source', () => {
-    const root = makeRoot();
-    put(root, '_trash/2026-08-20T14-11-19-940Z/ui/Hero.tsx', 'body');
-    const res = restoreFromTrash(root, '_trash/2026-08-20T14-11-19-940Z/ui/Hero.tsx');
-    expect(res.ok).toBe(true);
-    expect(res.restoredTo).toBe('ui/Hero.tsx');
-    expect(readFileSync(join(root, 'ui/Hero.tsx'), 'utf8')).toBe('body');
-    expect(existsSync(join(root, '_trash/2026-08-20T14-11-19-940Z/ui/Hero.tsx'))).toBe(false);
-  });
-
-  test('never overwrites a newer copy — lands beside it as .restored-<ts>', () => {
-    const root = makeRoot();
-    put(root, 'ui/Hero.tsx', 'NEWER');
-    put(root, '_trash/ui/Hero.tsx-conflict-1755700000000', 'older');
-    const res = restoreFromTrash(root, '_trash/ui/Hero.tsx-conflict-1755700000000');
-    expect(res.ok).toBe(true);
-    expect(res.restoredTo).toMatch(/^ui\/Hero\.tsx\.restored-\d+$/);
-    expect(readFileSync(join(root, 'ui/Hero.tsx'), 'utf8')).toBe('NEWER');
-  });
-
-  test('a shape with no derivable source refuses with guidance, not a guess', () => {
-    const root = makeRoot();
-    put(root, '_trash/hero-deleted-1755700000001/hero.tsx');
-    const res = restoreFromTrash(root, '_trash/hero-deleted-1755700000001/hero.tsx');
-    expect(res.ok).toBe(false);
-    expect(res.detail).toContain('original location is not recorded');
-  });
-
-  test('containment: traversal and non-_trash paths are refused', () => {
-    const root = makeRoot();
-    put(root, '_trash/x-conflict-1755700000000');
-    expect(restoreFromTrash(root, '../outside').ok).toBe(false);
-    expect(restoreFromTrash(root, '_trash/../ui/Hero.tsx').ok).toBe(false);
-    expect(restoreFromTrash(root, 'ui/Hero.tsx').ok).toBe(false);
-  });
-});
-
-describe('pruneTrash', () => {
-  test('removes only entries older than the window, reports both halves', () => {
-    const root = makeRoot();
-    const now = 1755700000000;
-    put(root, `_trash/old.txt-conflict-${now - 40 * DAY}`, '12345');
-    put(root, `_trash/new.txt-conflict-${now - 5 * DAY}`, '123');
-    const res = pruneTrash(root, 30, now);
-    expect(res).toEqual({ pruned: 1, bytes: 5, kept: 1 });
-    expect(listTrash(root)).toHaveLength(1);
-    expect(listTrash(root)[0].sourceRel).toBe('new.txt');
-  });
-
-  test('sweeps directories left empty by the prune', () => {
-    const root = makeRoot();
-    const now = Date.parse('2026-08-20T00:00:00Z');
-    put(root, '_trash/2026-01-01T00-00-00-000Z/ui/Old.tsx');
-    pruneTrash(root, 30, now);
-    expect(existsSync(join(root, '_trash/2026-01-01T00-00-00-000Z'))).toBe(false);
-    expect(existsSync(join(root, '_trash'))).toBe(true); // the root folder stays
-  });
-
-  test('a prune inside the window removes nothing', () => {
-    const root = makeRoot();
-    const now = 1755700000000;
-    put(root, `_trash/keep.txt-conflict-${now - 2 * DAY}`);
-    expect(pruneTrash(root, 30, now)).toEqual({ pruned: 0, bytes: 0, kept: 1 });
-  });
-});