@tilewise/workbench-client 0.0.0-stage → 0.1.1

package/dist/vite/apiWorkers.js

@@ -0,0 +1,111 @@
+import { pathToFileURL } from 'node:url';
+import { Worker } from 'node:worker_threads';
+import { apiFetchOf } from './apiFetch.js';
+/** How long a build's fake API stays loaded with nothing asked of it. */
+const IDLE = 30 * 60 * 1000;
+// The worker's code, as CommonJS: it loads the bundle and answers each request with it.
+const SOURCE = `
+const { parentPort, workerData } = require('node:worker_threads');
+const apiFetchOf = ${apiFetchOf.toString()};
+const loaded = import(workerData.url).then(apiFetchOf);
+parentPort.on('message', async ({ id, method, url, headers, body }) => {
+  try {
+    const answer = await (await loaded)(new Request(url, { method, headers, body }));
+    const bytes = await answer.arrayBuffer();
+    const plain = [...answer.headers].filter(([name]) => name !== 'set-cookie');
+    const cookies = answer.headers.getSetCookie().map((value) => ['set-cookie', value]);
+    parentPort.postMessage({ id, status: answer.status, headers: [...plain, ...cookies], body: bytes }, [bytes]);
+  } catch (failure) {
+    parentPort.postMessage({ id, error: String((failure && failure.stack) || failure) });
+  }
+});
+`;
+/**
+ * Each build's fake API, run in a worker of its own: loaded on its first
+ * request, kept while it is asked things, so a visit's data stays, and stopped
+ * after `idle` with nothing asked, which frees its memory. A worker gets no
+ * environment, so a bundle sees none of the dev server's settings.
+ */
+export function createApiWorkers(idle = IDLE) {
+    const running = new Map();
+    let next = 0;
+    function stop(key) {
+        const entry = running.get(key);
+        running.delete(key);
+        if (entry) {
+            if (entry.timer) {
+                clearTimeout(entry.timer);
+            }
+            void entry.worker.terminate();
+        }
+    }
+    function start(key, file) {
+        const worker = new Worker(SOURCE, {
+            eval: true,
+            env: {},
+            workerData: { url: pathToFileURL(file).href },
+        });
+        worker.unref();
+        const entry = { worker, pending: new Map(), timer: null };
+        const failAll = (error) => {
+            for (const [id, resolve] of entry.pending) {
+                resolve({ id, error });
+            }
+            entry.pending.clear();
+        };
+        worker.on('message', (reply) => {
+            entry.pending.get(reply.id)?.(reply);
+            entry.pending.delete(reply.id);
+        });
+        worker.on('error', (failure) => {
+            failAll(failure.stack ?? String(failure));
+            stop(key);
+        });
+        worker.on('exit', () => {
+            failAll('The fake API stopped');
+            if (running.get(key) === entry) {
+                running.delete(key);
+            }
+        });
+        running.set(key, entry);
+        return entry;
+    }
+    /** Asks the fake API in `file`, run once per `key`, and gives its answer. */
+    async function answer(key, file, request) {
+        const entry = running.get(key) ?? start(key, file);
+        if (entry.timer) {
+            clearTimeout(entry.timer);
+        }
+        entry.timer = setTimeout(() => stop(key), idle);
+        entry.timer.unref();
+        const body = request.method === 'GET' || request.method === 'HEAD' ? null : await request.arrayBuffer();
+        const asked = {
+            id: (next += 1),
+            method: request.method,
+            url: request.url,
+            headers: [...request.headers],
+            body,
+        };
+        const reply = await new Promise((resolve) => {
+            entry.pending.set(asked.id, resolve);
+            entry.worker.postMessage(asked, body ? [body] : []);
+        });
+        if ('error' in reply) {
+            return Response.json({ error: reply.error }, { status: 500 });
+        }
+        const empty = reply.status === 204 || reply.status === 304;
+        return new Response(empty ? null : reply.body, {
+            status: reply.status,
+            headers: reply.headers,
+        });
+    }
+    /** The keys of the fake APIs loaded now, for the tests. */
+    const loaded = () => [...running.keys()];
+    /** Stops every fake API, as the dev server closes. */
+    function stopAll() {
+        for (const key of [...running.keys()]) {
+            stop(key);
+        }
+    }
+    return { answer, loaded, stopAll };
+}

package/dist/vite/appFolder.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Where the app is in a commit's tree: at `path`, the app's folder in the
+ * repository as the checkout has it, or at the top for a commit from before
+ * the app moved there. A folder holds the app when it has Vite's index.html.
+ */
+export declare function appFolder(tree: string, path: string): string;

package/dist/vite/appFolder.js

@@ -0,0 +1,11 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * Where the app is in a commit's tree: at `path`, the app's folder in the
+ * repository as the checkout has it, or at the top for a commit from before
+ * the app moved there. A folder holds the app when it has Vite's index.html.
+ */
+export function appFolder(tree, path) {
+    const moved = join(tree, path);
+    return path !== '' && existsSync(join(moved, 'index.html')) ? moved : tree;
+}

package/dist/vite/builds.d.ts

@@ -0,0 +1,47 @@
+import type { Git } from './git.js';
+export interface Build {
+    state: 'none' | 'queued' | 'building' | 'built' | 'failed';
+    /** What it is doing now, while building. */
+    step?: string;
+    /** 1 for a commit whose app talks to the viewer; 0 for one from before. Its hello says which protocol. */
+    protocol?: number;
+    /** The end of the log, when it failed. */
+    error?: string;
+}
+/** A fake API beside the app: its module, from the app's folder, and where the app asks it. */
+export interface ApiOption {
+    entry: string;
+    path: string;
+}
+/** A build's own fake API: its bundle, and where the build asks it. */
+export interface BuiltApi {
+    file: string;
+    path: string;
+}
+/** A tree's lockfile and the package manager it belongs to: pnpm, or npm for a commit from before a switch. */
+export declare function lockOf(dir: string): Promise<{
+    manager: string;
+    text: string | null;
+}>;
+/**
+ * Builds any commit of the app, one at a time, in a git worktree under
+ * `.builds/work/`, into `.builds/<sha>/`, served under `/__workbench/b/<sha>/`.
+ * The checkout and its uncommitted changes are never touched.
+ *
+ * The app may live in a folder of the repository, such as a pnpm workspace's
+ * `apps/app/`: each commit is built from that folder, or from the top for a
+ * commit from before the app moved there. With `api`, a commit that has the
+ * fake API is bundled too, into `.builds/<sha>/__api/`, so its build asks its
+ * own API, whatever the checkout's API has become since.
+ */
+export declare function createBuilds(options: {
+    root: () => string;
+    git: Git;
+    api?: () => ApiOption | null;
+}): {
+    apiOf: (sha: string) => Promise<BuiltApi | null>;
+    buildOf: (sha: string) => Promise<Build>;
+    requestBuild: (sha: string, retry?: boolean) => Promise<Build>;
+    settled: () => Promise<void>;
+    folder: () => string;
+};

package/dist/vite/builds.js

@@ -0,0 +1,250 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { appendFile, lstat, mkdir, readdir, readFile, rename, rm, rmdir, symlink, unlink, writeFile, } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { dirname, join, relative, resolve } from 'node:path';
+import { appFolder } from './appFolder.js';
+import { bundleApi } from './bundleApi.js';
+import { buildEnvironment } from './environment.js';
+import { isWorkspace } from './isWorkspace.js';
+/** The Vite this plugin runs in, for a commit that has none of its own installed. */
+const ownVite = () => {
+    return join(dirname(createRequire(import.meta.url).resolve('vite/package.json')), 'bin', 'vite.js');
+};
+/** A tree's lockfile and the package manager it belongs to: pnpm, or npm for a commit from before a switch. */
+export async function lockOf(dir) {
+    const pnpm = await readFile(join(dir, 'pnpm-lock.yaml'), 'utf8').catch(() => null);
+    if (pnpm !== null) {
+        return { manager: 'pnpm', text: pnpm };
+    }
+    return {
+        manager: 'npm',
+        text: await readFile(join(dir, 'package-lock.json'), 'utf8').catch(() => null),
+    };
+}
+/**
+ * Builds any commit of the app, one at a time, in a git worktree under
+ * `.builds/work/`, into `.builds/<sha>/`, served under `/__workbench/b/<sha>/`.
+ * The checkout and its uncommitted changes are never touched.
+ *
+ * The app may live in a folder of the repository, such as a pnpm workspace's
+ * `apps/app/`: each commit is built from that folder, or from the top for a
+ * commit from before the app moved there. With `api`, a commit that has the
+ * fake API is bundled too, into `.builds/<sha>/__api/`, so its build asks its
+ * own API, whatever the checkout's API has become since.
+ */
+export function createBuilds(options) {
+    const states = new Map();
+    const queue = [];
+    let busy = false;
+    const folder = () => join(options.root(), '.builds');
+    /** A built commit's fake API, or null when it has none. */
+    async function apiOf(sha) {
+        try {
+            const meta = JSON.parse(await readFile(join(folder(), sha, 'meta.json'), 'utf8'));
+            return meta.ok && meta.api
+                ? { file: join(folder(), sha, meta.api.file), path: meta.api.path }
+                : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async function buildOf(sha) {
+        const live = states.get(sha);
+        if (live) {
+            return live;
+        }
+        try {
+            const meta = JSON.parse(await readFile(join(folder(), sha, 'meta.json'), 'utf8'));
+            const build = meta.ok
+                ? { state: 'built', protocol: meta.protocol ?? 0 }
+                : { state: 'failed', ...(meta.error !== undefined && { error: meta.error }) };
+            states.set(sha, build);
+            return build;
+        }
+        catch {
+            return { state: 'none' };
+        }
+    }
+    async function requestBuild(sha, retry = false) {
+        const build = await buildOf(sha);
+        if (build.state === 'failed' && retry) {
+            states.delete(sha);
+            await rm(join(folder(), sha), { recursive: true, force: true });
+        }
+        else if (build.state !== 'none') {
+            return build;
+        }
+        const queued = { state: 'queued' };
+        states.set(sha, queued);
+        queue.push(sha);
+        void drain();
+        return queued;
+    }
+    /** Waits for the queue to empty, for the tests. */
+    async function settled() {
+        while (busy || queue.length > 0) {
+            await new Promise((resolve) => setTimeout(resolve, 20));
+        }
+    }
+    async function drain() {
+        if (busy) {
+            return;
+        }
+        busy = true;
+        try {
+            for (let sha = queue.shift(); sha; sha = queue.shift()) {
+                await build(sha);
+            }
+        }
+        finally {
+            busy = false;
+        }
+    }
+    /** Runs a command into the build's log, failing on a non-zero exit. */
+    const step = (sha, log, command, args, cwd, name) => {
+        return new Promise((resolve, reject) => {
+            // pnpm and npm are .cmd files on Windows, which only a shell starts; the arguments are ours.
+            const shell = process.platform === 'win32' && (command === 'pnpm' || command === 'npm');
+            const child = spawn(command, args, { cwd, shell, env: buildEnvironment() });
+            const write = (chunk) => {
+                void appendFile(log, chunk);
+            };
+            child.stdout.on('data', write);
+            child.stderr.on('data', write);
+            child.on('error', reject);
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`${name} exited with ${code}`));
+                }
+            });
+            states.set(sha, { state: 'building', step: name });
+        });
+    };
+    async function build(sha) {
+        const root = options.root();
+        const work = join(folder(), 'work', sha);
+        const out = join(folder(), sha);
+        const log = join(folder(), `${sha}.log`);
+        await mkdir(join(folder(), 'work'), { recursive: true });
+        await writeFile(log, `Building ${sha}\n`);
+        states.set(sha, { state: 'building', step: 'checking out' });
+        try {
+            await dropWork(work);
+            await options.git('worktree', 'prune');
+            await options.git('worktree', 'add', '--detach', work, sha);
+            // The worktree is the whole repository; the app is in its folder, or at the top before a move.
+            const top = (await options.git('rev-parse', '--show-toplevel')).trim();
+            const app = appFolder(work, relative(top, root));
+            await addBasePath(app);
+            // A workspace installs, so its packages link to this commit's, not the checkout's. One
+            // package with the same lockfile as the checkout borrows its node_modules. Otherwise the
+            // commit installs its own, with the package manager its lockfile belongs to.
+            const ours = await lockOf(top);
+            const theirs = await lockOf(work);
+            if (await isWorkspace(work)) {
+                await step(sha, log, 'pnpm', ['install', '--frozen-lockfile', '--prefer-offline'], work, 'pnpm install');
+            }
+            else if (theirs.text !== null &&
+                theirs.text === ours.text &&
+                existsSync(join(top, 'node_modules'))) {
+                await symlink(join(top, 'node_modules'), join(work, 'node_modules'), 'junction');
+            }
+            else if (theirs.manager === 'pnpm') {
+                // The worktree sits inside the checkout: a commit with no workspace file of its own
+                // must not take the checkout's for its own.
+                const alone = existsSync(join(work, 'pnpm-workspace.yaml')) ? [] : ['--ignore-workspace'];
+                await step(sha, log, 'pnpm', ['install', '--frozen-lockfile', ...alone], work, 'pnpm install');
+            }
+            else {
+                await step(sha, log, 'npm', ['ci', '--no-audit', '--no-fund', '--loglevel=error'], work, 'npm ci');
+            }
+            const temporary = `${out}.tmp`;
+            await rm(temporary, { recursive: true, force: true });
+            // The commit's own Vite: the app's, then the workspace's, then this plugin's.
+            const vite = [
+                join(app, 'node_modules', 'vite', 'bin', 'vite.js'),
+                join(work, 'node_modules', 'vite', 'bin', 'vite.js'),
+            ].find((file) => existsSync(file)) ?? ownVite();
+            const args = [
+                vite,
+                'build',
+                '--base',
+                `/__workbench/b/${sha}/`,
+                '--outDir',
+                temporary,
+                '--emptyOutDir',
+            ];
+            await step(sha, log, process.execPath, args, app, 'vite build');
+            // Its own fake API, when the commit has one inside the worktree.
+            const api = options.api?.() ?? null;
+            let built = null;
+            const entry = api ? resolve(app, api.entry) : null;
+            if (api && entry && !relative(work, entry).startsWith('..')) {
+                const file = await bundleApi((more, cwd) => step(sha, log, process.execPath, [vite, ...more], cwd, 'API bundle'), app, entry, join(temporary, '__api'));
+                built = file ? { file: `__api/${file}`, path: api.path } : null;
+            }
+            const protocol = (await bundleText(temporary)).includes('aitems-workbench') ? 1 : 0;
+            await writeFile(join(temporary, 'meta.json'), JSON.stringify({
+                sha,
+                ok: true,
+                protocol,
+                builtAt: new Date().toISOString(),
+                ...(built && { api: built }),
+            }));
+            await rm(out, { recursive: true, force: true });
+            await rename(temporary, out);
+            states.set(sha, { state: 'built', protocol });
+        }
+        catch (failure) {
+            const tail = (await readFile(log, 'utf8').catch(() => '')).split('\n').slice(-40).join('\n');
+            const error = `${failure.message}\n${tail}`.trim();
+            await mkdir(out, { recursive: true });
+            await writeFile(join(out, 'meta.json'), JSON.stringify({ sha, ok: false, error, builtAt: new Date().toISOString() }));
+            states.set(sha, { state: 'failed', error });
+        }
+        finally {
+            await dropWork(work);
+        }
+    }
+    /**
+     * Removes a build's worktree. Its node_modules may be a link to the
+     * checkout's: that link goes first, on its own, because removing the
+     * worktree with it in place follows it and empties the checkout's packages.
+     */
+    async function dropWork(work) {
+        const modules = join(work, 'node_modules');
+        if ((await lstat(modules).catch(() => null))?.isSymbolicLink()) {
+            await unlink(modules).catch(() => rmdir(modules));
+        }
+        await options
+            .git('worktree', 'remove', '--force', work)
+            .catch(() => rm(work, { recursive: true, force: true }));
+    }
+    return { apiOf, buildOf, requestBuild, settled, folder };
+}
+/**
+ * A router made before the app was served under a base path matches nothing
+ * there; such a commit's TanStack router is given `import.meta.env.BASE_URL`.
+ */
+async function addBasePath(app) {
+    const main = join(app, 'src', 'main.tsx');
+    if (!existsSync(main)) {
+        return;
+    }
+    const source = await readFile(main, 'utf8');
+    if (source.includes('createRouter({ routeTree })')) {
+        await writeFile(main, source.replace('createRouter({ routeTree })', 'createRouter({ routeTree, basepath: import.meta.env.BASE_URL })'));
+    }
+}
+async function bundleText(dir) {
+    const assets = join(dir, 'assets');
+    const files = existsSync(assets)
+        ? (await readdir(assets)).filter((file) => file.endsWith('.js'))
+        : [];
+    return (await Promise.all(files.map((file) => readFile(join(assets, file), 'utf8')))).join('\n');
+}

package/dist/vite/bundleApi.d.ts

@@ -0,0 +1,9 @@
+/** Runs that commit's Vite with these arguments, in that folder. */
+export type RunVite = (args: string[], cwd: string) => Promise<void>;
+/**
+ * Bundles a commit's fake API, `entry`, into `out`: one module with every
+ * package inside it, so it still runs once the commit's worktree is gone.
+ * The commit's own Vite builds it, without the app's config or plugins. Gives
+ * the bundle's file name in `out`, or null when the commit has no fake API.
+ */
+export declare function bundleApi(runVite: RunVite, app: string, entry: string, out: string): Promise<string | null>;

package/dist/vite/bundleApi.js

@@ -0,0 +1,32 @@
+import { existsSync } from 'node:fs';
+import { readdir, rm, writeFile } from 'node:fs/promises';
+import { basename, extname, join } from 'node:path';
+/**
+ * Bundles a commit's fake API, `entry`, into `out`: one module with every
+ * package inside it, so it still runs once the commit's worktree is gone.
+ * The commit's own Vite builds it, without the app's config or plugins. Gives
+ * the bundle's file name in `out`, or null when the commit has no fake API.
+ */
+export async function bundleApi(runVite, app, entry, out) {
+    if (!existsSync(entry)) {
+        return null;
+    }
+    const config = join(app, '.workbench-api.config.mjs');
+    await writeFile(config, `export default ${JSON.stringify({
+        logLevel: 'warn',
+        publicDir: false,
+        build: { ssr: entry, outDir: out, emptyOutDir: true, minify: false, copyPublicDir: false },
+        ssr: { noExternal: true, target: 'node' },
+    })};\n`);
+    try {
+        await runVite(['build', '--config', config], app);
+    }
+    finally {
+        await rm(config, { force: true });
+    }
+    // The bundle is a module wherever it sits, whatever package.json is above it.
+    await writeFile(join(out, 'package.json'), '{ "type": "module" }\n');
+    const name = basename(entry, extname(entry));
+    const files = await readdir(out);
+    return files.find((file) => file === `${name}.js` || file === `${name}.mjs`) ?? null;
+}

package/dist/vite/checkout.d.ts

@@ -0,0 +1,11 @@
+import type { Git } from './git.js';
+interface Answer {
+    status: number;
+    body: Record<string, unknown>;
+}
+/**
+ * Checks a branch out, refused while anything is uncommitted. When the
+ * lockfile changes, installs and restarts the dev server.
+ */
+export declare function checkout(git: Git, root: string, branch: string, restart: () => void): Promise<Answer>;
+export {};

package/dist/vite/checkout.js

@@ -0,0 +1,43 @@
+import { spawn } from 'node:child_process';
+import { lockOf } from './builds.js';
+/**
+ * Checks a branch out, refused while anything is uncommitted. When the
+ * lockfile changes, installs and restarts the dev server.
+ */
+export async function checkout(git, root, branch, restart) {
+    const changed = (await git('status', '--porcelain')).split('\n').filter(Boolean).length;
+    if (changed) {
+        return {
+            status: 409,
+            body: { error: `You have ${changed} changed files. Commit or stash them first.`, changed },
+        };
+    }
+    const known = (await git('for-each-ref', '--format=%(refname:short)', `refs/heads/${branch}`, `refs/remotes/origin/${branch}`)).trim();
+    if (!known) {
+        return { status: 404, body: { error: `No branch ${branch}` } };
+    }
+    const before = (await lockOf(root)).text;
+    await git('switch', branch);
+    const after = await lockOf(root);
+    const installed = before !== after.text;
+    if (installed) {
+        await new Promise((resolve, reject) => {
+            const args = after.manager === 'pnpm' ? ['install'] : ['install', '--no-audit', '--no-fund'];
+            const child = spawn(after.manager, args, {
+                cwd: root,
+                shell: process.platform === 'win32',
+                stdio: 'inherit',
+            });
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`${after.manager} install exited with ${code}`));
+                }
+            });
+        });
+        setTimeout(restart, 50);
+    }
+    return { status: 200, body: { current: branch, installed } };
+}

package/dist/vite/environment.d.ts

@@ -0,0 +1,9 @@
+/** Every setting the local builds service reads from the environment. */
+export declare const environment: {
+    /** The viewer's address. Without it, the dev server opens no viewer. */
+    viewerUrl: string | null;
+    /** The package script that started the dev server: only `dev` opens the viewer. */
+    script: string | null;
+};
+/** What a build's install and bundle run with: this environment, as CI. */
+export declare const buildEnvironment: () => NodeJS.ProcessEnv;

package/dist/vite/environment.js

@@ -0,0 +1,10 @@
+const viewer = process.env['WORKBENCH_URL']?.replace(/\/$/, '');
+/** Every setting the local builds service reads from the environment. */
+export const environment = {
+    /** The viewer's address. Without it, the dev server opens no viewer. */
+    viewerUrl: viewer === undefined || viewer === '' ? null : viewer,
+    /** The package script that started the dev server: only `dev` opens the viewer. */
+    script: process.env['npm_lifecycle_event'] ?? null,
+};
+/** What a build's install and bundle run with: this environment, as CI. */
+export const buildEnvironment = () => ({ ...process.env, CI: '1' });

package/dist/vite/fetchBridge.d.ts

@@ -0,0 +1,8 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+/**
+ * A Node request as a fetch `Request` for a fake API, at `path`: the part of
+ * the address after the API's mount, with its query.
+ */
+export declare function toRequest(request: IncomingMessage, path: string): Promise<Request>;
+/** Writes a fake API's fetch `Response` to a Node response. */
+export declare function sendResponse(response: ServerResponse, answer: Response): Promise<void>;

package/dist/vite/fetchBridge.js

@@ -0,0 +1,42 @@
+/** Headers Node works out for itself, from what it sends. */
+const COMPUTED = new Set(['content-length', 'transfer-encoding', 'connection']);
+const bodyOf = (request) => {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        request.on('data', (chunk) => chunks.push(chunk));
+        request.on('end', () => resolve(Buffer.concat(chunks)));
+        request.on('error', reject);
+    });
+};
+/**
+ * A Node request as a fetch `Request` for a fake API, at `path`: the part of
+ * the address after the API's mount, with its query.
+ */
+export async function toRequest(request, path) {
+    const method = request.method ?? 'GET';
+    const headers = new Headers();
+    for (const [name, value] of Object.entries(request.headers)) {
+        if (value === undefined) {
+            continue;
+        }
+        for (const each of Array.isArray(value) ? value : [value]) {
+            headers.append(name, each);
+        }
+    }
+    const body = method === 'GET' || method === 'HEAD' ? null : Uint8Array.from(await bodyOf(request));
+    return new Request(new URL(path, 'http://localhost'), { method, headers, body });
+}
+/** Writes a fake API's fetch `Response` to a Node response. */
+export async function sendResponse(response, answer) {
+    response.statusCode = answer.status;
+    answer.headers.forEach((value, name) => {
+        if (!COMPUTED.has(name) && name !== 'set-cookie') {
+            response.setHeader(name, value);
+        }
+    });
+    const cookies = answer.headers.getSetCookie();
+    if (cookies.length > 0) {
+        response.setHeader('set-cookie', cookies);
+    }
+    response.end(Buffer.from(await answer.arrayBuffer()));
+}

package/dist/vite/git.d.ts

@@ -0,0 +1,7 @@
+export type Git = (...args: string[]) => Promise<string>;
+/** Runs git in a repository, and gives its output. */
+export declare function gitIn(root: string): Git;
+/** Whether a ref names a commit. */
+export declare const refExists: (git: Git, ref: string) => Promise<boolean>;
+/** The repository's default branch, as its remote has it, or `main`. */
+export declare function defaultBranch(git: Git): Promise<string>;

package/dist/vite/git.js

@@ -0,0 +1,18 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const run = promisify(execFile);
+/** Runs git in a repository, and gives its output. */
+export function gitIn(root) {
+    return async (...args) => {
+        return (await run('git', args, { cwd: root, maxBuffer: 16 * 1024 * 1024 })).stdout;
+    };
+}
+/** Whether a ref names a commit. */
+export const refExists = (git, ref) => {
+    return git('rev-parse', '--verify', '--quiet', ref).then(() => true, () => false);
+};
+/** The repository's default branch, as its remote has it, or `main`. */
+export async function defaultBranch(git) {
+    const head = await git('symbolic-ref', '--short', 'refs/remotes/origin/HEAD').catch(() => '');
+    return head.trim().replace(/^origin\//, '') || 'main';
+}

package/dist/vite/index.d.ts

@@ -0,0 +1 @@
+export { workbenchLocal } from './workbenchLocal.js';

package/dist/vite/index.js

@@ -0,0 +1 @@
+export { workbenchLocal } from './workbenchLocal.js';

package/dist/vite/isWorkspace.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Whether a tree is a pnpm workspace of several packages. A pnpm-workspace.yaml
+ * without `packages` only holds settings for one package.
+ */
+export declare function isWorkspace(tree: string): Promise<boolean>;

package/dist/vite/isWorkspace.js

@@ -0,0 +1,10 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+/**
+ * Whether a tree is a pnpm workspace of several packages. A pnpm-workspace.yaml
+ * without `packages` only holds settings for one package.
+ */
+export async function isWorkspace(tree) {
+    const text = await readFile(join(tree, 'pnpm-workspace.yaml'), 'utf8').catch(() => '');
+    return /^packages\s*:/m.test(text);
+}