zidane-ui 9.0.4 → 9.1.3

package/src/git/headless/sync.ts

@@ -1,71 +0,0 @@
-/**
- * The git bar's sync chip, React-free: what a click does for a checkout's
- * status, the confirmation's one sentence, and the chip's tooltip.
- *
- *   - The branch has a remote copy: a click syncs (pull, merging, then push).
- *   - No remote copy yet: a click publishes the branch.
- *   - Neither (detached, no remote): the counts, not clickable.
- */
-import type { GitStatus } from './host';
-import type { GitLabels } from './labels';
-
-/** What a click on the sync chip does. */
-export type GitSyncAction = 'sync' | 'publish';
-
-/**
- * What a click does, or `null` when the chip only reports.
- *
- * @param status - The checkout's status.
- */
-export function syncAction(status: GitStatus): GitSyncAction | null {
-  if (status.detached) return null;
-  if (status.upstream) return 'sync';
-  return status.publishRemote ? 'publish' : null;
-}
-
-/**
- * The confirmation's one sentence: what will move, and where.
- *
- * @param status - The checkout's status.
- * @param labels - The git labels.
- */
-export function syncSummary(status: GitStatus, labels: GitLabels): string {
-  if (!status.upstream) return labels.gitPublishSummary(status.branch, status.ahead, status.publishRemote);
-  return labels.gitSyncSummary(status.behind, status.ahead, status.upstream);
-}
-
-/**
- * The chip's tooltip (and accessible name): the counts, then what a click does.
- *
- * @param status - The checkout's status.
- * @param action - {@link syncAction} of it.
- * @param state - The agent is working (`running`), a sync is in flight (`busy`).
- * @param labels - The git labels.
- */
-export function syncTooltip(
-  status: GitStatus,
-  action: GitSyncAction | null,
-  state: { running: boolean; busy: boolean },
-  labels: GitLabels,
-): string {
-  if (state.busy) return action === 'publish' ? labels.gitPublishing : labels.gitSyncing;
-  const counts = status.upstream
-    ? [
-        status.ahead > 0 ? labels.gitToPush(status.ahead) : null,
-        status.behind > 0 ? labels.gitToPull(status.behind) : null,
-      ]
-    : [
-        status.ahead > 0 ? labels.gitCommitsAhead(status.ahead, status.defaultBranch) : null,
-        status.behind > 0 ? labels.gitCommitsBehind(status.behind) : null,
-      ];
-  const facts = counts.filter(Boolean).join(', ') || (status.upstream ? labels.gitUpToDate(status.upstream) : '');
-  if (!action) return facts;
-  const verb = state.running
-    ? action === 'publish'
-      ? labels.gitPublishLater
-      : labels.gitSyncLater
-    : action === 'publish'
-      ? labels.gitPublishTo(status.publishRemote)
-      : labels.gitSyncWith(status.upstream);
-  return facts ? labels.gitFactsThen(facts, verb) : verb;
-}

package/src/git/index.ts

@@ -1,17 +0,0 @@
-/**
- * `zidane-ui/git`: the git area's components. `GitProvider` puts a `GitHost`
- * in context; `BranchMenu` switches branches and pull requests (and starts a
- * branch or a worktree); `WherePicker` / `WhereMenu` choose where a new
- * session runs; `RemoteFolderPicker` / `RemoteFolderBrowser` pick a folder on
- * a remote host. The host interface and models are `zidane-ui/git/headless`.
- */
-export * from './GitProvider';
-export * from './BranchMenu';
-export * from './WherePicker';
-export * from './RemoteFolderPicker';
-export * from './GitBar';
-export * from './SyncChip';
-export * from './useGitBar';
-export * from './ImportRepoDialog';
-export * from './MoveSessionDialog';
-export * from './useEnvironmentChoices';

package/src/git/testing/contract.ts

@@ -1,551 +0,0 @@
-/**
- * What every `GitHost` implementation does alike, as a vitest suite: the in-memory fixture
- * (`createFixtureGitHost`), zidane-server (`createServerGitHost`), the desktop app's IPC host.
- *
- * An implementation's test calls {@link describeGitHostContract} with a harness factory. The
- * contract hands it a {@link GitHostContractBackend}: the checkout's branches and pull requests,
- * a branch another worktree holds, the environment kinds, the remote folders, and what each
- * action does there. The harness builds the host over a backend that does exactly that. The
- * capabilities list says which optional members the host offers: the suite checks the others are
- * left out (undefined, never a throwing stub) and skips what needs them.
- *
- *   describeGitHostContract('createFixtureGitHost', (backend) => ({ host: … }), ['branches', 'checkout']);
- */
-import type { EnvironmentDescriptor } from 'zidane/chat';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-import type {
-  GitBranch,
-  GitBranchPullRequest,
-  GitCloneProgress,
-  GitHost,
-  GitPullRequest,
-  GitRepoInfo,
-  GitRepoSpec,
-  GitStatus,
-} from '../headless/host';
-
-/** An optional `GitHost` member. */
-export type GitHostCapability =
-  | 'branches'
-  | 'pullRequests'
-  | 'checkout'
-  | 'createBranch'
-  | 'startWorktree'
-  | 'moveSession'
-  | 'environments'
-  | 'subscribeEnvironments'
-  | 'status'
-  | 'subscribeRefs'
-  | 'listFolders'
-  | 'pickFolder'
-  | 'subscribeActivity'
-  | 'branchPullRequest'
-  | 'sync'
-  | 'clone'
-  | 'createFolder'
-  | 'searchFolders'
-  | 'originUrl'
-  | 'cloneOnServer';
-
-const CAPABILITIES: readonly GitHostCapability[] = [
-  'branches',
-  'pullRequests',
-  'checkout',
-  'createBranch',
-  'startWorktree',
-  'moveSession',
-  'environments',
-  'subscribeEnvironments',
-  'status',
-  'subscribeRefs',
-  'listFolders',
-  'pickFolder',
-  'subscribeActivity',
-  'branchPullRequest',
-  'sync',
-  'clone',
-  'createFolder',
-  'searchFolders',
-  'originUrl',
-  'cloneOnServer',
-];
-
-/** The capabilities whose member is an object of methods, not a function. */
-const GROUPS: readonly GitHostCapability[] = ['clone'];
-
-/** What the backend behind the host holds, and what it does with each action. */
-export interface GitHostContractBackend {
-  /** The checkout's folder. */
-  cwd: string;
-  /** A session in that folder. */
-  sessionId: string;
-  /** The saved server whose folders `listFolders` lists (hosts that reach several pass it on). */
-  hostId: string;
-  /** Local branches, most recent first. The first is checked out. */
-  branches: GitBranch[];
-  /** The current branch. Switches and new branches land here. */
-  current: string;
-  /** Open pull requests. A search answers the ones `prMatches` finds. */
-  pullRequests: GitPullRequest[];
-  /** A branch another worktree has checked out: switching to it is refused with git's message, the worktree and its chats. */
-  held: { branch: string; worktree: string; chats: string[]; message: string };
-  /** Creating a branch that exists fails with this message. */
-  existsMessage: string;
-  /** Sessions moved into worktrees land here. */
-  moves: { sessionId: string; branch?: string }[];
-  /** Sessions moved anywhere (`moveSession`) land here: where, and in which folder. */
-  relocations: { sessionId: string; kind: string; branch?: string; cwd?: string }[];
-  /** The environment kinds for `cwd`. */
-  environments: EnvironmentDescriptor[];
-  /** The checkout's status. */
-  status: GitStatus;
-  /**
-   * The remote host's folders: its roots, and the folders under each path. A path outside the roots is refused with
-   * `outsideMessage`; a new folder whose name is taken, with `existsMessage`. New folders land in `tree`.
-   */
-  folders: { roots: string[]; tree: Record<string, string[]>; outsideMessage: string; existsMessage: string };
-  /** The `origin` URL of each checkout on this computer. Other folders have none. */
-  origins: Record<string, string>;
-  /** Clones that ran on a server: which server, what, and where. */
-  serverClones: { hostId: string; input: string; parent: string }[];
-  /** What the native folder dialog answers. */
-  pickedFolder: string;
-  /** The open pull request per branch. Branches left out have none. */
-  branchPullRequests: Record<string, GitBranchPullRequest>;
-  /** What a sync does: it pulls `behind` and pushes `ahead` of `status`. Syncing `conflictCwd` fails with `conflictMessage` and `conflicts`. */
-  sync: { conflictCwd: string; conflictMessage: string; conflicts: string[] };
-  /** Syncs that ran, by folder. */
-  synced: string[];
-  /** The repository import: what `repo.input` parses to, where clones land by default, the progress a clone reports, and a refused input. */
-  repo: {
-    input: string;
-    spec: GitRepoSpec;
-    defaultParent: string;
-    progress: GitCloneProgress[];
-    refusedInput: string;
-    refusedMessage: string;
-    /** What `input` is, for the import dialog's card (`clone.info`); other inputs have none. */
-    info: GitRepoInfo;
-  };
-  /** Clones that ran: what was cloned, and where. */
-  cloned: { input: string; parent: string }[];
-}
-
-/** A host built over a backend, and what the suite drives on it. */
-export interface GitHostHarness {
-  /** The host under test. */
-  host: GitHost;
-  /** Has the backend announce that the checkout's refs moved (needed for `subscribeRefs`). */
-  moveRefs?(): void;
-  /** Has the backend announce that the environment kinds may have changed (needed for `subscribeEnvironments`). */
-  changeEnvironments?(): void;
-  /** Has the backend report work by a session that may have moved its checkout (needed for `subscribeActivity`). */
-  activity?(sessionId: string): void;
-  /** Closes connections and timers after each test. */
-  dispose?(): void;
-}
-
-/** Builds a fresh host (and its backend) for one test. */
-export type GitHostHarnessFactory = (backend: GitHostContractBackend) => GitHostHarness | Promise<GitHostHarness>;
-
-function contractBackend(): GitHostContractBackend {
-  const pr = (number: number, extra: Partial<GitPullRequest>): GitPullRequest => ({
-    number,
-    title: `PR ${number}`,
-    url: `https://github.com/o/r/pull/${number}`,
-    branch: `feat/${number}`,
-    author: 'alex',
-    fork: false,
-    draft: false,
-    additions: 1,
-    deletions: 1,
-    files: 1,
-    review: null,
-    checks: null,
-    updatedAt: 1_000,
-    group: 'other',
-    local: false,
-    ...extra,
-  });
-  return {
-    cwd: '/w',
-    sessionId: 's-1',
-    hostId: 'box',
-    branches: [
-      { name: 'main', updatedAt: 3_000, isDefault: true },
-      { name: 'fix/a', updatedAt: 2_000, isDefault: false, stats: { ahead: 1, behind: 2, added: 3, removed: 4 } },
-      { name: 'held/b', updatedAt: 1_000, isDefault: false },
-    ],
-    current: 'main',
-    pullRequests: [
-      pr(12, { title: 'Terminal tabs', branch: 'feat/tabs', group: 'review' }),
-      pr(7, { title: 'Fix the drawer', branch: 'fix/a', group: 'mine', local: true }),
-    ],
-    held: { branch: 'held/b', worktree: '/w-b', chats: ['s-2'], message: "'held/b' is already checked out at '/w-b'" },
-    existsMessage: "a branch named 'main' already exists",
-    moves: [],
-    relocations: [],
-    environments: [
-      {
-        kind: 'local',
-        label: 'Local',
-        enabled: true,
-        isDefault: true,
-        available: true,
-        takesBranch: false,
-        canVerify: false,
-        fields: [],
-      } as unknown as EnvironmentDescriptor,
-      {
-        kind: 'worktree',
-        label: 'Worktree',
-        enabled: true,
-        isDefault: false,
-        available: true,
-        takesBranch: true,
-        suggestedBranch: 'zidane/x',
-        canVerify: false,
-        fields: [],
-      } as unknown as EnvironmentDescriptor,
-    ],
-    status: {
-      branch: 'main',
-      detached: false,
-      defaultBranch: 'origin/main',
-      upstream: 'origin/main',
-      publishRemote: null,
-      ahead: 1,
-      behind: 0,
-      changes: { files: 2, added: 5, removed: 1 },
-    },
-    folders: {
-      roots: ['/srv', '/home/me'],
-      tree: { '/srv': ['app', 'site'], '/srv/app': ['src'] },
-      outsideMessage: '/etc is outside the workspace roots',
-      existsMessage: 'app already exists in /srv.',
-    },
-    origins: { '/Users/me/project': 'git@github.com:o/r.git' },
-    serverClones: [],
-    pickedFolder: '/Users/me/project',
-    branchPullRequests: { main: { number: 5, title: 'Release', url: 'https://github.com/o/r/pull/5', draft: false } },
-    sync: { conflictCwd: '/conflicted', conflictMessage: 'Pull stopped on conflicts', conflicts: ['src/a.ts'] },
-    synced: [],
-    repo: {
-      input: 'o/r',
-      spec: { cloneUrl: 'https://github.com/o/r.git', name: 'r', label: 'o/r' },
-      defaultParent: '/Users/me/src',
-      progress: [{ phase: 'Receiving objects', percent: 50 }],
-      refusedInput: 'o/missing',
-      refusedMessage: 'Repository not found',
-      info: {
-        owner: 'o',
-        repo: 'r',
-        url: 'https://github.com/o/r',
-        description: 'The r repository',
-        stars: 7,
-        defaultBranch: 'main',
-        avatarUrl: 'https://github.com/o.png?size=96',
-        imageUrl: 'https://opengraph.githubassets.com/1/o/r',
-      },
-    },
-    cloned: [],
-  };
-}
-
-const waitFor = <T>(check: () => T) => vi.waitFor(check, { timeout: 3000, interval: 2 });
-
-/**
- * Declares the shared `GitHost` suite for one implementation.
- *
- * @param name - The implementation's name, shown in the suite title.
- * @param makeHarness - Builds a fresh host over a backend that does what it is given, once per test.
- * @param capabilities - The optional members the host offers. Every other optional member must be undefined.
- */
-export function describeGitHostContract(
-  name: string,
-  makeHarness: GitHostHarnessFactory,
-  capabilities: readonly GitHostCapability[],
-): void {
-  const has = (...needed: GitHostCapability[]) => needed.every((c) => capabilities.includes(c));
-
-  describe(`GitHost contract: ${name}`, () => {
-    const cleanup: (() => void)[] = [];
-    afterEach(() => {
-      for (const done of cleanup.splice(0).reverse()) done();
-    });
-
-    const setup = async () => {
-      const backend = contractBackend();
-      const harness = await makeHarness(backend);
-      cleanup.push(() => harness.dispose?.());
-      return { backend, harness, host: harness.host };
-    };
-
-    it('offers exactly its capabilities; the members it leaves out are undefined', async () => {
-      const { host } = await setup();
-      for (const capability of CAPABILITIES) {
-        const value = host[capability];
-        if (!has(capability)) expect(value, capability).toBeUndefined();
-        else expect(typeof value, capability).toBe(GROUPS.includes(capability) ? 'object' : 'function');
-      }
-    });
-
-    it.skipIf(!has('branches'))('lists the local branches, most recent first, with their standing', async () => {
-      const { host, backend } = await setup();
-      const branches = await host.branches!(backend.cwd);
-      expect(branches.map((b) => b.name)).toEqual(['main', 'fix/a', 'held/b']);
-      expect(branches[0]).toMatchObject({ isDefault: true });
-      expect(branches[1]!.stats).toEqual({ ahead: 1, behind: 2, added: 3, removed: 4 });
-    });
-
-    it.skipIf(!has('pullRequests'))('lists the open pull requests, and searches them', async () => {
-      const { host, backend } = await setup();
-      const all = await host.pullRequests!({ cwd: backend.cwd });
-      expect(all.kind).toBe('list');
-      if (all.kind !== 'list') return;
-      expect(all.items.map((p) => p.number)).toEqual([12, 7]);
-      expect(all.items[1]).toMatchObject({ group: 'mine', local: true, branch: 'fix/a' });
-      const found = await host.pullRequests!({ cwd: backend.cwd, search: 'tabs' });
-      expect(found.kind === 'list' && found.items.map((p) => p.number)).toEqual([12]);
-    });
-
-    it.skipIf(!has('checkout'))('switches to a branch, and to a pull request by number', async () => {
-      const { host, backend } = await setup();
-      expect(await host.checkout!(backend.cwd, { branch: 'fix/a' }, backend.sessionId)).toEqual({ ok: true });
-      expect(backend.current).toBe('fix/a');
-      expect(await host.checkout!(backend.cwd, { pullRequest: 12 }, backend.sessionId)).toEqual({ ok: true });
-      expect(backend.current).toBe('feat/tabs');
-    });
-
-    it.skipIf(!has('checkout'))('a branch another worktree holds is refused, naming it and its chats', async () => {
-      const { host, backend } = await setup();
-      const result = await host.checkout!(backend.cwd, { branch: backend.held.branch }, backend.sessionId);
-      expect(result).toEqual({
-        ok: false,
-        error: { code: 'failed', message: backend.held.message },
-        worktree: { path: backend.held.worktree, chats: backend.held.chats },
-      });
-      expect(backend.current).toBe('main');
-    });
-
-    it.skipIf(!has('createBranch'))('starts a branch and switches to it; an existing name fails in words', async () => {
-      const { host, backend } = await setup();
-      expect(await host.createBranch!(backend.cwd, 'new/x', backend.sessionId)).toEqual({ ok: true });
-      expect(backend.current).toBe('new/x');
-      expect(await host.createBranch!(backend.cwd, 'main', backend.sessionId)).toEqual({
-        ok: false,
-        error: { code: 'failed', message: backend.existsMessage },
-      });
-    });
-
-    it.skipIf(!has('startWorktree'))(
-      'moves a session into a worktree, on the branch given or the suggested one',
-      async () => {
-        const { host, backend } = await setup();
-        expect(await host.startWorktree!(backend.sessionId, 'wt/one')).toEqual({ ok: true });
-        expect(await host.startWorktree!(backend.sessionId)).toEqual({ ok: true });
-        expect(backend.moves).toEqual([
-          { sessionId: backend.sessionId, branch: 'wt/one' },
-          { sessionId: backend.sessionId },
-        ]);
-      },
-    );
-
-    it.skipIf(!has('moveSession'))('moves a session to another kind, in the folder given there', async () => {
-      const { host, backend } = await setup();
-      expect(await host.moveSession!(backend.sessionId, { kind: 'local@laptop', cwd: '/srv/app' })).toEqual({
-        ok: true,
-      });
-      expect(await host.moveSession!(backend.sessionId, { kind: 'worktree', branch: 'wt/two' })).toEqual({ ok: true });
-      expect(backend.relocations).toEqual([
-        { sessionId: backend.sessionId, kind: 'local@laptop', cwd: '/srv/app' },
-        { sessionId: backend.sessionId, kind: 'worktree', branch: 'wt/two' },
-      ]);
-    });
-
-    it.skipIf(!has('environments'))('lists the environment kinds for a folder', async () => {
-      const { host, backend } = await setup();
-      const kinds = await host.environments!({ cwd: backend.cwd });
-      expect(kinds.map((d) => d.kind)).toEqual(['local', 'worktree']);
-      expect(kinds[1]).toMatchObject({ takesBranch: true, suggestedBranch: 'zidane/x' });
-    });
-
-    it.skipIf(!has('subscribeEnvironments'))(
-      'tells a subscriber when the environment kinds may have changed, until it unsubscribes',
-      async () => {
-        const { host, backend, harness } = await setup();
-        const seen = vi.fn();
-        const off = host.subscribeEnvironments!({ cwd: backend.cwd }, seen);
-        harness.changeEnvironments!();
-        await waitFor(() => expect(seen).toHaveBeenCalledTimes(1));
-        off();
-        harness.changeEnvironments!();
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(seen).toHaveBeenCalledTimes(1);
-      },
-    );
-
-    it.skipIf(!has('status'))('says where the checkout stands', async () => {
-      const { host, backend } = await setup();
-      expect(await host.status!(backend.cwd)).toEqual(backend.status);
-    });
-
-    it.skipIf(!has('subscribeRefs'))('tells a subscriber when the refs move, until it unsubscribes', async () => {
-      const { host, backend, harness } = await setup();
-      const seen = vi.fn();
-      const off = host.subscribeRefs!(backend.cwd, seen);
-      harness.moveRefs!();
-      await waitFor(() => expect(seen).toHaveBeenCalledTimes(1));
-      off();
-      harness.moveRefs!();
-      await new Promise((resolve) => setTimeout(resolve, 10));
-      expect(seen).toHaveBeenCalledTimes(1);
-    });
-
-    it.skipIf(!has('listFolders'))(
-      'lists the first root, a folder below it with its parent, and refuses outside',
-      async () => {
-        const { host, backend } = await setup();
-        const first = await host.listFolders!({ hostId: backend.hostId });
-        expect(first.ok).toBe(true);
-        if (!first.ok) return;
-        expect(first.listing).toMatchObject({ roots: ['/srv', '/home/me'], path: '/srv', parent: null });
-        expect(first.listing.dirs.map((d) => [d.name, d.path])).toEqual([
-          ['app', '/srv/app'],
-          ['site', '/srv/site'],
-        ]);
-        const below = await host.listFolders!({ hostId: backend.hostId, path: '/srv/app' });
-        expect(below.ok && below.listing).toMatchObject({ path: '/srv/app', parent: '/srv' });
-        const outside = await host.listFolders!({ hostId: backend.hostId, path: '/etc' });
-        expect(outside).toEqual({ ok: false, error: { code: 'failed', message: backend.folders.outsideMessage } });
-      },
-    );
-
-    it.skipIf(!has('clone'))('says what a repository is when it can, and nothing for an unknown one', async () => {
-      const { host, backend } = await setup();
-      const info = host.clone!.info;
-      if (!info) return;
-      expect(await info(backend.repo.input)).toEqual(backend.repo.info);
-      expect(await info(backend.repo.refusedInput)).toBeNull();
-    });
-
-    it.skipIf(!has('listFolders', 'createFolder'))('says what the host lets clients do in its folders', async () => {
-      const { host, backend } = await setup();
-      const first = await host.listFolders!({ hostId: backend.hostId });
-      expect(first.ok && first.listing.allows).toMatchObject({ createFolders: true, clone: true });
-    });
-
-    it.skipIf(!has('listFolders', 'createFolder'))(
-      'creates a folder that the next listing shows; a taken name fails in words',
-      async () => {
-        const { host, backend } = await setup();
-        expect(await host.createFolder!({ hostId: backend.hostId, parent: '/srv', name: 'fresh' })).toEqual({
-          ok: true,
-          folder: { name: 'fresh', path: '/srv/fresh', isGitRepo: false },
-        });
-        const listed = await host.listFolders!({ hostId: backend.hostId });
-        expect(listed.ok && listed.listing.dirs.map((d) => d.name)).toContain('fresh');
-        expect(await host.createFolder!({ hostId: backend.hostId, parent: '/srv', name: 'app' })).toEqual({
-          ok: false,
-          error: { code: 'failed', message: backend.folders.existsMessage },
-        });
-      },
-    );
-
-    it.skipIf(!has('searchFolders'))('finds folders by name below a folder, and refuses outside', async () => {
-      const { host, backend } = await setup();
-      const found = await host.searchFolders!({ hostId: backend.hostId, query: 'SR', path: '/srv' });
-      expect(found).toEqual({
-        ok: true,
-        results: [{ name: 'src', path: '/srv/app/src', isGitRepo: false }],
-        truncated: false,
-      });
-      const outside = await host.searchFolders!({ hostId: backend.hostId, query: 'x', path: '/etc' });
-      expect(outside).toEqual({ ok: false, error: { code: 'failed', message: backend.folders.outsideMessage } });
-    });
-
-    it.skipIf(!has('originUrl'))("reads a local checkout's origin, and none elsewhere", async () => {
-      const { host, backend } = await setup();
-      expect(await host.originUrl!('/Users/me/project')).toBe(backend.origins['/Users/me/project']);
-      expect(await host.originUrl!('/Users/me/notes')).toBeNull();
-    });
-
-    it.skipIf(!has('cloneOnServer'))('clones on a server where asked, and refuses in words', async () => {
-      const { host, backend } = await setup();
-      expect(await host.cloneOnServer!(backend.hostId, 'git@github.com:o/r.git', '/srv')).toMatchObject({
-        ok: true,
-        path: '/srv/r',
-      });
-      expect(backend.serverClones).toEqual([
-        { hostId: backend.hostId, input: 'git@github.com:o/r.git', parent: '/srv' },
-      ]);
-      expect(await host.cloneOnServer!(backend.hostId, backend.repo.refusedInput, '/srv')).toEqual({
-        ok: false,
-        error: { code: 'failed', message: backend.repo.refusedMessage },
-      });
-    });
-
-    it.skipIf(!has('pickFolder'))('picks a folder on this computer', async () => {
-      const { host, backend } = await setup();
-      expect(await host.pickFolder!()).toBe(backend.pickedFolder);
-    });
-
-    it.skipIf(!has('subscribeActivity'))(
-      "tells a subscriber when its session's work lands, not another's",
-      async () => {
-        const { host, backend, harness } = await setup();
-        const seen = vi.fn();
-        const off = host.subscribeActivity!(backend.sessionId, seen);
-        harness.activity!('s-other');
-        harness.activity!(backend.sessionId);
-        await waitFor(() => expect(seen).toHaveBeenCalledTimes(1));
-        off();
-        harness.activity!(backend.sessionId);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(seen).toHaveBeenCalledTimes(1);
-      },
-    );
-
-    it.skipIf(!has('branchPullRequest'))("finds a branch's open pull request, and none for another", async () => {
-      const { host, backend } = await setup();
-      expect(await host.branchPullRequest!(backend.cwd, 'main')).toEqual(backend.branchPullRequests.main);
-      expect(await host.branchPullRequest!(backend.cwd, 'fix/a', true)).toBeNull();
-    });
-
-    it.skipIf(!has('sync'))('syncs the branch, and a refused pull comes back with its conflicts', async () => {
-      const { host, backend } = await setup();
-      expect(await host.sync!(backend.cwd, backend.sessionId)).toEqual({
-        ok: true,
-        pulled: backend.status.behind,
-        pushed: backend.status.ahead,
-        published: false,
-      });
-      expect(backend.synced).toEqual([backend.cwd]);
-      expect(await host.sync!(backend.sync.conflictCwd)).toEqual({
-        ok: false,
-        error: { code: 'failed', message: backend.sync.conflictMessage },
-        conflicts: backend.sync.conflicts,
-      });
-    });
-
-    it.skipIf(!has('clone'))('parses what was pasted, clones it where asked, and refuses in words', async () => {
-      const { host, backend } = await setup();
-      const clone = host.clone!;
-      expect(clone.parse(backend.repo.input)).toEqual(backend.repo.spec);
-      expect(clone.parse('not a repository')).toBeNull();
-      expect(await clone.defaultParent()).toBe(backend.repo.defaultParent);
-      const progress = vi.fn();
-      const off = clone.onProgress?.(progress);
-      const done = await clone.clone(backend.repo.input, '/tmp');
-      off?.();
-      expect(done).toMatchObject({ ok: true, path: `/tmp/${backend.repo.spec.name}` });
-      expect(backend.cloned).toEqual([{ input: backend.repo.input, parent: '/tmp' }]);
-      if (clone.onProgress) expect(progress).toHaveBeenCalledWith(backend.repo.progress[0]);
-      expect(await clone.clone(backend.repo.refusedInput, '/tmp')).toEqual({
-        ok: false,
-        error: { code: 'failed', message: backend.repo.refusedMessage },
-      });
-    });
-  });
-}