@wacht/bench 0.1.0

package/dist/openapi.js

@@ -0,0 +1,259 @@
+import { mkdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { AUTH_DIR, OPENAPI_CACHE_FILE, PLATFORM_OPENAPI_URL } from './config.js';
+import { readBenchContext } from './context-store.js';
+import { entries, requestBody, machineRequest } from './machine-api.js';
+import { field, log, printBannerFor, printJson, section, warning } from './ui.js';
+const OPENAPI_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+const HTTP_METHODS = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options'];
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function asSpec(value) {
+    if (!isRecord(value) || !isRecord(value.paths)) {
+        throw new Error('OpenAPI document is missing paths.');
+    }
+    return value;
+}
+async function readCache() {
+    try {
+        const [file, metadata] = await Promise.all([
+            readFile(OPENAPI_CACHE_FILE, 'utf8'),
+            stat(OPENAPI_CACHE_FILE),
+        ]);
+        const ageMs = Date.now() - metadata.mtimeMs;
+        return {
+            spec: asSpec(JSON.parse(file)),
+            source: ageMs > OPENAPI_CACHE_TTL_MS ? 'cache-stale' : 'cache',
+            cacheAgeMs: ageMs,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function fetchSpec() {
+    const response = await fetch(PLATFORM_OPENAPI_URL);
+    if (!response.ok) {
+        throw new Error(`OpenAPI fetch failed: HTTP ${response.status}`);
+    }
+    return asSpec(await response.json());
+}
+export async function loadOpenApiSpec(ctx, options = {}) {
+    const cached = await readCache();
+    if (cached && cached.source === 'cache' && !options.refresh)
+        return cached;
+    try {
+        const spec = await fetchSpec();
+        await mkdir(AUTH_DIR, { recursive: true });
+        await writeFile(OPENAPI_CACHE_FILE, `${JSON.stringify(spec, null, 2)}\n`, { mode: 0o600 });
+        return { spec, source: 'network', cacheAgeMs: 0 };
+    }
+    catch (error) {
+        if (cached) {
+            log(ctx, warning(`Using stale OpenAPI cache: ${error instanceof Error ? error.message : String(error)}`));
+            return { ...cached, source: 'cache-stale' };
+        }
+        throw error;
+    }
+}
+function operations(spec) {
+    const result = [];
+    for (const [path, pathItem] of Object.entries(spec.paths ?? {})) {
+        if (!isRecord(pathItem))
+            continue;
+        for (const method of HTTP_METHODS) {
+            const operation = pathItem[method];
+            if (!isRecord(operation))
+                continue;
+            const typed = operation;
+            result.push({
+                operationId: typed.operationId ?? `${method}_${path.replace(/[^a-zA-Z0-9]+/g, '_')}`,
+                method: method.toUpperCase(),
+                path,
+                summary: typed.summary ?? '',
+                tags: typed.tags ?? [],
+                parameters: typed.parameters ?? [],
+                requestBody: typed.requestBody,
+            });
+        }
+    }
+    return result.sort((a, b) => `${a.tags[0] ?? ''}:${a.path}:${a.method}`.localeCompare(`${b.tags[0] ?? ''}:${b.path}:${b.method}`));
+}
+function findOperation(spec, target, maybePath) {
+    const all = operations(spec);
+    if (maybePath) {
+        const method = target.toUpperCase();
+        return all.find((operation) => operation.method === method && operation.path === maybePath) ?? null;
+    }
+    const normalized = target.trim();
+    const methodPath = normalized.match(/^([A-Za-z]+)\s+(.+)$/);
+    if (methodPath) {
+        return all.find((operation) => operation.method === methodPath[1].toUpperCase() && operation.path === methodPath[2]) ?? null;
+    }
+    return all.find((operation) => operation.operationId === normalized) ?? null;
+}
+function schemaType(schema) {
+    if (!schema)
+        return 'unknown';
+    if (typeof schema.type === 'string')
+        return schema.type;
+    if (typeof schema.$ref === 'string')
+        return schema.$ref.split('/').pop() ?? schema.$ref;
+    if (Array.isArray(schema.anyOf))
+        return schema.anyOf.map((item) => isRecord(item) ? schemaType(item) : 'unknown').join(' | ');
+    return 'object';
+}
+function requestContent(operation) {
+    return Object.keys(operation.requestBody?.content ?? {});
+}
+function printSchemaSource(ctx, loaded) {
+    const age = loaded.cacheAgeMs === undefined ? '' : ` (${Math.round(loaded.cacheAgeMs / 1000)}s old)`;
+    log(ctx, field('Schema', `${loaded.source}${age}`));
+}
+export async function openApiList(ctx, options) {
+    const loaded = await loadOpenApiSpec(ctx, options);
+    const all = operations(loaded.spec).filter((operation) => {
+        const tagMatch = !options.tag || operation.tags.some((tag) => tag.toLowerCase() === options.tag?.toLowerCase());
+        const search = options.search?.toLowerCase();
+        const searchMatch = !search
+            || operation.operationId.toLowerCase().includes(search)
+            || operation.path.toLowerCase().includes(search)
+            || operation.summary.toLowerCase().includes(search)
+            || operation.tags.some((tag) => tag.toLowerCase().includes(search));
+        return tagMatch && searchMatch;
+    });
+    if (ctx.json) {
+        printJson({
+            ok: true,
+            schemaSource: loaded.source,
+            count: all.length,
+            operations: all,
+        });
+        return;
+    }
+    printBannerFor(ctx);
+    log(ctx, section('API Operations'));
+    printSchemaSource(ctx, loaded);
+    log(ctx, field('Count', String(all.length)));
+    log(ctx, '');
+    for (const operation of all) {
+        const tag = operation.tags[0] ? `[${operation.tags[0]}] ` : '';
+        log(ctx, `${operation.method.padEnd(6)} ${operation.path.padEnd(58)} ${tag}${operation.operationId}`);
+    }
+}
+export async function openApiDescribe(ctx, target, maybePath, options) {
+    const loaded = await loadOpenApiSpec(ctx, options);
+    const operation = findOperation(loaded.spec, target, maybePath);
+    if (!operation) {
+        throw new Error('Operation not found. Use `wacht api ls` to find operation IDs and paths.');
+    }
+    if (ctx.json) {
+        printJson({
+            ok: true,
+            schemaSource: loaded.source,
+            operation,
+            requestContentTypes: requestContent(operation),
+        });
+        return;
+    }
+    printBannerFor(ctx);
+    log(ctx, section(operation.operationId));
+    printSchemaSource(ctx, loaded);
+    log(ctx, field('Method', operation.method));
+    log(ctx, field('Path', operation.path));
+    if (operation.summary)
+        log(ctx, field('Summary', operation.summary));
+    if (operation.tags.length)
+        log(ctx, field('Tags', operation.tags.join(', ')));
+    if (operation.parameters.length) {
+        log(ctx, '');
+        log(ctx, section('Parameters'));
+        for (const parameter of operation.parameters) {
+            const required = parameter.required ? 'required' : 'optional';
+            log(ctx, `${parameter.name ?? 'unknown'} (${parameter.in ?? 'unknown'}, ${required}, ${schemaType(parameter.schema)})`);
+        }
+    }
+    const contentTypes = requestContent(operation);
+    if (contentTypes.length) {
+        log(ctx, '');
+        log(ctx, section('Request Body'));
+        for (const contentType of contentTypes)
+            log(ctx, contentType);
+    }
+}
+function applyPathParams(path, params) {
+    let next = path;
+    for (const [key, value] of params) {
+        next = next.replaceAll(`{${key}}`, encodeURIComponent(value));
+    }
+    const missing = next.match(/{[^}]+}/g);
+    if (missing) {
+        throw new Error(`Missing path parameter(s): ${missing.map((item) => item.slice(1, -1)).join(', ')}. Pass --param key=value.`);
+    }
+    return next;
+}
+function appendQueryParams(path, params, operation) {
+    const queryNames = new Set(operation.parameters.filter((parameter) => parameter.in === 'query').map((parameter) => parameter.name));
+    const url = new URL(path, 'https://machine.local');
+    for (const [key, value] of params) {
+        if (queryNames.has(key)) {
+            url.searchParams.set(key, value);
+        }
+    }
+    return `${url.pathname}${url.search}`;
+}
+export async function openApiCall(ctx, target, options) {
+    const loaded = await loadOpenApiSpec(ctx, options);
+    const operation = findOperation(loaded.spec, target);
+    if (!operation) {
+        throw new Error('Operation not found. Use `wacht api ls` to find operation IDs.');
+    }
+    const context = await readBenchContext();
+    const deploymentId = options.deployment ?? context?.deployment_id;
+    const params = entries(options.param, '--param');
+    const apiOptions = {
+        body: options.body,
+        field: options.field,
+        form: options.form,
+        file: options.file,
+        header: options.header,
+    };
+    const pathWithParams = appendQueryParams(applyPathParams(operation.path, params), params, operation);
+    const machinePath = pathWithParams.startsWith('/project') || pathWithParams === '/projects'
+        ? pathWithParams
+        : `/deployments/${deploymentId ?? ''}${pathWithParams}`;
+    if (machinePath.includes('/deployments//')) {
+        throw new Error('Select an active deployment first, or pass raw paths with `wacht api METHOD /path`.');
+    }
+    const { body, headers } = await requestBody(apiOptions);
+    const data = await machineRequest(machinePath, {
+        method: operation.method,
+        body,
+        headers,
+    });
+    if (ctx.json) {
+        printJson({
+            ok: true,
+            schemaSource: loaded.source,
+            operationId: operation.operationId,
+            method: operation.method,
+            path: machinePath,
+            data,
+        });
+        return;
+    }
+    printJson(data);
+}
+export async function openApiRefresh(ctx) {
+    const loaded = await loadOpenApiSpec(ctx, { refresh: true });
+    const count = operations(loaded.spec).length;
+    if (ctx.json) {
+        printJson({ ok: true, schemaSource: loaded.source, count, cacheFile: OPENAPI_CACHE_FILE });
+        return;
+    }
+    printBannerFor(ctx);
+    log(ctx, section('OpenAPI Schema'));
+    log(ctx, field('Source', loaded.source));
+    log(ctx, field('Operations', String(count)));
+    log(ctx, field('Cache', OPENAPI_CACHE_FILE));
+}

package/dist/pkce.js

@@ -0,0 +1,14 @@
+import { createHash, randomBytes } from 'node:crypto';
+export function base64Url(input) {
+    return Buffer.from(input)
+        .toString('base64')
+        .replaceAll('+', '-')
+        .replaceAll('/', '_')
+        .replaceAll('=', '');
+}
+export function randomToken(bytes = 32) {
+    return base64Url(randomBytes(bytes));
+}
+export function codeChallengeFor(verifier) {
+    return base64Url(createHash('sha256').update(verifier).digest());
+}

package/dist/project-detect.js

@@ -0,0 +1,64 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+async function fileText(root, relativePath) {
+    try {
+        return await readFile(path.join(root, relativePath), 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+async function readPackageJson(root) {
+    const raw = await fileText(root, 'package.json');
+    if (!raw)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+async function detectPackageManager(root) {
+    if (await fileText(root, 'pnpm-lock.yaml'))
+        return 'pnpm';
+    if (await fileText(root, 'yarn.lock'))
+        return 'yarn';
+    if (await fileText(root, 'bun.lock') || await fileText(root, 'bun.lockb'))
+        return 'bun';
+    if (await fileText(root, 'package-lock.json'))
+        return 'npm';
+    return 'unknown';
+}
+function hasDependency(pkg, name) {
+    return !!pkg?.dependencies?.[name] || !!pkg?.devDependencies?.[name];
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+export async function detectProject(root) {
+    const pkg = await readPackageJson(root);
+    const frameworks = [];
+    const suggestedSkills = ['wacht', 'wacht-setup'];
+    if (hasDependency(pkg, 'next')) {
+        frameworks.push('Next.js');
+        suggestedSkills.push('wacht-nextjs-patterns');
+    }
+    if (hasDependency(pkg, 'react-router') || hasDependency(pkg, '@react-router/dev')) {
+        frameworks.push('React Router');
+        suggestedSkills.push('wacht-react-router-patterns');
+    }
+    if (hasDependency(pkg, '@tanstack/react-router')) {
+        frameworks.push('TanStack Router');
+        suggestedSkills.push('wacht-tanstack-router-patterns');
+    }
+    if (hasDependency(pkg, '@wacht/backend')) {
+        suggestedSkills.push('wacht-backend-js', 'wacht-api-auth');
+    }
+    return {
+        root,
+        packageManager: await detectPackageManager(root),
+        frameworks: unique(frameworks),
+        suggestedSkills: unique(suggestedSkills),
+    };
+}

package/dist/prompts.js

@@ -0,0 +1,74 @@
+import { stdin as input, stdout as output } from 'node:process';
+import { createInterface } from 'node:readline/promises';
+export function canPrompt(ctx) {
+    return ctx.interactive && process.stdin.isTTY && process.stdout.isTTY;
+}
+async function ask(question) {
+    const rl = createInterface({ input, output });
+    try {
+        return (await rl.question(question)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function promptText(ctx, value, question, missingMessage) {
+    if (value && value.trim())
+        return value.trim();
+    if (!canPrompt(ctx))
+        throw new Error(missingMessage);
+    const answer = await ask(question);
+    if (!answer)
+        throw new Error(missingMessage);
+    return answer;
+}
+export async function promptOptionalText(ctx, value, question) {
+    if (value && value.trim())
+        return value.trim();
+    if (!canPrompt(ctx))
+        return undefined;
+    const answer = await ask(question);
+    return answer || undefined;
+}
+export async function promptChoice(ctx, value, choices, question, missingMessage) {
+    if (value) {
+        if (!choices.includes(value)) {
+            throw new Error(`${missingMessage} Allowed values: ${choices.join(', ')}.`);
+        }
+        return value;
+    }
+    if (!canPrompt(ctx))
+        throw new Error(missingMessage);
+    for (const [index, choice] of choices.entries()) {
+        console.log(`${index + 1}. ${choice}`);
+    }
+    console.log('');
+    const answer = await ask(question);
+    const index = Number.parseInt(answer, 10) - 1;
+    if (Number.isInteger(index) && index >= 0 && index < choices.length) {
+        return choices[index];
+    }
+    if (choices.includes(answer))
+        return answer;
+    throw new Error(`${missingMessage} Allowed values: ${choices.join(', ')}.`);
+}
+export async function promptList(ctx, values, question, fallback) {
+    if (values && values.length)
+        return values;
+    if (!canPrompt(ctx))
+        return fallback;
+    const answer = await ask(question);
+    if (!answer)
+        return fallback;
+    return answer.split(',').map((item) => item.trim()).filter(Boolean);
+}
+export async function promptOptionalList(ctx, values, question) {
+    if (values && values.length)
+        return values;
+    if (!canPrompt(ctx))
+        return [];
+    const answer = await ask(question);
+    if (!answer)
+        return [];
+    return answer.split(',').map((item) => item.trim()).filter(Boolean);
+}

package/dist/resources.js

@@ -0,0 +1,204 @@
+import { readBenchContext } from './context-store.js';
+import { entries, machineRequest, requestBody } from './machine-api.js';
+import { field, log, printBannerFor, printJson, section } from './ui.js';
+async function deploymentScopedPath(pathname, override) {
+    const ctx = await readBenchContext();
+    const deploymentId = override ?? ctx?.deployment_id;
+    if (!deploymentId) {
+        throw new Error('No active deployment. Run `wacht deployments select` or pass --deployment <id>.');
+    }
+    return `/deployments/${deploymentId}${pathname.startsWith('/') ? pathname : `/${pathname}`}`;
+}
+async function callDeployment(pathname, override, init = {}) {
+    let resolved = await deploymentScopedPath(pathname, override);
+    if (init.query) {
+        const query = new URLSearchParams();
+        for (const [key, value] of Object.entries(init.query)) {
+            if (value !== undefined && value !== '')
+                query.set(key, value);
+        }
+        const search = query.toString();
+        if (search)
+            resolved = `${resolved}?${search}`;
+    }
+    const { query: _query, ...rest } = init;
+    return machineRequest(resolved, rest);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function pickArray(value) {
+    if (Array.isArray(value))
+        return value;
+    if (isRecord(value)) {
+        if (Array.isArray(value.data))
+            return value.data;
+        if (Array.isArray(value.items))
+            return value.items;
+    }
+    return [];
+}
+function pad(value, width) {
+    return value.padEnd(width, ' ');
+}
+function truncate(value, max) {
+    if (value.length <= max)
+        return value;
+    return `${value.slice(0, Math.max(0, max - 1))}~`;
+}
+function shortDate(value) {
+    if (typeof value !== 'string')
+        return '-';
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? value : date.toISOString().slice(0, 10);
+}
+function printRows(ctx, title, rows, headers) {
+    printBannerFor(ctx);
+    log(ctx, section(title));
+    log(ctx, field('Count', String(rows.length)));
+    log(ctx, '');
+    if (rows.length === 0) {
+        log(ctx, '(none)');
+        return;
+    }
+    const widths = headers.map((h) => Math.max(h.label.length, ...rows.map((row) => (row[h.key] ?? '').length), h.width ?? 0));
+    log(ctx, headers.map((h, i) => pad(h.label, widths[i])).join('  '));
+    log(ctx, headers.map((_, i) => '-'.repeat(widths[i])).join('  '));
+    for (const row of rows) {
+        log(ctx, headers.map((h, i) => pad(row[h.key] ?? '', widths[i])).join('  '));
+    }
+}
+// ─── Users ──────────────────────────────────────────────────────────
+export async function listUsers(ctx, options) {
+    const data = await callDeployment('/users', options.deployment, {
+        method: 'GET',
+        query: { limit: options.limit ?? '', offset: options.offset ?? '', search: options.search ?? '' },
+    });
+    const items = pickArray(data);
+    if (ctx.json) {
+        printJson({ ok: true, data });
+        return;
+    }
+    const rows = items.filter(isRecord).map((u) => ({
+        id: truncate(String(u.id ?? ''), 22),
+        email: truncate(String(u.primary_email_address?.toString().includes('@') ? u.primary_email_address : (u.email ?? '-')), 32),
+        name: truncate([u.first_name, u.last_name].filter(Boolean).join(' ') || '-', 24),
+        created: shortDate(u.created_at),
+    }));
+    printRows(ctx, 'Users', rows, [
+        { key: 'id', label: 'ID' },
+        { key: 'email', label: 'Email' },
+        { key: 'name', label: 'Name' },
+        { key: 'created', label: 'Created' },
+    ]);
+}
+export async function getUser(ctx, userId, options) {
+    const data = await callDeployment(`/users/${encodeURIComponent(userId)}/details`, options.deployment, { method: 'GET' });
+    if (ctx.json) {
+        printJson({ ok: true, data });
+        return;
+    }
+    printJson(data);
+}
+export async function createUser(ctx, options) {
+    const path = await deploymentScopedPath('/users', options.deployment);
+    const { body, headers } = await requestBody(options);
+    const data = await machineRequest(path, { method: 'POST', body, headers });
+    if (ctx.json) {
+        printJson({ ok: true, data });
+        return;
+    }
+    printJson(data);
+}
+// ─── Organizations ──────────────────────────────────────────────────
+export async function listOrgs(ctx, options) {
+    const data = await callDeployment('/organizations', options.deployment, {
+        method: 'GET',
+        query: { limit: options.limit ?? '', offset: options.offset ?? '', search: options.search ?? '' },
+    });
+    const items = pickArray(data);
+    if (ctx.json) {
+        printJson({ ok: true, data });
+        return;
+    }
+    const rows = items.filter(isRecord).map((o) => ({
+        id: truncate(String(o.id ?? ''), 22),
+        name: truncate(String(o.name ?? '-'), 32),
+        members: String(o.member_count ?? o.members_count ?? '-'),
+        created: shortDate(o.created_at),
+    }));
+    printRows(ctx, 'Organizations', rows, [
+        { key: 'id', label: 'ID' },
+        { key: 'name', label: 'Name' },
+        { key: 'members', label: 'Members' },
+        { key: 'created', label: 'Created' },
+    ]);
+}
+export async function getOrg(ctx, orgId, options) {
+    const data = await callDeployment(`/organizations/${encodeURIComponent(orgId)}`, options.deployment, { method: 'GET' });
+    if (ctx.json) {
+        printJson({ ok: true, data });
+        return;
+    }
+    printJson(data);
+}
+export async function createOrg(ctx, options) {
+    const path = await deploymentScopedPath('/organizations', options.deployment);
+    const { body, headers } = await requestBody(options);
+    const data = await machineRequest(path, { method: 'POST', body, headers });
+    if (ctx.json) {
+        printJson({ ok: true, data });
+        return;
+    }
+    printJson(data);
+}
+// ─── Workspaces ─────────────────────────────────────────────────────
+export async function listWorkspaces(ctx, options) {
+    const pathname = options.org
+        ? `/organizations/${encodeURIComponent(options.org)}/workspaces`
+        : '/workspaces';
+    const data = await callDeployment(pathname, options.deployment, {
+        method: 'GET',
+        query: { limit: options.limit ?? '', offset: options.offset ?? '', search: options.search ?? '' },
+    });
+    const items = pickArray(data);
+    if (ctx.json) {
+        printJson({ ok: true, data });
+        return;
+    }
+    const rows = items.filter(isRecord).map((w) => ({
+        id: truncate(String(w.id ?? ''), 22),
+        name: truncate(String(w.name ?? '-'), 28),
+        org: truncate(String(w.organization_id ?? '-'), 22),
+        created: shortDate(w.created_at),
+    }));
+    printRows(ctx, 'Workspaces', rows, [
+        { key: 'id', label: 'ID' },
+        { key: 'name', label: 'Name' },
+        { key: 'org', label: 'Org ID' },
+        { key: 'created', label: 'Created' },
+    ]);
+}
+export async function getWorkspace(ctx, workspaceId, options) {
+    const data = await callDeployment(`/workspaces/${encodeURIComponent(workspaceId)}`, options.deployment, { method: 'GET' });
+    if (ctx.json) {
+        printJson({ ok: true, data });
+        return;
+    }
+    printJson(data);
+}
+export async function createWorkspace(ctx, options) {
+    if (!options.org) {
+        throw new Error('Workspaces are scoped to an organization. Pass --org <organization_id>.');
+    }
+    const path = await deploymentScopedPath(`/organizations/${encodeURIComponent(options.org)}/workspaces`, options.deployment);
+    const { body, headers } = await requestBody(options);
+    const data = await machineRequest(path, { method: 'POST', body, headers });
+    if (ctx.json) {
+        printJson({ ok: true, data });
+        return;
+    }
+    printJson(data);
+}
+// re-exported for ergonomics
+export { entries };

package/dist/skills.js

@@ -0,0 +1,29 @@
+import { spawn } from 'node:child_process';
+import { SKILLS_SOURCE } from './config.js';
+import { valueAfter } from './util.js';
+export function installSkills(skill) {
+    const installArgs = ['skills', 'add', SKILLS_SOURCE];
+    if (skill)
+        installArgs.push('--skill', skill);
+    return new Promise((resolve, reject) => {
+        const child = spawn('npx', installArgs, {
+            stdio: 'inherit',
+            shell: process.platform === 'win32',
+        });
+        child.on('error', reject);
+        child.on('exit', (code, signal) => {
+            if (signal) {
+                reject(new Error(`Skill install interrupted by ${signal}`));
+                return;
+            }
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`Skill install failed with exit code ${code ?? 1}`));
+        });
+    });
+}
+export async function skillsInstall(args) {
+    await installSkills(valueAfter(args, '--skill'));
+}

package/dist/types.js

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