@wacht/bench 0.1.1 → 0.1.2

package/dist/commands.js

@@ -16,6 +16,7 @@ import { completionScript } from './completion.js';
 import { configApply, configDiff, configPull, configSchemaCommand, printConfigTemplate, } from './config-workflow.js';
 import { clearDeployment, createDeploymentCommand, createProjectCommand, currentDeployment, selectDeployment, } from './deployment-context.js';
 import { initProject, initStarter } from './init.js';
+import { envPull } from './env-pull.js';
 import { apiCommand, listProjects } from './machine-api.js';
 import { openApiCall, openApiDescribe, openApiList, openApiRefresh } from './openapi.js';
 import { installMcp, listMcp, printMcpConfig, uninstallMcp } from './mcp.js';
@@ -168,10 +169,22 @@ export async function runCli(args) {
     const skills = program.command('skills').description('install Wacht agent skills');
     skills
         .command('install')
-        .description('install the Wacht skills pack')
+        .description('install the Wacht skills pack into one or more AI agents')
         .option('--skill <name>', 'install one skill from the pack')
+        .option('--agent <ids>', 'comma-separated agent ids (e.g. claude-code,cursor,codex); skips the agent picker', (value) => value.split(',').map((s) => s.trim()).filter(Boolean))
+        .option('--all-agents', "install into every supported agent (passes -a '*')")
+        .option('--global', 'install at user scope instead of project scope')
+        .option('--yes', 'do not prompt for confirmation')
+        .option('--copy', 'copy skill files instead of symlinking')
         .action(async (options) => {
-        await installSkills(options.skill);
+        await installSkills({
+            skill: options.skill,
+            agents: options.agent,
+            allAgents: options.allAgents,
+            global: options.global,
+            yes: options.yes,
+            copy: options.copy,
+        });
     });
     const mcp = program.command('mcp').description('configure Wacht Docs MCP across AI clients');
     mcp
@@ -206,6 +219,15 @@ export async function runCli(args) {
         .action((options) => {
         printMcpConfig(options.client);
     });
+    const env = program.command('env').description('manage deployment credentials and environment files');
+    env
+        .command('pull')
+        .description('mint a fresh backend API key for the active deployment and write keys to .env.local')
+        .option('--file <path>', 'env file path; defaults to .env.local in the current directory')
+        .option('--print', 'print credentials to stdout instead of writing the env file')
+        .action(async (options) => {
+        await envPull(context(program), options);
+    });
     const config = program.command('config').description('manage Wacht deployment settings as code');
     config
         .command('pull')

package/dist/env-pull.js

@@ -0,0 +1,100 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { machineRequest } from './machine-api.js';
+import { detectProject } from './project-detect.js';
+import { field, log, printBannerFor, printJson, section } from './ui.js';
+function isCredentialsResponse(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const v = value;
+    if (typeof v.publishable_key !== 'string')
+        return false;
+    if (typeof v.frontend_host !== 'string')
+        return false;
+    if (typeof v.backend_host !== 'string')
+        return false;
+    if (typeof v.api_key !== 'object' || v.api_key === null)
+        return false;
+    const k = v.api_key;
+    return typeof k.secret === 'string';
+}
+function publishableKeyVar(frameworks) {
+    if (frameworks.has('Next.js'))
+        return 'NEXT_PUBLIC_WACHT_PUBLISHABLE_KEY';
+    if (frameworks.has('React Router') || frameworks.has('TanStack Router')) {
+        return 'VITE_WACHT_PUBLISHABLE_KEY';
+    }
+    return 'NEXT_PUBLIC_WACHT_PUBLISHABLE_KEY';
+}
+function upsertEnvLines(existing, updates) {
+    const lines = existing.length === 0 ? [] : existing.split(/\r?\n/);
+    const matched = new Set();
+    const next = lines.map((line) => {
+        const eqIdx = line.indexOf('=');
+        if (eqIdx <= 0)
+            return line;
+        const key = line.slice(0, eqIdx).trim();
+        if (!(key in updates))
+            return line;
+        matched.add(key);
+        return `${key}=${updates[key]}`;
+    });
+    const missing = Object.entries(updates).filter(([key]) => !matched.has(key));
+    if (missing.length) {
+        if (next.length && next[next.length - 1].trim() !== '')
+            next.push('');
+        for (const [key, value] of missing)
+            next.push(`${key}=${value}`);
+    }
+    let out = next.join('\n');
+    if (!out.endsWith('\n'))
+        out += '\n';
+    return out;
+}
+export async function envPull(ctx, options = {}) {
+    const data = await machineRequest('/credentials', { method: 'POST' });
+    if (!isCredentialsResponse(data)) {
+        throw new Error('Unexpected response shape from /credentials.');
+    }
+    if (options.print || ctx.json) {
+        if (ctx.json) {
+            printJson({ ok: true, data });
+        }
+        else {
+            printBannerFor(ctx);
+            log(ctx, section('Deployment Credentials'));
+            log(ctx, field('Publishable key', data.publishable_key));
+            log(ctx, field('API key', data.api_key.secret));
+            log(ctx, field('API key suffix', `${data.api_key.prefix}…${data.api_key.suffix}`));
+            log(ctx, field('Frontend host', data.frontend_host));
+            log(ctx, field('Backend host', data.backend_host));
+        }
+        return;
+    }
+    const root = process.cwd();
+    const profile = await detectProject(root);
+    const pubVar = publishableKeyVar(new Set(profile.frameworks));
+    const filePath = options.file
+        ? path.resolve(root, options.file)
+        : path.join(root, '.env.local');
+    const existing = await readFile(filePath, 'utf8').catch((err) => {
+        if (err.code === 'ENOENT')
+            return '';
+        throw err;
+    });
+    const updated = upsertEnvLines(existing, {
+        [pubVar]: data.publishable_key,
+        WACHT_API_KEY: data.api_key.secret,
+    });
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, updated, 'utf8');
+    printBannerFor(ctx);
+    log(ctx, section('Wrote credentials'));
+    log(ctx, field('File', path.relative(root, filePath) || filePath));
+    log(ctx, field(pubVar, `${data.publishable_key.slice(0, 12)}…`));
+    log(ctx, field('WACHT_API_KEY', `${data.api_key.prefix}…${data.api_key.suffix}`));
+    log(ctx, field('Frontend host', data.frontend_host));
+    log(ctx, field('Backend host', data.backend_host));
+    log(ctx, '');
+    log(ctx, 'Note: the API key secret is only shown once. Subsequent calls mint a new key.');
+}

package/dist/init.js

@@ -140,11 +140,11 @@ export async function initProject(args, ctx) {
     if (options.installSkills) {
         log(ctx, '');
         log(ctx, section('Install Skills'));
-        await installSkills();
+        await installSkills({ yes: true });
     }
     else {
         log(ctx, '');
-        log(ctx, field('Skills', `run ${command('wacht skills add')} when you want to install/update the pack`));
+        log(ctx, field('Skills', `run ${command('wacht skills install')} when you want to install/update the pack`));
     }
     if (ctx.json) {
         printJson({

package/dist/machine-api.js

@@ -1,12 +1,40 @@
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { MACHINE_API_URL } from './config.js';
+import { readBenchContext } from './context-store.js';
 import { getValidAuth } from './oauth.js';
 import { promptChoice, promptOptionalList, promptText } from './prompts.js';
 import { field, log, printBannerFor, printJson, section } from './ui.js';
+function isProjectScopedPath(p) {
+    if (p === '/projects' || p === '/project')
+        return true;
+    if (p.startsWith('/projects/') || p.startsWith('/project/'))
+        return true;
+    return false;
+}
+function isAlreadyDeploymentScoped(p) {
+    return p === '/deployments' || p.startsWith('/deployments/');
+}
+async function applyDeploymentPrefix(pathname) {
+    const normalized = pathname.startsWith('/') ? pathname : `/${pathname}`;
+    if (isProjectScopedPath(normalized) || isAlreadyDeploymentScoped(normalized)) {
+        return normalized;
+    }
+    const context = await readBenchContext();
+    if (!context?.deployment_id) {
+        throw new Error('No active deployment selected. Run `wacht deployments select`.');
+    }
+    const splitIdx = normalized.search(/[?#]/);
+    const prefix = `/deployments/${context.deployment_id}`;
+    const pathPart = splitIdx === -1 ? normalized : normalized.slice(0, splitIdx);
+    const suffix = splitIdx === -1 ? '' : normalized.slice(splitIdx);
+    const joinedPath = pathPart === '/' ? prefix : `${prefix}${pathPart}`;
+    return `${joinedPath}${suffix}`;
+}
 export async function machineRequest(pathname, options = {}) {
     const auth = await getValidAuth();
-    const url = new URL(pathname, auth.machine_api_url || MACHINE_API_URL);
+    const resolvedPath = await applyDeploymentPrefix(pathname);
+    const url = new URL(resolvedPath, auth.machine_api_url || MACHINE_API_URL);
     const headers = new Headers(options.headers);
     headers.set('authorization', `Bearer ${auth.access_token}`);
     headers.set('accept', 'application/json');

package/dist/openapi.js

@@ -219,12 +219,18 @@ export async function openApiCall(ctx, target, options) {
         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//')) {
+    const isProjectScoped = pathWithParams.startsWith('/project') || pathWithParams === '/projects';
+    let machinePath;
+    if (isProjectScoped) {
+        machinePath = pathWithParams;
+    }
+    else if (!deploymentId) {
         throw new Error('Select an active deployment first, or pass raw paths with `wacht api METHOD /path`.');
     }
+    else {
+        const base = `/deployments/${deploymentId}`;
+        machinePath = pathWithParams === '/' ? base : `${base}${pathWithParams}`;
+    }
     const { body, headers } = await requestBody(apiOptions);
     const data = await machineRequest(machinePath, {
         method: operation.method,

package/dist/skills.js

@@ -1,10 +1,22 @@
 import { spawn } from 'node:child_process';
 import { SKILLS_SOURCE } from './config.js';
 import { valueAfter } from './util.js';
-export function installSkills(skill) {
+export function installSkills(options = {}) {
     const installArgs = ['skills', 'add', SKILLS_SOURCE];
-    if (skill)
-        installArgs.push('--skill', skill);
+    if (options.allAgents) {
+        installArgs.push('-a', '*');
+    }
+    else if (options.agents && options.agents.length > 0) {
+        installArgs.push('-a', ...options.agents);
+    }
+    if (options.skill)
+        installArgs.push('-s', options.skill);
+    if (options.global)
+        installArgs.push('-g');
+    if (options.yes)
+        installArgs.push('-y');
+    if (options.copy)
+        installArgs.push('--copy');
     return new Promise((resolve, reject) => {
         const child = spawn('npx', installArgs, {
             stdio: 'inherit',
@@ -25,5 +37,5 @@ export function installSkills(skill) {
     });
 }
 export async function skillsInstall(args) {
-    await installSkills(valueAfter(args, '--skill'));
+    await installSkills({ skill: valueAfter(args, '--skill') });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wacht/bench",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "CLI for Wacht Bench, the AI development workbench for Wacht.",
   "type": "module",
   "bin": {