zidane-ui 9.1.1 → 9.1.4

package/src/adapters/server-files-host.ts

@@ -1,287 +0,0 @@
-/**
- * A `FilesHost` on a running zidane-server, over a shared browser client
- * (`createServerClient`). zidane-server addresses files through a session's
- * workspace (`sessions.workspaceListFiles` / `workspaceReadFile` /
- * `workspaceWriteFile` / `workspaceFileSize`, a `chat` token), so the host
- * asks the app which session a folder belongs to (`sessionOf`). Folder
- * changes are the `tool-result` events of that session (`event` signals).
- *
- * The server has no file version: a file's version is a hash of its text,
- * and a write re-reads the file first and refuses when that hash moved.
- *
- * A folder inside the server's workspace roots is also searched, diffed and
- * checked directly: content search (`files.search`), git status and the
- * working-tree diff (`git.fileStatus`, `git.diff`) and the project's own
- * diagnostics (`files.diagnostics`, `files.diagnosticsInvalidate`, an
- * `admin` token), each offered when the connection may call its method.
- *
- * Entry actions (create, move, copy, remove, import) are the session's too
- * (`sessions.workspaceCreate` / `Move` / `Copy` / `Remove`, an `admin`
- * token): the server runs the rules where the files are, and removes for
- * good. A drop is walked here and sent one file per call. Its empty folders
- * (`sessions.workspaceEmptyDirs`) join the listing, as a file listing leaves
- * them out.
- *
- * Media files (images, video, audio) play from the server's media route
- * (`mediaUrl`: `GET /zidane/media` under a ticket this host registers on
- * every connection, `files.mediaTicket`), relative to the page's origin:
- * the web app the server serves. Without the method, they show as binary.
- *
- * Left out: language servers (`lsp`: their documents live per window on
- * the machine running them) and `system` (the files are on the server, not
- * where the browser runs).
- */
-import type { HostSignal } from 'zidane/ipc';
-import { importEntries, type EntryResult } from 'zidane/chat/pure';
-import { SERVER_MEDIA_PATH, type ServerClient } from 'zidane/ipc/browser';
-
-import { createStorageEditorPrefs, type EditorPrefsStorage } from '../files/headless/editor-prefs';
-import { droppedImportItems } from '../files/headless/entries';
-import type {
-  ContentSearchOptions,
-  DiagnosticsRunOptions,
-  FilesEntries,
-  FilesHost,
-  MediaSource,
-  WorkspaceEntry,
-  WorkspaceFile,
-} from '../files/headless/host';
-import { mediaTypeOfPath } from '../files/headless/media';
-
-/** Options for {@link createServerFilesHost}. */
-export interface ServerFilesHostOptions {
-  /** The client to speak through, shared with the chat host (`createServerHost({ client })`) and other areas' hosts. */
-  client: ServerClient;
-  /** The session whose workspace holds a folder's files (the session open on it); `undefined`: none, nothing to read. */
-  sessionOf: (cwd: string) => string | undefined;
-  /** Where the editor preferences live (`localStorage`). Absent: no `editorPrefs`, the defaults. */
-  storage?: EditorPrefsStorage;
-}
-
-/** FNV-1a over the text: the file's version, as the server has none. */
-function versionOf(text: string): number {
-  let h = 0x811c9dc5;
-  for (let i = 0; i < text.length; i++) {
-    h ^= text.charCodeAt(i);
-    h = Math.imul(h, 0x01000193);
-  }
-  return h >>> 0;
-}
-
-const utf8Bytes = (text: string) => new TextEncoder().encode(text).length;
-
-/** Bytes as base64, in slices (`String.fromCharCode` takes so many arguments at once). */
-function toBase64(bytes: Uint8Array): string {
-  let binary = '';
-  for (let at = 0; at < bytes.length; at += 0x8000) binary += String.fromCharCode(...bytes.subarray(at, at + 0x8000));
-  return btoa(binary);
-}
-
-const ENTRY_METHODS = [
-  'sessions.workspaceCreate',
-  'sessions.workspaceMove',
-  'sessions.workspaceCopy',
-  'sessions.workspaceRemove',
-] as const;
-
-/** The session's entry actions, over its `sessions.workspace*` calls. */
-function serverEntries(client: ServerClient, session: (cwd: string) => string): FilesEntries {
-  const noSession = (cwd: string): EntryResult => ({
-    ok: false,
-    reason: 'denied',
-    message: `No session holds ${cwd}.`,
-  });
-  const create = (cwd: string, path: string, kind: 'file' | 'dir', content?: Uint8Array, freeName?: boolean) =>
-    client.call('sessions.workspaceCreate', {
-      sessionId: session(cwd),
-      path,
-      kind,
-      ...(content ? { content: toBase64(content) } : {}),
-      ...(freeName ? { freeName } : {}),
-    });
-  const guarded = async (cwd: string, run: () => Promise<EntryResult>): Promise<EntryResult> => {
-    try {
-      return await run();
-    } catch (error) {
-      return error instanceof Error && /no session holds/.test(error.message)
-        ? noSession(cwd)
-        : { ok: false, reason: 'denied', message: error instanceof Error ? error.message : String(error) };
-    }
-  };
-  return {
-    create: (cwd, path, kind) => guarded(cwd, () => create(cwd, path, kind)),
-    move: (cwd, from, to) =>
-      guarded(cwd, () => client.call('sessions.workspaceMove', { sessionId: session(cwd), from, to })),
-    copy: (cwd, from, toDir) =>
-      guarded(cwd, () => client.call('sessions.workspaceCopy', { sessionId: session(cwd), from, toDir })),
-    remove: (cwd, path) =>
-      guarded(cwd, () => client.call('sessions.workspaceRemove', { sessionId: session(cwd), path })),
-    importFiles: async (cwd, dir, items) =>
-      importEntries(
-        (path, kind, options) => guarded(cwd, () => create(cwd, path, kind, options?.content, options?.freeName)),
-        dir,
-        await droppedImportItems(items),
-      ),
-    removal: () => 'permanent',
-  };
-}
-
-/** A listed path relative to the folder: `./a`, `/cwd/a` and `a` all read `a`. */
-function relativePath(path: string, cwd: string): string {
-  const base = cwd.replace(/\/+$/, '');
-  if (path.startsWith(`${base}/`)) return path.slice(base.length + 1);
-  return path.replace(/^\.\//, '');
-}
-
-/**
- * A media ticket, registered on every connection of `client` (the server
- * drops it with the connection); `null` when the server serves no media.
- */
-function mediaTicket(client: ServerClient): string | null {
-  if (!client.can('files.mediaTicket')) return null;
-  const bytes = crypto.getRandomValues(new Uint8Array(32));
-  const ticket = btoa(String.fromCharCode(...bytes))
-    .replace(/\+/g, '-')
-    .replace(/\//g, '_')
-    .replace(/=+$/, '');
-  const register = () => void client.call('files.mediaTicket', { ticket }).catch(() => undefined);
-  register();
-  client.onOpen(register);
-  return ticket;
-}
-
-/** Where `source` plays from, under `ticket`. */
-function mediaAddress(ticket: string, source: MediaSource): string {
-  const query = new URLSearchParams({ ticket, cwd: source.cwd, path: source.path });
-  if (source.kind === 'diff') query.set('side', source.side);
-  if (source.version !== undefined) query.set('v', String(source.version));
-  return `${SERVER_MEDIA_PATH}?${query}`;
-}
-
-/**
- * Creates a {@link FilesHost} on a running zidane-server.
- *
- * @param options - The shared client, the folder → session lookup and where editor preferences live.
- */
-export function createServerFilesHost(options: ServerFilesHostOptions): FilesHost {
-  const { client, sessionOf } = options;
-  const ticket = mediaTicket(client);
-
-  const session = (cwd: string): string => {
-    const id = sessionOf(cwd);
-    if (!id) throw new Error(`createServerFilesHost: no session holds ${cwd}`);
-    return id;
-  };
-
-  /** The file's text, or `null` when it does not exist. */
-  const readText = async (sessionId: string, path: string): Promise<string | null> => {
-    try {
-      return await client.call('sessions.workspaceReadFile', { sessionId, path });
-    } catch (error) {
-      // Missing, or the read failed: the size tells them apart.
-      const size = await client.call('sessions.workspaceFileSize', { sessionId, path }).catch(() => undefined);
-      if (size === null) return null;
-      throw error;
-    }
-  };
-
-  return {
-    async list(cwd, opts) {
-      const sessionId = session(cwd);
-      const [entries, emptyDirs] = await Promise.all([
-        client.call('sessions.workspaceListFiles', {
-          sessionId,
-          path: '**/*',
-          options: { glob: true, gitignore: !opts?.showIgnored },
-        }),
-        client.can('sessions.workspaceEmptyDirs')
-          ? client.call('sessions.workspaceEmptyDirs', { sessionId }).catch(() => [] as string[])
-          : ([] as string[]),
-      ]);
-      const paths = new Set<string>();
-      for (const entry of entries) paths.add(relativePath(typeof entry === 'string' ? entry : entry.path, cwd));
-      return [
-        ...[...paths].map((path): WorkspaceEntry => ({ path, kind: 'file' })),
-        ...emptyDirs.map((path): WorkspaceEntry => ({ path: `${path}/`, kind: 'dir' })),
-      ].sort((a, b) => a.path.localeCompare(b.path));
-    },
-    async read(cwd, path) {
-      const sessionId = sessionOf(cwd);
-      if (!sessionId) return null;
-      const media = mediaTypeOfPath(path);
-      if (media && ticket) {
-        // It plays from the media route: its bytes don't cross the socket. Its size stands in for a version.
-        const size = await client.call('sessions.workspaceFileSize', { sessionId, path }).catch(() => null);
-        return size === null
-          ? null
-          : { path, contents: '', truncated: false, size, binary: true, media, mtimeMs: size };
-      }
-      const text = await readText(sessionId, path).catch(() => null);
-      if (text === null) return null;
-      const binary = media !== null || text.includes('\u0000');
-      const file: WorkspaceFile = {
-        path,
-        contents: binary ? '' : text,
-        truncated: false,
-        size: utf8Bytes(text),
-        binary,
-        mtimeMs: versionOf(text),
-      };
-      return file;
-    },
-    async write(cwd, path, contents, expectedMtimeMs) {
-      const sessionId = sessionOf(cwd);
-      if (!sessionId) return { ok: false, reason: 'denied' };
-      const current = await readText(sessionId, path).catch(() => undefined);
-      if (current === undefined) return { ok: false, reason: 'denied' };
-      if (current === null) return { ok: false, reason: 'missing' };
-      if (versionOf(current) !== expectedMtimeMs) return { ok: false, reason: 'changed' };
-      try {
-        await client.call('sessions.workspaceWriteFile', { sessionId, path, content: contents });
-      } catch {
-        return { ok: false, reason: 'denied' };
-      }
-      return { ok: true, mtimeMs: versionOf(contents) };
-    },
-    ...(ENTRY_METHODS.every((method) => client.can(method)) ? { entries: serverEntries(client, session) } : {}),
-    watch(scope, onChange) {
-      return client.onSignal((signal: HostSignal) => {
-        if (signal.kind !== 'event' || signal.event.kind !== 'tool-result') return;
-        const bound = scope.session ?? sessionOf(scope.workspace ?? scope.cwd);
-        if (signal.sessionId === bound) onChange('tool-result');
-      });
-    },
-    ...(client.can('files.search')
-      ? {
-          search: (cwd: string, query: string, { caseSensitive, searchId }: ContentSearchOptions) =>
-            client.call('files.search', { cwd, query, caseSensitive, searchId }),
-        }
-      : {}),
-    ...(client.can('git.fileStatus') ? { gitStatus: (cwd: string) => client.call('git.fileStatus', { cwd }) } : {}),
-    ...(client.can('git.diff')
-      ? {
-          workingTreeDiff: (cwd: string, opts?: { path?: string; context?: number }) =>
-            client.call('git.diff', {
-              cwd,
-              ...(opts?.path ? { path: opts.path } : {}),
-              // JSON has no Infinity: `null` asks for whole files.
-              ...(opts?.context !== undefined ? { context: Number.isFinite(opts.context) ? opts.context : null } : {}),
-            }),
-        }
-      : {}),
-    ...(client.can('files.diagnostics') && client.can('files.diagnosticsInvalidate')
-      ? {
-          diagnostics: {
-            // Language servers run on no server: `lsp` changes nothing here.
-            run: (cwd: string, paths: string[], { disabled, timeoutMs }: DiagnosticsRunOptions) =>
-              client.call('files.diagnostics', { cwd, paths, disabled, timeoutMs }),
-            invalidate: async (cwd: string) => {
-              await client.call('files.diagnosticsInvalidate', { cwd });
-            },
-          },
-        }
-      : {}),
-    ...(options.storage ? { editorPrefs: createStorageEditorPrefs({ storage: options.storage }) } : {}),
-    ...(ticket ? { mediaUrl: (source: MediaSource) => mediaAddress(ticket, source) } : {}),
-  };
-}

package/src/adapters/server-git-host.ts

@@ -1,289 +0,0 @@
-/**
- * A `GitHost` on a running zidane-server, over the same client as the chat
- * host (`createServerClient`, or `createServerHost(...).client`).
- *
- * What it offers: the server's folders for a session's folder (`fs.listDirs`,
- * inside the server's workspace roots, with what the hello's `clone` and
- * `createFolders` allow there), creating and searching them (`fs.mkdir`,
- * `fs.searchDirs`), a shared machine's folders (`machines.listDirs`), the
- * environment kinds a new session can run in
- * (`environments.list`, read again on `settings:changed`, where environment
- * edits land, and after a reconnect), moving a session into a new worktree
- * or anywhere else the server runs, its machines included
- * (`sessions.moveEnvironment`), and the checkout in a folder of the
- * server's workspace roots: branches, pull requests, the git bar's status and
- * pull request (`git.branches`, `git.pullRequests`, `git.status`,
- * `git.branchPullRequest`), switching, starting branches, sync and the
- * repository import (`git.checkout`, `git.createBranch`, `git.sync`,
- * `git.clone` with `git:clone:progress`, `git.cloneCancel`; clones land in
- * the first workspace root by default). A session's tool results refresh the
- * git bar (`event` signals), and so do its refs moving (`subscribeRefs`:
- * `git.watch`, `git:refs`, watched again after a reconnect). Each git member
- * is offered when the connection may call its method (`client.can`): reads,
- * cloning and new folders need a `chat` token, the other writes an `admin`
- * one.
- *
- * Not offered: a native folder dialog, and clone on send (the browser has no
- * project on this computer to start from: `originUrl`, `cloneOnServer`).
- */
-import { parseRepoInput } from 'zidane/chat/pure';
-import type { HostSignal, IpcResult } from 'zidane/ipc';
-import type { ServerClient } from 'zidane/ipc/browser';
-
-import type {
-  GitCheckoutResult as GitHostCheckoutResult,
-  GitClone,
-  GitFolderAllows,
-  GitFolderListing,
-  GitHost,
-  GitHostError,
-  GitSyncResult as GitHostSyncResult,
-} from '../git/headless/host';
-
-/** Options for {@link createServerGitHost}. */
-export interface ServerGitHostOptions {
-  /** The client to speak through, shared with the chat host. */
-  client: ServerClient;
-}
-
-const failed = (error: unknown): GitHostError => ({
-  code: 'failed',
-  message: error instanceof Error ? error.message : String(error),
-});
-
-/** A server's switch answer, as the kit words it. */
-function readCheckout(result: IpcResult<'git.checkout'>): GitHostCheckoutResult {
-  if (result.ok) return { ok: true };
-  return {
-    ok: false,
-    error: { code: 'failed', message: result.error },
-    ...(result.worktree ? { worktree: { path: result.worktree, chats: result.chats ?? [] } } : {}),
-  };
-}
-
-/** A server's sync answer, as the kit words it. */
-function readSync(result: IpcResult<'git.sync'>): GitHostSyncResult {
-  if (result.ok) return result;
-  return {
-    ok: false,
-    error: { code: 'failed', message: result.error },
-    ...(result.conflicts ? { conflicts: result.conflicts } : {}),
-  };
-}
-
-/**
- * What the server lets this connection do in its folders: the hello's flags, and the methods its token reaches. An
- * older server sends no flags: the methods its hello lists say it then. `undefined` when neither says.
- */
-function folderAllows(client: ServerClient): GitFolderAllows | undefined {
-  const hello = client.hello();
-  const searchFolders = client.can('fs.searchDirs');
-  if (hello?.clone !== undefined || hello?.createFolders !== undefined) {
-    return {
-      createFolders: hello.createFolders === true && client.can('fs.mkdir'),
-      clone: hello.clone === true && client.can('git.clone'),
-      searchFolders,
-    };
-  }
-  if (!hello?.methods) return undefined;
-  return { createFolders: client.can('fs.mkdir'), clone: client.can('git.clone'), searchFolders };
-}
-
-/** The repository import over `git.clone`: one clone per connection, landing in the first workspace root by default. */
-function createClone(client: ServerClient): GitClone {
-  return {
-    parse: parseRepoInput,
-    async defaultParent() {
-      return (await client.call('fs.roots', {})).roots[0] ?? '';
-    },
-    async clone(input, parent) {
-      try {
-        const result = await client.call('git.clone', { input, parent });
-        if (result.ok) return { ok: true, path: result.path, existed: result.existed };
-        return result.cancelled
-          ? { ok: false, cancelled: true }
-          : { ok: false, error: { code: 'failed', message: result.error } };
-      } catch (error) {
-        return { ok: false, error: failed(error) };
-      }
-    },
-    onProgress: (onProgress) =>
-      client.onSignal((signal: HostSignal) => {
-        if (signal.kind === 'git:clone:progress') onProgress({ phase: signal.phase, percent: signal.percent });
-      }),
-    ...(client.can('git.cloneCancel')
-      ? {
-          cancel: async () => {
-            await client.call('git.cloneCancel', {});
-          },
-        }
-      : {}),
-  };
-}
-
-/**
- * Creates a {@link GitHost} over a zidane-server client.
- *
- * @param options - The client.
- */
-export function createServerGitHost(options: ServerGitHostOptions): GitHost {
-  const { client } = options;
-  const host: GitHost = {
-    async startWorktree(sessionId, branch) {
-      try {
-        await client.call('sessions.moveEnvironment', {
-          sessionId,
-          environment: { kind: 'worktree', ...(branch ? { branch } : {}) },
-        });
-        return { ok: true };
-      } catch (error) {
-        return { ok: false, error: failed(error) };
-      }
-    },
-    async moveSession(sessionId, { kind, branch, cwd, removeOldWorktree }) {
-      try {
-        // An older host ignores `removeOldWorktree` and answers nothing.
-        const result = (await client.call('sessions.moveEnvironment', {
-          sessionId,
-          environment: { kind, ...(branch ? { branch } : {}) },
-          ...(cwd ? { cwd } : {}),
-          ...(removeOldWorktree ? { removeOldWorktree: true } : {}),
-        })) as unknown as { oldWorktree?: { removed: boolean; reason?: string } } | null | undefined;
-        return { ok: true, ...(result?.oldWorktree ? { oldWorktree: result.oldWorktree } : {}) };
-      } catch (error) {
-        return { ok: false, error: failed(error) };
-      }
-    },
-    async environments({ cwd }) {
-      return client.call('environments.list', cwd ? { cwd } : {});
-    },
-    subscribeEnvironments(_query, onChange) {
-      const offSignal = client.onSignal((signal: HostSignal) => {
-        if (signal.kind === 'settings:changed') onChange();
-      });
-      const offOpen = client.onOpen((_hello, reconnected) => {
-        if (reconnected) onChange();
-      });
-      return () => {
-        offSignal();
-        offOpen();
-      };
-    },
-    subscribeActivity: (sessionId, onChange) =>
-      client.onSignal((signal: HostSignal) => {
-        if (signal.kind === 'event' && signal.sessionId === sessionId && signal.event.kind === 'tool-result')
-          onChange();
-      }),
-    async listFolders({ machineId, path }) {
-      try {
-        if (machineId) {
-          const listing = await client.call('machines.listDirs', { machineId, ...(path ? { path } : {}) });
-          const atRoot = listing.roots.includes(listing.path);
-          const result: GitFolderListing = {
-            roots: listing.roots,
-            path: listing.path,
-            parent: atRoot ? null : listing.path.replace(/\/[^/]+\/?$/, '') || '/',
-            dirs: listing.dirs.map((dir) => ({
-              name: dir.slice(dir.lastIndexOf('/') + 1),
-              path: dir,
-              isGitRepo: false,
-            })),
-          };
-          return { ok: true, listing: result };
-        }
-        const listing = await client.call('fs.listDirs', path ? { path } : {});
-        const allows = folderAllows(client);
-        return {
-          ok: true,
-          listing: {
-            roots: listing.roots,
-            path: listing.path,
-            parent: listing.parent,
-            dirs: listing.entries.map((dir) => ({ name: dir.name, path: dir.path, isGitRepo: dir.isGitRepo })),
-            ...(allows ? { allows } : {}),
-          },
-        };
-      } catch (error) {
-        return { ok: false, error: failed(error) };
-      }
-    },
-  };
-  if (client.can('fs.mkdir')) {
-    host.createFolder = async ({ parent, name }) => {
-      try {
-        return { ok: true, folder: await client.call('fs.mkdir', { parent, name }) };
-      } catch (error) {
-        return { ok: false, error: failed(error) };
-      }
-    };
-  }
-  if (client.can('fs.searchDirs')) {
-    host.searchFolders = async ({ query, path }) => {
-      try {
-        const found = await client.call('fs.searchDirs', { query, ...(path ? { path } : {}) });
-        return { ok: true, results: found.results, truncated: found.truncated === true };
-      } catch (error) {
-        return { ok: false, error: failed(error) };
-      }
-    };
-  }
-  if (client.can('git.branches')) host.branches = (cwd) => client.call('git.branches', { cwd });
-  if (client.can('git.pullRequests')) {
-    host.pullRequests = async ({ cwd, search, fresh }) => {
-      const result = await client.call('git.pullRequests', {
-        cwd,
-        ...(search ? { search } : {}),
-        ...(fresh ? { fresh } : {}),
-      });
-      if (result === null) return { kind: 'unavailable' };
-      if (!Array.isArray(result)) return { kind: 'rate-limited', retryAt: result.rateLimited.retryAt };
-      return { kind: 'list', items: result };
-    };
-  }
-  if (client.can('git.checkout')) {
-    host.checkout = async (cwd, target, sessionId) =>
-      readCheckout(
-        await client.call('git.checkout', {
-          cwd,
-          target: 'branch' in target ? target.branch : { pr: target.pullRequest },
-          ...(sessionId ? { sessionId } : {}),
-        }),
-      );
-  }
-  if (client.can('git.createBranch')) {
-    host.createBranch = async (cwd, name, sessionId) =>
-      readCheckout(await client.call('git.createBranch', { cwd, name, ...(sessionId ? { sessionId } : {}) }));
-  }
-  if (client.can('git.status')) host.status = (cwd) => client.call('git.status', { cwd });
-  if (client.can('git.branchPullRequest')) {
-    host.branchPullRequest = (cwd, branch, fresh) =>
-      client.call('git.branchPullRequest', { cwd, branch, ...(fresh ? { fresh } : {}) });
-  }
-  if (client.can('git.sync')) {
-    host.sync = async (cwd, sessionId) =>
-      readSync(await client.call('git.sync', { cwd, ...(sessionId ? { sessionId } : {}) }));
-  }
-  if (client.can('git.clone')) host.clone = createClone(client);
-  if (client.can('git.watch')) host.subscribeRefs = (cwd, onChange) => subscribeRefs(client, cwd, onChange);
-  return host;
-}
-
-/** Follows `cwd`'s refs: one `git.watch` per connection while subscribed (a closed connection's is released with it). */
-function subscribeRefs(client: ServerClient, cwd: string, onChange: () => void): () => void {
-  const watch = () => void client.call('git.watch', { cwd }).catch(() => undefined);
-  if (client.hello()) watch();
-  const offs = [
-    client.onSignal((signal: HostSignal) => {
-      if (signal.kind === 'git:refs' && signal.cwd === cwd) onChange();
-    }),
-    // A new connection: watch there; the refs may have moved meanwhile.
-    client.onOpen(() => {
-      watch();
-      onChange();
-    }),
-  ];
-  return () => {
-    for (const off of offs) off();
-    void client.call('git.unwatch', { cwd }).catch(() => undefined);
-  };
-}