@trypattern/sdk 0.0.0-stage → 0.1.1

package/dist/cli/publishing.d.ts

@@ -0,0 +1,21 @@
+type Outcome = {
+    code: number;
+    data: Record<string, unknown>;
+    text: string;
+};
+export type PublishingIo = {
+    say: (line: string) => void;
+    openUrl: (url: string) => void;
+    run: (bin: string, args: readonly string[], cwd: string) => Promise<{
+        code: number;
+        output: string;
+    }>;
+    build: () => Promise<Outcome>;
+    sdkVersion: string;
+};
+export declare function login(io: PublishingIo): Promise<Outcome>;
+export declare function pull(io: PublishingIo, name: string | undefined, cwd: string): Promise<Outcome>;
+export declare function publish(io: PublishingIo, root: string, isStarter: boolean): Promise<Outcome>;
+export declare function versions(io: PublishingIo, root: string): Promise<Outcome>;
+export declare function restore(io: PublishingIo, root: string, number: string | undefined): Promise<Outcome>;
+export {};

package/dist/cli/publishing.js

@@ -0,0 +1,493 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { homedir, hostname, userInfo } from 'node:os';
+import { basename, dirname, extname, join, matchesGlob, relative } from 'node:path';
+import { z } from 'zod';
+import { DASHBOARD_URL, UPLOAD, appSummary, isPrivatePath, loginPoll, loginStarted, nameProblem, publishSummary, sourcePathProblem } from "../publishWire.js";
+import { appInfo } from "../appTitle.js";
+import { PROJECT_FILE, readProjectFile } from "../vite/projectFile.js";
+const CONFIG_DIR = join(homedir(), '.config', 'pattern');
+const CREDENTIALS_FILE = join(CONFIG_DIR, 'credentials.json');
+const PENDING_FILE = join(CONFIG_DIR, 'pending-login.json');
+const LOGIN_MINUTES = 10;
+const POLL_MS = 2000;
+const LOGIN_WAIT_MS = 120_000;
+const PUBLISH_WAIT_MS = 300_000;
+const SESSION_COOKIE = 'pattern_session';
+const IGNORED_IN_EMPTY_FOLDER = new Set(['.DS_Store', '.claude']);
+const MIME_TYPES = {
+    '.html': 'text/html',
+    '.js': 'text/javascript',
+    '.mjs': 'text/javascript',
+    '.css': 'text/css',
+    '.json': 'application/json',
+    '.map': 'application/json',
+    '.webmanifest': 'application/manifest+json',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.avif': 'image/avif',
+    '.ico': 'image/x-icon',
+    '.woff2': 'font/woff2',
+    '.woff': 'font/woff',
+    '.txt': 'text/plain',
+    '.xml': 'application/xml',
+    '.pdf': 'application/pdf',
+    '.mp4': 'video/mp4',
+    '.sql': 'application/sql'
+};
+const STEP_WORDS = {
+    reserve: 'Reserving the address',
+    database: 'Updating the database',
+    'sign-in': 'Turning on sign-in',
+    publish: 'Publishing the site'
+};
+function dashboard() {
+    return (process.env['PATTERN_DASHBOARD_URL'] ?? DASHBOARD_URL).replace(/\/$/, '');
+}
+const credentials = z.record(z.string(), z.object({ cookie: z.string() }));
+const pendingLogin = z.object({
+    dashboard: z.string(),
+    secret: z.string(),
+    code: z.string(),
+    url: z.string(),
+    startedAt: z.number()
+});
+function readJson(path, schema) {
+    try {
+        const parsed = schema.safeParse(JSON.parse(readFileSync(path, 'utf8')));
+        return parsed.success ? parsed.data : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function writePrivate(path, value) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+}
+function savedCookie() {
+    return readJson(CREDENTIALS_FILE, credentials)?.[dashboard()]?.cookie;
+}
+function saveCookie(cookie) {
+    const all = { ...readJson(CREDENTIALS_FILE, credentials) };
+    if (cookie === undefined)
+        delete all[dashboard()];
+    else
+        all[dashboard()] = { cookie };
+    writePrivate(CREDENTIALS_FILE, all);
+}
+class SignedOut extends Error {
+}
+async function call(path, init = {}) {
+    const cookie = savedCookie();
+    if (cookie === undefined)
+        throw new SignedOut();
+    const response = await fetch(`${dashboard()}${path}`, {
+        ...init,
+        headers: {
+            ...init.headers,
+            cookie,
+            origin: dashboard()
+        }
+    });
+    const renewed = response.headers
+        .getSetCookie()
+        .find((line) => line.startsWith(`${SESSION_COOKIE}=`));
+    if (renewed !== undefined) {
+        const pair = renewed.split(';')[0] ?? '';
+        if (pair !== `${SESSION_COOKIE}=`)
+            saveCookie(pair);
+    }
+    if (response.status === 401) {
+        saveCookie(undefined);
+        throw new SignedOut();
+    }
+    return response;
+}
+async function callJson(path, schema, init = {}) {
+    const response = await call(path, init);
+    const body = await response.json().catch(() => null);
+    if (!response.ok) {
+        const error = Reflect.get(Object(body), 'error');
+        throw new Error(typeof error === 'string' ? error : `HTTP ${response.status}`);
+    }
+    return schema.parse(body);
+}
+function labelOfThisMachine() {
+    const machine = hostname().replace(/\.local$/, '');
+    return `${userInfo().username} on ${machine}`.slice(0, 80);
+}
+function sleep(ms) {
+    return new Promise((done) => setTimeout(done, ms));
+}
+async function waitForApproval(secret) {
+    const deadline = Date.now() + LOGIN_WAIT_MS;
+    while (Date.now() < deadline) {
+        const response = await fetch(`${dashboard()}/api/auth/cli/logins/${secret}`);
+        const poll = loginPoll.safeParse(await response.json().catch(() => null));
+        if (poll.success && poll.data.status === 'approved')
+            return poll.data.cookie;
+        await sleep(POLL_MS);
+    }
+    return undefined;
+}
+async function signIn(io, again) {
+    const pending = readJson(PENDING_FILE, pendingLogin);
+    const isFresh = pending !== undefined &&
+        pending.dashboard === dashboard() &&
+        Date.now() - pending.startedAt < LOGIN_MINUTES * 60_000;
+    if (pending !== undefined && isFresh) {
+        io.say(`Waiting for Allow on ${pending.url} (code ${pending.code})`);
+        const cookie = await waitForApproval(pending.secret);
+        if (cookie !== undefined) {
+            saveCookie(cookie);
+            rmSync(PENDING_FILE, { force: true });
+            return { code: 0, data: { signedIn: true }, text: '✓ Signed in' };
+        }
+        return {
+            code: 3,
+            data: { waitingFor: 'approval', code: pending.code, url: pending.url },
+            text: `✗ Not allowed yet. The browser page ${pending.url} shows the code ${pending.code}.\n  next  once they click Allow there, run ${again} again`
+        };
+    }
+    const response = await fetch(`${dashboard()}/api/auth/cli/logins`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ label: labelOfThisMachine() })
+    });
+    const started = loginStarted.parse(await response.json());
+    writePrivate(PENDING_FILE, {
+        dashboard: dashboard(),
+        ...started,
+        startedAt: Date.now()
+    });
+    io.openUrl(started.url);
+    return {
+        code: 3,
+        data: { waitingFor: 'approval', code: started.code, url: started.url },
+        text: `Opened ${started.url} in the browser.\n  code  ${started.code}\n  next  tell them: "Check the code on the page is ${started.code}, then click Allow." Then run ${again} again.`
+    };
+}
+async function signedIn(io, again, work) {
+    if (savedCookie() === undefined) {
+        const outcome = await signIn(io, again);
+        if (outcome.code !== 0)
+            return outcome;
+    }
+    try {
+        return await work();
+    }
+    catch (error) {
+        if (!(error instanceof SignedOut))
+            throw error;
+        const outcome = await signIn(io, again);
+        if (outcome.code !== 0)
+            return outcome;
+        return work();
+    }
+}
+function isOutcome(value) {
+    return typeof value === 'object' && value !== null && 'text' in value;
+}
+function failure(error, data = {}) {
+    const message = error instanceof TypeError && error.message === 'fetch failed'
+        ? `Couldn’t reach ${dashboard()}. Check the internet connection and try again.`
+        : error instanceof Error
+            ? error.message
+            : String(error);
+    return { code: 1, data: { ...data, error: message }, text: `✗ ${message}` };
+}
+export async function login(io) {
+    try {
+        if (savedCookie() !== undefined) {
+            const me = await call('/api/me').catch(() => undefined);
+            if (me?.ok === true) {
+                return {
+                    code: 0,
+                    data: { signedIn: true },
+                    text: '✓ Already signed in'
+                };
+            }
+        }
+        return await signIn(io, 'app login');
+    }
+    catch (error) {
+        return failure(error);
+    }
+}
+function isEmptyFolder(path) {
+    return readdirSync(path).every((entry) => IGNORED_IN_EMPTY_FOLDER.has(entry));
+}
+function commandLineToolsReady() {
+    return spawnSync('xcode-select', ['-p'], { stdio: 'ignore' }).status === 0;
+}
+export async function pull(io, name, cwd) {
+    if (name === undefined || nameProblem(name) !== undefined) {
+        return {
+            code: 2,
+            data: { error: 'missing name' },
+            text: '✗ Which site? app pull sundayparty'
+        };
+    }
+    const target = isEmptyFolder(cwd) ? cwd : join(cwd, name);
+    if (target !== cwd && existsSync(target) && !isEmptyFolder(target)) {
+        return {
+            code: 1,
+            data: { error: 'folder not empty', folder: target },
+            text: `✗ ${target} already has files in it. Pull into an empty folder.`
+        };
+    }
+    try {
+        const result = await signedIn(io, `app pull ${name}`, async () => {
+            const app = await callJson(`/api/apps/${name}`, appSummary);
+            const response = await call(`/api/apps/${name}/source`);
+            if (!response.ok)
+                throw new Error(`Couldn’t download ${name}`);
+            const number = response.headers.get('x-pattern-publish') ?? '?';
+            const live = await fetch(`${app.url}/api/app`)
+                .then((reply) => reply.json())
+                .then((body) => appInfo.parse(body).title)
+                .catch(() => '');
+            const title = live === '' ? app.title : live;
+            return { app, title, number, form: await response.formData() };
+        });
+        if (isOutcome(result))
+            return result;
+        let files = 0;
+        for (const [key, value] of result.form.entries()) {
+            if (!key.startsWith(UPLOAD.source) || typeof value === 'string')
+                continue;
+            const path = key.slice(UPLOAD.source.length);
+            if (sourcePathProblem(path) !== undefined)
+                continue;
+            const destination = join(target, path);
+            mkdirSync(dirname(destination), { recursive: true });
+            writeFileSync(destination, Buffer.from(await value.arrayBuffer()));
+            files += 1;
+        }
+        writeFileSync(join(target, PROJECT_FILE), `${JSON.stringify({ name, title: result.title }, null, 2)}\n`);
+        io.say(`✓ Downloaded ${files} files of version ${result.number}`);
+        const install = await io.run('pnpm', ['install'], target);
+        if (install.code !== 0) {
+            return failure(new Error(`pnpm install failed\n${install.output}`));
+        }
+        io.say('✓ Installed');
+        const setup = await io.run(join(target, 'app'), ['setup'], target);
+        if (setup.code !== 0)
+            io.say(setup.output.trimEnd());
+        if (commandLineToolsReady() && !existsSync(join(target, '.git'))) {
+            await io.run('git', ['init', '-q'], target);
+            await io.run('git', ['add', '-A'], target);
+            await io.run('git', ['commit', '-q', '-m', `Version ${result.number} from onpattern.app`], target);
+        }
+        const moved = target === cwd ? '' : `\n  folder  ${target} (open this folder in Claude)`;
+        return {
+            code: 0,
+            data: { name, folder: target, version: result.number, files },
+            text: `✓ ${result.title} is on this computer${moved}\n  next  read AGENTS.md, then app start`
+        };
+    }
+    catch (error) {
+        return failure(error);
+    }
+}
+function filesUnder(root) {
+    if (!existsSync(root))
+        return [];
+    return readdirSync(root, { recursive: true, withFileTypes: true })
+        .filter((entry) => entry.isFile())
+        .map((entry) => relative(root, join(entry.parentPath, entry.name)));
+}
+function ignoredPatterns(root) {
+    const path = join(root, '.gitignore');
+    if (!existsSync(path))
+        return [];
+    return readFileSync(path, 'utf8')
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line !== '' && !line.startsWith('#'))
+        .map((line) => line.replace(/^\//, '').replace(/\/$/, ''));
+}
+function sourceFiles(root) {
+    const git = existsSync(join(root, '.git')) || commandLineToolsReady()
+        ? spawnSync('git', ['ls-files', '--cached', '--others', '--exclude-standard', '-z'], { cwd: root, encoding: 'utf8' })
+        : undefined;
+    const listed = git !== undefined && git.status === 0
+        ? git.stdout.split('\0').filter((path) => path !== '')
+        : filesUnder(root).filter((path) => {
+            const patterns = ignoredPatterns(root);
+            return !patterns.some((pattern) => matchesGlob(path, pattern) ||
+                path.split('/').some((part) => matchesGlob(part, pattern)));
+        });
+    return listed.filter((path) => sourcePathProblem(path) === undefined &&
+        existsSync(join(root, path)) &&
+        statSync(join(root, path)).isFile());
+}
+function fileBlob(path, contents) {
+    return new Blob([contents ?? readFileSync(path)], {
+        type: MIME_TYPES[extname(path).toLowerCase()] ?? 'application/octet-stream'
+    });
+}
+function workerDirectory(dist) {
+    return readdirSync(dist, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && entry.name !== 'client')
+        .map((entry) => join(dist, entry.name))
+        .filter((path) => existsSync(join(path, 'wrangler.json')))
+        .toSorted((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs)[0];
+}
+function starterPackageJson(path, sdkVersion) {
+    return readFileSync(path, 'utf8').replace(/"@trypattern\/sdk": "workspace:[^"]*"/, `"@trypattern/sdk": "${sdkVersion}"`);
+}
+function uploadForm(root, io, isStarter) {
+    const dist = join(root, 'dist');
+    const worker = workerDirectory(dist);
+    if (worker === undefined)
+        throw new Error('The build left no worker in dist/');
+    const wrangler = JSON.parse(readFileSync(join(worker, 'wrangler.json'), 'utf8'));
+    const form = new FormData();
+    form.append(UPLOAD.compatibilityDate, String(Reflect.get(Object(wrangler), 'compatibility_date') ?? ''));
+    form.append(UPLOAD.sdkVersion, io.sdkVersion);
+    for (const file of readdirSync(worker)) {
+        if (!file.endsWith('.js') || isPrivatePath(file))
+            continue;
+        form.append(`${UPLOAD.worker}${file}`, fileBlob(join(worker, file)), file);
+    }
+    for (const path of filesUnder(join(dist, 'client'))) {
+        if (basename(path) === '.assetsignore' || isPrivatePath(path))
+            continue;
+        form.append(`${UPLOAD.client}${path}`, fileBlob(join(dist, 'client', path)), basename(path));
+    }
+    const migrations = join(root, 'server', 'migrations');
+    for (const file of existsSync(migrations) ? readdirSync(migrations) : []) {
+        if (!file.endsWith('.sql'))
+            continue;
+        form.append(`${UPLOAD.migrations}${file}`, fileBlob(join(migrations, file)), file);
+    }
+    const sources = sourceFiles(root);
+    for (const path of sources) {
+        const full = join(root, path);
+        const contents = isStarter && path === 'package.json'
+            ? starterPackageJson(full, io.sdkVersion)
+            : undefined;
+        form.append(`${UPLOAD.source}${path}`, fileBlob(full, contents), basename(path));
+    }
+    return { form, sources: sources.length };
+}
+async function followPublish(io, name, started) {
+    let publish = started;
+    let shown;
+    const deadline = Date.now() + PUBLISH_WAIT_MS;
+    while (publish.status === 'running' && Date.now() < deadline) {
+        if (publish.step !== shown) {
+            io.say(`  ${STEP_WORDS[publish.step]}…`);
+            shown = publish.step;
+        }
+        await sleep(POLL_MS);
+        publish = await callJson(`/api/apps/${name}/publishes/${publish.number}`, publishSummary);
+    }
+    const data = { name, version: publish.number, status: publish.status };
+    if (publish.status === 'live') {
+        return {
+            code: 0,
+            data,
+            text: `✓ Version ${publish.number} is live at https://${name}.onpattern.app`
+        };
+    }
+    if (publish.status === 'failed') {
+        return {
+            code: 1,
+            data: { ...data, error: publish.error },
+            text: `✗ Version ${publish.number} didn’t go live: ${publish.error ?? 'no details'}\n  The site still runs the previous version.`
+        };
+    }
+    return {
+        code: 1,
+        data,
+        text: `✗ Version ${publish.number} is still publishing after ${PUBLISH_WAIT_MS / 60_000} minutes\n  next  app versions shows how it ends`
+    };
+}
+export async function publish(io, root, isStarter) {
+    try {
+        const { name } = readProjectFile(root);
+        const built = await io.build();
+        if (built.code !== 0)
+            return built;
+        io.say('✓ Built');
+        const { form, sources } = uploadForm(root, io, isStarter);
+        io.say(`✓ Packed the build and ${sources} source files`);
+        const again = isStarter ? 'app publish --starter' : 'app publish';
+        const result = await signedIn(io, again, async () => {
+            if (isStarter) {
+                await callJson('/api/starters', z.object({ key: z.string() }), {
+                    method: 'POST',
+                    body: form
+                });
+                return undefined;
+            }
+            return callJson(`/api/apps/${name}/publishes`, publishSummary, {
+                method: 'POST',
+                body: form
+            });
+        });
+        if (isOutcome(result))
+            return result;
+        if (result === undefined) {
+            return {
+                code: 0,
+                data: { starter: io.sdkVersion },
+                text: `✓ Published the starter for SDK ${io.sdkVersion}`
+            };
+        }
+        return await followPublish(io, name, result);
+    }
+    catch (error) {
+        return failure(error);
+    }
+}
+export async function versions(io, root) {
+    try {
+        const { name } = readProjectFile(root);
+        const result = await signedIn(io, 'app versions', () => callJson(`/api/apps/${name}/publishes`, z.array(publishSummary)));
+        if (isOutcome(result))
+            return result;
+        const lines = result.map((item) => {
+            const what = item.restoredFrom !== null
+                ? `restored version ${item.restoredFrom}`
+                : item.isStarter
+                    ? 'starter site'
+                    : `published by ${item.byEmail}`;
+            return `  ${String(item.number).padStart(3)}  ${item.status.padEnd(7)}  ${item.startedAt.slice(0, 16).replace('T', ' ')}  ${what}`;
+        });
+        return {
+            code: 0,
+            data: { name, versions: result },
+            text: [`Versions of ${name} (newest first)`, ...lines].join('\n')
+        };
+    }
+    catch (error) {
+        return failure(error);
+    }
+}
+export async function restore(io, root, number) {
+    if (number === undefined || !/^\d+$/.test(number)) {
+        return {
+            code: 2,
+            data: { error: 'missing version' },
+            text: '✗ Which version? app restore 3 (app versions lists them)'
+        };
+    }
+    try {
+        const { name } = readProjectFile(root);
+        const result = await signedIn(io, `app restore ${number}`, () => callJson(`/api/apps/${name}/publishes/${number}/restore`, publishSummary, { method: 'POST' }));
+        if (isOutcome(result))
+            return result;
+        return await followPublish(io, name, result);
+    }
+    catch (error) {
+        return failure(error);
+    }
+}

package/dist/cli/screenshot.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/screenshot.js

@@ -0,0 +1,96 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { launchChrome, openApp, viewportNames, viewports } from "../flows/browser.js";
+const ROOT = process.cwd();
+const SCREENSHOTS_DIRECTORY = join(ROOT, '.dev', 'screenshots');
+function readRequest() {
+    const parsed = JSON.parse(process.argv[2] ?? '');
+    if (typeof parsed !== 'object' ||
+        parsed === null ||
+        !('url' in parsed) ||
+        !('path' in parsed) ||
+        !('name' in parsed) ||
+        !('commands' in parsed) ||
+        !('signedInAs' in parsed) ||
+        (typeof parsed.signedInAs !== 'string' && parsed.signedInAs !== null) ||
+        typeof parsed.url !== 'string' ||
+        typeof parsed.path !== 'string' ||
+        typeof parsed.name !== 'string' ||
+        !Array.isArray(parsed.commands)) {
+        throw new Error('screenshot.ts expects {url, path, name, commands, signedInAs} JSON');
+    }
+    return {
+        url: parsed.url,
+        path: parsed.path,
+        name: parsed.name,
+        commands: parsed.commands,
+        signedInAs: parsed.signedInAs
+    };
+}
+async function captureAll(browser, request) {
+    const [first = 'desktop'] = viewportNames;
+    const app = await openApp(browser, request.url, request.path, first, request.signedInAs);
+    try {
+        let snapshot = await app.snapshot();
+        let commandError;
+        for (const command of request.commands) {
+            try {
+                snapshot = await app.send(command);
+            }
+            catch (error) {
+                commandError = `command ${JSON.stringify(command)} failed: ${error instanceof Error ? error.message : String(error)}`;
+                break;
+            }
+        }
+        const shots = [];
+        for (const viewport of viewportNames) {
+            const seenBefore = app.problems.length;
+            const file = join(SCREENSHOTS_DIRECTORY, `${request.name}-${viewport}.png`);
+            writeFileSync(file, Buffer.from(await app.captureAt(viewport), 'base64'));
+            const problems = [
+                ...(commandError === undefined ? [] : [commandError]),
+                ...(viewport === first ? app.problems : app.problems.slice(seenBefore))
+            ];
+            shots.push({ viewport, ...viewports[viewport], file, snapshot, problems });
+        }
+        return shots;
+    }
+    finally {
+        await app.close();
+    }
+}
+async function main() {
+    try {
+        const request = readRequest();
+        mkdirSync(SCREENSHOTS_DIRECTORY, { recursive: true });
+        const browser = await launchChrome();
+        const shots = await captureAll(browser, request).finally(() => browser.close());
+        const viewportsByProblem = new Map();
+        for (const shot of shots) {
+            for (const problem of shot.problems) {
+                viewportsByProblem.set(problem, [
+                    ...(viewportsByProblem.get(problem) ?? []),
+                    shot.viewport
+                ]);
+            }
+        }
+        const result = {
+            screenshots: shots.map(({ viewport, width, height, file }) => ({
+                viewport,
+                width,
+                height,
+                file
+            })),
+            snapshot: shots[0]?.snapshot ?? null,
+            problems: [...viewportsByProblem].map(([message, seenIn]) => ({
+                message,
+                viewports: seenIn
+            }))
+        };
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+    }
+    catch (error) {
+        process.stdout.write(`${JSON.stringify({ error: error instanceof Error ? error.message : String(error) })}\n`);
+    }
+}
+await main();

package/dist/cli/tools.d.ts

@@ -0,0 +1,12 @@
+declare const TOOLS: {
+    readonly tsc: readonly ["typescript", "tsc"];
+    readonly oxlint: readonly ["oxlint", "oxlint"];
+    readonly prettier: readonly ["prettier", "prettier"];
+    readonly vite: readonly ["vite", "vite"];
+    readonly vitest: readonly ["vitest", "vitest"];
+    readonly wrangler: readonly ["wrangler", "wrangler"];
+    readonly 'drizzle-kit': readonly ["drizzle-kit", "drizzle-kit"];
+};
+export type Tool = keyof typeof TOOLS;
+export declare function toolBin(tool: Tool): string;
+export {};

package/dist/cli/tools.js

@@ -0,0 +1,35 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+const require = createRequire(import.meta.url);
+const TOOLS = {
+    tsc: ['typescript', 'tsc'],
+    oxlint: ['oxlint', 'oxlint'],
+    prettier: ['prettier', 'prettier'],
+    vite: ['vite', 'vite'],
+    vitest: ['vitest', 'vitest'],
+    wrangler: ['wrangler', 'wrangler'],
+    'drizzle-kit': ['drizzle-kit', 'drizzle-kit']
+};
+export function toolBin(tool) {
+    const [name, bin] = TOOLS[tool];
+    const manifest = (require.resolve.paths(name) ?? [])
+        .map((directory) => join(directory, name, 'package.json'))
+        .find((path) => existsSync(path));
+    if (manifest === undefined) {
+        throw new Error(`${name} is not installed`);
+    }
+    const parsed = JSON.parse(readFileSync(manifest, 'utf8'));
+    const bins = typeof parsed === 'object' && parsed !== null && 'bin' in parsed
+        ? parsed.bin
+        : undefined;
+    const path = typeof bins === 'string'
+        ? bins
+        : typeof bins === 'object' && bins !== null
+            ? Reflect.get(bins, bin)
+            : undefined;
+    if (typeof path !== 'string') {
+        throw new Error(`${name} has no ${bin} command`);
+    }
+    return join(dirname(manifest), path);
+}

package/dist/clock.d.ts

@@ -0,0 +1,6 @@
+export type Clock = {
+    every: (ms: number, run: () => void) => () => void;
+    tick: () => void;
+};
+export declare function realClock(): Clock;
+export declare function manualClock(): Clock;