@1agh/maude 0.60.7 → 1.0.3

package/apps/studio/test/sync-asset-pull.test.ts

@@ -1,161 +0,0 @@
-// The downward asset lane — see sync/asset-pull.ts.
-//
-// Regression cover for the reported "obrázky v annotations se nevykreslí":
-// `<slug>.annotations.svg` synced, its `assets/<sha8>.png` did not, and the
-// canvas rendered a broken-image glyph on every peer but the one that made it.
-
-import { describe, expect, test } from 'bun:test';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-
-import { pullAssets, referencedAssets } from '../sync/asset-pull.ts';
-
-function project(files: Record<string, string>): string {
-  const root = mkdtempSync(path.join(tmpdir(), 'maude-asset-pull-'));
-  for (const [rel, body] of Object.entries(files)) {
-    const abs = path.join(root, rel);
-    mkdirSync(path.dirname(abs), { recursive: true });
-    writeFileSync(abs, body);
-  }
-  return root;
-}
-
-const annotation = (name: string) =>
-  `<svg xmlns="http://www.w3.org/2000/svg"><image data-tool="image" href="assets/${name}"/></svg>`;
-
-/** A hub that serves every asset as three bytes. */
-const servingFetch = (seen: string[] = []) =>
-  (async (url: string) => {
-    seen.push(String(url));
-    return new Response(new Uint8Array([1, 2, 3]), { status: 200 });
-  }) as unknown as typeof fetch;
-
-describe('referencedAssets', () => {
-  test('finds the image an annotation references', () => {
-    const root = project({ 'ui-board.annotations.svg': annotation('c0fa9c7f.png') });
-    expect(referencedAssets(root)).toEqual(['c0fa9c7f.png']);
-  });
-
-  test('reads canvas bodies and sidecars too, deduplicating', () => {
-    const root = project({
-      'ui-board.annotations.svg': annotation('a.png'),
-      'ui/card.tsx': `<img src="assets/b.jpg" /><img src="assets/a.png" />`,
-      'ui/card.css': `.x { background: url(assets/c.webp) }`,
-    });
-    expect(referencedAssets(root)).toEqual(['a.png', 'b.jpg', 'c.webp']);
-  });
-
-  test('refuses a reference that could place a file outside assets/', () => {
-    // An annotation can itself have arrived from the hub, so a name found in
-    // one is untrusted input.
-    const root = project({
-      'ui-board.annotations.svg': [
-        '<svg>',
-        '<image href="assets/../../etc/passwd"/>',
-        '<image href="assets/ok.png"/>',
-        '</svg>',
-      ].join(''),
-    });
-    expect(referencedAssets(root)).toEqual(['ok.png']);
-  });
-
-  test('refuses an extension outside the asset allowlist', () => {
-    const root = project({
-      'ui/card.tsx': `"assets/payload.sh" "assets/x.tsx" "assets/real.png"`,
-    });
-    expect(referencedAssets(root)).toEqual(['real.png']);
-  });
-
-  test('ignores runtime directories — a trashed canvas wants nothing', () => {
-    const root = project({
-      '_trash/old-deleted-1/old.annotations.svg': annotation('ghost.png'),
-      '_history/ui-board/1.tsx': `"assets/older.png"`,
-      'ui-board.annotations.svg': annotation('live.png'),
-    });
-    expect(referencedAssets(root)).toEqual(['live.png']);
-  });
-});
-
-describe('pullAssets', () => {
-  const opts = (root: string, fetchImpl: typeof fetch) => ({
-    designRoot: root,
-    hubUrl: 'https://hub.example/',
-    token: () => 'tok',
-    fetchImpl,
-    log: { log: () => {}, warn: () => {} },
-  });
-
-  test('fetches a referenced asset this machine does not have', async () => {
-    const root = project({ 'ui-board.annotations.svg': annotation('c0fa9c7f.png') });
-    const seen: string[] = [];
-    const res = await pullAssets(opts(root, servingFetch(seen)));
-
-    expect(res.pulled).toEqual(['c0fa9c7f.png']);
-    expect(seen).toEqual(['https://hub.example/assets/c0fa9c7f.png']);
-    expect(readFileSync(path.join(root, 'assets/c0fa9c7f.png'))).toEqual(Buffer.from([1, 2, 3]));
-  });
-
-  test('asks for nothing when every reference is already on disk', async () => {
-    const root = project({
-      'ui-board.annotations.svg': annotation('have.png'),
-      'assets/have.png': 'bytes',
-    });
-    let called = 0;
-    const counting = (async () => {
-      called += 1;
-      return new Response('x', { status: 200 });
-    }) as unknown as typeof fetch;
-
-    const res = await pullAssets(opts(root, counting));
-    expect(called).toBe(0);
-    expect(res.present).toBe(1);
-    expect(res.pulled).toEqual([]);
-  });
-
-  test('is idempotent — a second pass costs no requests', async () => {
-    const root = project({ 'ui-board.annotations.svg': annotation('x.png') });
-    await pullAssets(opts(root, servingFetch()));
-    const seen: string[] = [];
-    const second = await pullAssets(opts(root, servingFetch(seen)));
-    expect(seen).toEqual([]);
-    expect(second.pulled).toEqual([]);
-  });
-
-  test('a 404 is recorded and retried, never fatal', async () => {
-    // Ordinary: the peer that owns the bytes has not pushed them yet.
-    const root = project({ 'ui-board.annotations.svg': annotation('later.png') });
-    const missing = (async () => new Response('nope', { status: 404 })) as unknown as typeof fetch;
-    const res = await pullAssets(opts(root, missing));
-    expect(res.pulled).toEqual([]);
-    expect(res.failed).toEqual([{ name: 'later.png', reason: 'HTTP 404' }]);
-    expect(existsSync(path.join(root, 'assets/later.png'))).toBe(false);
-  });
-
-  test('a throwing hub is not fatal either', async () => {
-    const root = project({ 'ui-board.annotations.svg': annotation('x.png') });
-    const boom = (async () => {
-      throw new Error('offline');
-    }) as unknown as typeof fetch;
-    const res = await pullAssets(opts(root, boom));
-    expect(res.pulled).toEqual([]);
-    expect(res.failed[0]?.reason).toBe('offline');
-  });
-
-  test('refuses an empty body rather than writing a zero-byte image', async () => {
-    const root = project({ 'ui-board.annotations.svg': annotation('x.png') });
-    const empty = (async () =>
-      new Response(new Uint8Array([]), { status: 200 })) as unknown as typeof fetch;
-    const res = await pullAssets(opts(root, empty));
-    expect(res.pulled).toEqual([]);
-    expect(existsSync(path.join(root, 'assets/x.png'))).toBe(false);
-  });
-
-  test('leaves no .part file behind on success', async () => {
-    // The write is temp-then-rename so the dev server serving this very path
-    // never reads a half-written image.
-    const root = project({ 'ui-board.annotations.svg': annotation('x.png') });
-    await pullAssets(opts(root, servingFetch()));
-    expect(existsSync(path.join(root, 'assets/x.png.part'))).toBe(false);
-  });
-});

package/apps/studio/test/sync-asset-push-worker.test.ts

@@ -1,183 +0,0 @@
-// The out-of-process asset sweep — the CHILD's half of the contract.
-//
-// These spawn the real worker against a real (local) hub, because the two
-// properties that matter here cannot be observed from inside the process that
-// would otherwise mock them: what actually reaches stdout, and what actually
-// reaches the wire's Authorization header. The parent's half (line parsing,
-// crash translation, cancel) is `sync-asset-sweep.test.ts`.
-
-import { describe, expect, test } from 'bun:test';
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-const WORKER = join(import.meta.dir, '..', 'sync', 'asset-push-worker.ts');
-
-/** A design root holding `n` DS assets — the class that pushes to `/_asset-file/`. */
-function projectWith(n: number): string {
-  const root = mkdtempSync(join(tmpdir(), 'sweep-worker-'));
-  mkdirSync(join(root, 'system/ds/assets/logos'), { recursive: true });
-  for (let i = 0; i < n; i++) {
-    writeFileSync(join(root, `system/ds/assets/logos/mark-${i}.svg`), `<svg>${i}</svg>`);
-  }
-  return root;
-}
-
-/**
- * A hub that accepts everything, records every Authorization it saw, and lets a
- * test react to a request (that is how the renewal case rewrites the token file
- * mid-sweep).
- */
-function hub(onRequest?: (req: Request, seen: number) => void) {
-  const auths: string[] = [];
-  let seen = 0;
-  const server = Bun.serve({
-    port: 0,
-    async fetch(req) {
-      const url = new URL(req.url);
-      auths.push(req.headers.get('authorization') ?? '');
-      onRequest?.(req, seen++);
-      // No batch probe here — answering 404 sends the sweep down the
-      // per-file HEAD path, which is the wider of the two code paths.
-      if (url.pathname === '/_asset-probe') return new Response('nope', { status: 404 });
-      if (req.method === 'HEAD') return new Response(null, { status: 404 });
-      await req.arrayBuffer(); // drain, or the socket desynchronizes
-      return new Response('ok', { status: 200 });
-    },
-  });
-  return {
-    url: `http://127.0.0.1:${server.port}`,
-    auths,
-    stop: () => server.stop(true),
-  };
-}
-
-/** Run the worker to completion; return its stdout lines, stderr and exit code. */
-async function run(args: string[]): Promise<{
-  lines: { t: string; [k: string]: unknown }[];
-  raw: string;
-  stderr: string;
-  code: number | null;
-}> {
-  const child = Bun.spawn([process.execPath, WORKER, ...args], {
-    stdin: 'ignore',
-    stdout: 'pipe',
-    stderr: 'pipe',
-  });
-  const [raw, stderr] = await Promise.all([
-    new Response(child.stdout).text(),
-    new Response(child.stderr).text(),
-  ]);
-  await child.exited;
-  const lines = raw
-    .split('\n')
-    .filter((l) => l.trim())
-    .map((l) => JSON.parse(l));
-  return { lines, raw, stderr, code: child.exitCode };
-}
-
-describe('the worker speaks NDJSON and nothing else', () => {
-  test('progress lines, then exactly one result line, then a clean exit', async () => {
-    const root = projectWith(3);
-    const h = hub();
-    const tokenFile = join(root, 'tok');
-    writeFileSync(tokenFile, 'secret-a', { mode: 0o600 });
-    try {
-      const { lines, raw, code } = await run([root, h.url, tokenFile]);
-
-      expect(code).toBe(0);
-      // Every line parsed — nothing unstructured reached stdout.
-      expect(raw.trimEnd().split('\n').length).toBe(lines.length);
-      const results = lines.filter((l) => l.t === 'result');
-      expect(results.length).toBe(1);
-      expect(lines.filter((l) => l.t === 'progress').length).toBeGreaterThan(0);
-      // …and the result is the LAST thing said.
-      expect(lines[lines.length - 1].t).toBe('result');
-      expect(results[0].pushed).toEqual([
-        'system/ds/assets/logos/mark-0.svg',
-        'system/ds/assets/logos/mark-1.svg',
-        'system/ds/assets/logos/mark-2.svg',
-      ]);
-      expect(results[0].failed).toEqual([]);
-    } finally {
-      h.stop();
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  test('the final progress line is `finished`, so a parent never waits forever', async () => {
-    const root = projectWith(1);
-    const h = hub();
-    const tokenFile = join(root, 'tok');
-    writeFileSync(tokenFile, 'secret-a', { mode: 0o600 });
-    try {
-      const { lines } = await run([root, h.url, tokenFile]);
-      const progress = lines.filter((l) => l.t === 'progress');
-      expect(progress[progress.length - 1].finished).toBe(true);
-    } finally {
-      h.stop();
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-});
-
-describe('the credential travels in a file, not on the command line', () => {
-  test('the token reaching the hub is the FILE contents', async () => {
-    const root = projectWith(1);
-    const h = hub();
-    const tokenFile = join(root, 'tok');
-    writeFileSync(tokenFile, 'secret-from-file\n', { mode: 0o600 });
-    try {
-      await run([root, h.url, tokenFile]);
-      // Trimmed — a file written with a trailing newline must not send one.
-      expect(h.auths).toContain('Bearer secret-from-file');
-      expect(h.auths.every((a) => a === 'Bearer secret-from-file')).toBe(true);
-    } finally {
-      h.stop();
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  test('a token rewritten mid-sweep is picked up (silent renewal keeps working)', async () => {
-    const root = projectWith(4);
-    const tokenFile = join(root, 'tok');
-    writeFileSync(tokenFile, 'old', { mode: 0o600 });
-    // Rotate after the hub has answered a couple of requests — exactly what
-    // `scheduleRenewal` does to the parent's in-memory token today.
-    const h = hub((_req, seen) => {
-      if (seen === 2) writeFileSync(tokenFile, 'new', { mode: 0o600 });
-    });
-    try {
-      await run([root, h.url, tokenFile]);
-      expect(h.auths).toContain('Bearer old');
-      expect(h.auths).toContain('Bearer new');
-    } finally {
-      h.stop();
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-});
-
-describe('the worker refuses what it cannot do', () => {
-  test('missing arguments is exit 2 and a structured error, not a stack trace', async () => {
-    const { lines, code } = await run([]);
-    expect(code).toBe(2);
-    expect(lines[0].t).toBe('error');
-    expect(String(lines[0].message)).toContain('usage:');
-  });
-
-  test('an unreachable hub is a finished sweep with failures — never a hang', async () => {
-    const root = projectWith(1);
-    const tokenFile = join(root, 'tok');
-    writeFileSync(tokenFile, 'secret-a', { mode: 0o600 });
-    try {
-      // Port 1 is not listening; the sweep must still terminate and report.
-      const { lines, code } = await run([root, 'http://127.0.0.1:1', tokenFile]);
-      expect(code).toBe(0);
-      const result = lines.find((l) => l.t === 'result') as { failed: unknown[] } | undefined;
-      expect(result?.failed.length).toBe(1);
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-});

package/apps/studio/test/sync-asset-sweep.test.ts

@@ -1,243 +0,0 @@
-// The PARENT half of the out-of-process asset sweep.
-//
-// The child's own contract is `sync-asset-push-worker.test.ts`; here the child
-// is a stand-in script, because what needs pinning is the parent's behaviour
-// when that child misbehaves — and a real sweep cannot be made to segfault on
-// demand. Every case below is a way the sweep can end, and the property under
-// test is the same one each time: the parent always produces a FINAL emit, so
-// the panel can never sit at "92 of 182" forever.
-
-import { describe, expect, test } from 'bun:test';
-import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import type { AssetPushProgress } from '../sync/asset-push.ts';
-import { assetWorkerScript, runAssetSweep } from '../sync/asset-sweep.ts';
-
-const dirs: string[] = [];
-
-/** Write a stand-in child and return its path. */
-function fakeChild(body: string): string {
-  const dir = mkdtempSync(join(tmpdir(), 'sweep-parent-'));
-  dirs.push(dir);
-  const p = join(dir, 'child.ts');
-  writeFileSync(p, body);
-  return p;
-}
-
-function progressLine(over: Partial<AssetPushProgress> = {}): string {
-  const base = {
-    t: 'progress',
-    total: 3,
-    done: 1,
-    pushed: 1,
-    skipped: 0,
-    failedCount: 0,
-    failures: [],
-    active: 'system/ds/assets/logos/a.svg',
-    finished: false,
-  };
-  return JSON.stringify({ ...base, ...over });
-}
-
-function sweep(script: string, onProgress: (p: AssetPushProgress) => void) {
-  const designRoot = mkdtempSync(join(tmpdir(), 'sweep-root-'));
-  dirs.push(designRoot);
-  return runAssetSweep({
-    designRoot,
-    hubUrl: 'https://hub.example',
-    token: () => 'secret-token',
-    onProgress,
-    script,
-    log: { log: () => {}, warn: () => {} },
-  });
-}
-
-describe('a sweep that finishes', () => {
-  test('progress reaches the panel and the result comes back', async () => {
-    const seen: AssetPushProgress[] = [];
-    const child = fakeChild(`
-      process.stdout.write(${JSON.stringify(`${progressLine()}\n`)});
-      process.stdout.write(${JSON.stringify(`${progressLine({ done: 3, pushed: 3, active: null, finished: true })}\n`)});
-      process.stdout.write(JSON.stringify({ t: 'result', pushed: ['a', 'b', 'c'], skipped: 0, failed: [] }) + '\\n');
-    `);
-    const result = await sweep(child, (p) => seen.push(p)).done;
-
-    expect(result).toEqual({ pushed: ['a', 'b', 'c'], skipped: 0, failed: [] });
-    expect(seen.length).toBe(2);
-    expect(seen[1].finished).toBe(true);
-  });
-
-  test('unparseable output is dropped, not fatal', async () => {
-    const seen: AssetPushProgress[] = [];
-    const child = fakeChild(`
-      process.stdout.write('a stray console.log from an import\\n');
-      process.stdout.write(${JSON.stringify(`${progressLine()}\n`)});
-      process.stdout.write('{ half a li');
-      process.stdout.write('ne }\\n');
-      process.stdout.write(JSON.stringify({ t: 'result', pushed: [], skipped: 1, failed: [] }) + '\\n');
-    `);
-    const result = await sweep(child, (p) => seen.push(p)).done;
-
-    expect(result).toEqual({ pushed: [], skipped: 1, failed: [] });
-    expect(seen.length).toBe(1);
-  });
-});
-
-describe('a sweep that dies is a REPORTED failure, never a stall', () => {
-  test('a signalled child names the signal in the final emit', async () => {
-    const seen: AssetPushProgress[] = [];
-    const child = fakeChild(`
-      process.stdout.write(${JSON.stringify(`${progressLine({ done: 92, total: 182, pushed: 92 })}\n`)});
-      await Bun.sleep(20);
-      process.kill(process.pid, 'SIGKILL');
-      await new Promise(() => {});
-    `);
-    const result = await sweep(child, (p) => seen.push(p)).done;
-
-    expect(result).toBeNull();
-    const final = seen[seen.length - 1];
-    expect(final.finished).toBe(true);
-    // The counts it got to are KEPT — the person is told where it stopped.
-    expect(final.done).toBe(92);
-    expect(final.total).toBe(182);
-    expect(final.failedCount).toBe(1);
-    expect(final.failures[0].reason).toContain('SIGKILL');
-    expect(final.active).toBeNull();
-  });
-
-  test('a child that reports an error carries the message through', async () => {
-    const seen: AssetPushProgress[] = [];
-    const child = fakeChild(`
-      process.stdout.write(JSON.stringify({ t: 'error', message: 'the design root vanished' }) + '\\n');
-      process.exit(1);
-    `);
-    const result = await sweep(child, (p) => seen.push(p)).done;
-
-    expect(result).toBeNull();
-    expect(seen[seen.length - 1].failures[0].reason).toContain('the design root vanished');
-  });
-
-  test('a missing worker script is reported — never a silent in-process fallback', async () => {
-    const seen: AssetPushProgress[] = [];
-    const result = await sweep(join(tmpdir(), 'no-such-worker-xyz.ts'), (p) => seen.push(p)).done;
-
-    expect(result).toBeNull();
-    expect(seen.length).toBe(1);
-    expect(seen[0].finished).toBe(true);
-    expect(seen[0].failedCount).toBe(1);
-  });
-
-  test('a result line with a non-zero exit is NOT trusted as success', async () => {
-    const seen: AssetPushProgress[] = [];
-    const child = fakeChild(`
-      process.stdout.write(JSON.stringify({ t: 'result', pushed: ['a'], skipped: 0, failed: [] }) + '\\n');
-      process.exit(3);
-    `);
-    const result = await sweep(child, (p) => seen.push(p)).done;
-
-    expect(result).toBeNull();
-    expect(seen[seen.length - 1].failures[0].reason).toContain('3');
-  });
-});
-
-describe('cancel ends the sweep, and says that is what happened', () => {
-  test('a wedged child is killed and the lane closes as cancelled', async () => {
-    const seen: AssetPushProgress[] = [];
-    const child = fakeChild(`
-      process.stdout.write(${JSON.stringify(`${progressLine()}\n`)});
-      await new Promise(() => {});
-    `);
-    const handle = sweep(child, (p) => seen.push(p));
-    // Wait for the first emit so the child is definitely alive — BOUNDED, so a
-    // machine that cannot spawn fails this test instead of hanging the suite.
-    for (let i = 0; seen.length === 0 && i < 500; i++) await Bun.sleep(10);
-    expect(seen.length).toBeGreaterThan(0);
-    handle.cancel();
-    const result = await handle.done;
-
-    expect(result).toBeNull();
-    const final = seen[seen.length - 1];
-    expect(final.finished).toBe(true);
-    expect(final.failures[0].reason).toBe('cancelled');
-  });
-
-  test('cancel is idempotent and safe after the sweep already ended', async () => {
-    const child = fakeChild(
-      `process.stdout.write(JSON.stringify({ t: 'result', pushed: [], skipped: 0, failed: [] }) + '\\n');`
-    );
-    const handle = sweep(child, () => {});
-    await handle.done;
-    expect(() => {
-      handle.cancel();
-      handle.cancel();
-    }).not.toThrow();
-  });
-});
-
-describe('the credential never touches argv', () => {
-  test('the token goes to a 0600 file that is gone when the sweep ends', async () => {
-    let sawArgv = '';
-    let sawToken = '';
-    let sawMode = '';
-    const child = fakeChild(`
-      const { readFileSync, statSync } = await import('node:fs');
-      const tokenFile = process.argv[4];
-      process.stdout.write(JSON.stringify({
-        t: 'result', pushed: [], skipped: 0,
-        failed: [
-          { key: 'argv', reason: process.argv.slice(2).join(' ') },
-          { key: 'token', reason: readFileSync(tokenFile, 'utf8') },
-          { key: 'mode', reason: (statSync(tokenFile).mode & 0o777).toString(8) },
-          { key: 'file', reason: tokenFile },
-        ],
-      }) + '\\n');
-    `);
-    const result = await sweep(child, () => {});
-    const failed = (await result.done)?.failed ?? [];
-    sawArgv = failed.find((f) => f.key === 'argv')?.reason ?? '';
-    sawToken = failed.find((f) => f.key === 'token')?.reason ?? '';
-    sawMode = failed.find((f) => f.key === 'mode')?.reason ?? '';
-    const tokenFile = failed.find((f) => f.key === 'file')?.reason ?? '';
-
-    expect(sawToken).toBe('secret-token');
-    // `ps` shows argv to every user on the machine.
-    expect(sawArgv).not.toContain('secret-token');
-    expect(sawMode).toBe('600');
-    expect(existsSync(tokenFile)).toBe(false);
-  });
-});
-
-describe('the credential stays current across the boundary', () => {
-  test('the token file is written atomically — the child can never read half of it', async () => {
-    // The child re-reads this file per request; a plain overwrite is observable
-    // half-done, and half a bearer token is a 401 on every remaining upload.
-    const src = readFileSync(join(import.meta.dir, '..', 'sync', 'asset-sweep.ts'), 'utf8');
-    expect(src).toContain('renameSync(tmp, tokenFile)');
-    // And the parent keeps it current: a renewal mid-sweep must reach the child,
-    // which is why `token` is a GETTER and not the string it resolved to.
-    expect(src).toMatch(/token: \(\) => string/);
-    expect(src).toMatch(/setInterval\(/);
-  });
-});
-
-describe('the worker ships where the server can find it', () => {
-  test('the resolved script is a real file on disk (DDR-045, not a bunfs path)', () => {
-    const script = assetWorkerScript();
-    expect(script.endsWith(join('sync', 'asset-push-worker.ts'))).toBe(true);
-    expect(existsSync(script)).toBe(true);
-  });
-});
-
-// Temp roots outlive individual tests (the token-file case reads one back), so
-// they are swept once at the end rather than per-test.
-process.on('exit', () => {
-  for (const d of dirs) {
-    try {
-      if (existsSync(d) && readdirSync(d)) rmSync(d, { recursive: true, force: true });
-    } catch {
-      /* best-effort */
-    }
-  }
-});