@wacht/bench 0.1.0

package/dist/auth-store.js

@@ -0,0 +1,19 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { AUTH_DIR, AUTH_FILE } from './config.js';
+import { isStoredAuth } from './guards.js';
+export async function readAuth() {
+    try {
+        const parsed = JSON.parse(await readFile(AUTH_FILE, 'utf8'));
+        return isStoredAuth(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeAuth(auth) {
+    await mkdir(AUTH_DIR, { recursive: true });
+    await writeFile(AUTH_FILE, `${JSON.stringify(auth, null, 2)}\n`, { mode: 0o600 });
+}
+export async function clearAuth() {
+    await rm(AUTH_FILE, { force: true });
+}

package/dist/browser.js

@@ -0,0 +1,15 @@
+import { spawn } from 'node:child_process';
+export function openBrowser(url) {
+    const command = process.platform === 'darwin'
+        ? 'open'
+        : process.platform === 'win32'
+            ? 'cmd'
+            : 'xdg-open';
+    const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+    const child = spawn(command, args, {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.on('error', () => { });
+    child.unref();
+}

package/dist/commands.js

@@ -0,0 +1,389 @@
+import { Command } from 'commander';
+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 { apiCommand, listProjects } from './machine-api.js';
+import { openApiCall, openApiDescribe, openApiList, openApiRefresh } from './openapi.js';
+import { printMcpConfig } from './mcp.js';
+import { authStatus, login, logout } from './oauth.js';
+import { createOrg, createUser, createWorkspace, getOrg, getUser, getWorkspace, listOrgs, listUsers, listWorkspaces, } from './resources.js';
+import { installSkills } from './skills.js';
+import { banner } from './ui.js';
+function collect(value, previous) {
+    previous.push(value);
+    return previous;
+}
+function context(command) {
+    const options = command.optsWithGlobals();
+    if (options.color === false) {
+        process.env.NO_COLOR = '1';
+    }
+    return {
+        json: !!options.json,
+        quiet: !!options.quiet,
+        banner: options.banner !== false,
+        interactive: options.interactive !== false && !options.json && !options.quiet,
+    };
+}
+function initArgs(options) {
+    const args = [];
+    if (options.client)
+        args.push('--client', options.client);
+    if (options.installSkills)
+        args.push('--install-skills');
+    if (options.skipAgents)
+        args.push('--skip-agents');
+    if (options.skipConfig)
+        args.push('--skip-config');
+    if (options.skipEnv)
+        args.push('--skip-env');
+    if (options.skipGuide)
+        args.push('--skip-guide');
+    if (options.skipTemplates)
+        args.push('--skip-templates');
+    return args;
+}
+export async function runCli(args) {
+    const program = new Command();
+    program
+        .name('wacht')
+        .description('AI development workbench for Wacht')
+        .showHelpAfterError()
+        .option('--json', 'emit machine-readable JSON where supported')
+        .option('--quiet', 'suppress nonessential human output')
+        .option('--no-interactive', 'do not prompt; require explicit arguments and flags')
+        .option('--no-banner', 'hide the Wacht Bench banner')
+        .option('--no-color', 'disable colored output')
+        .addHelpText('beforeAll', () => {
+        const options = program.opts();
+        if (options.json || options.quiet || options.banner === false)
+            return '';
+        return `${banner()}\n\n`;
+    });
+    program
+        .command('init')
+        .description('bootstrap the current project for Wacht development')
+        .option('--client <client>', 'assistant client metadata', 'cursor')
+        .option('--starter [framework]', 'clone a Wacht starter (nextjs, react-router, tanstack) instead of bootstrapping the current dir')
+        .option('--target <dir>', 'target directory when using --starter (defaults to ./wacht-<framework>-starter)')
+        .option('--install-skills', 'run npx skills add after writing config')
+        .option('--skip-agents', 'do not create or update AGENTS.md')
+        .option('--skip-config', 'do not write .wacht/bench.json')
+        .option('--skip-env', 'do not write .env.wacht.example')
+        .option('--skip-guide', 'do not write .wacht/BOOTSTRAP.md')
+        .option('--skip-templates', 'do not write starter templates under .wacht/templates')
+        .action(async (options) => {
+        const ctx = context(program);
+        if (options.starter) {
+            const framework = typeof options.starter === 'string' ? options.starter : undefined;
+            await initStarter({
+                framework,
+                target: options.target,
+                install: !!options.installSkills,
+                client: options.client ?? 'cursor',
+            }, ctx);
+            return;
+        }
+        await initProject(initArgs(options), ctx);
+    });
+    program
+        .command('login')
+        .description('log in with Wacht OAuth using Authorization Code + PKCE')
+        .option('--skip-select', 'do not select an active deployment after login')
+        .action(async (options) => {
+        const ctx = context(program);
+        await login(ctx);
+        if (!options.skipSelect && ctx.interactive) {
+            await selectDeployment(ctx, { optional: true });
+        }
+    });
+    program
+        .command('logout')
+        .description('clear local Bench auth and revoke the refresh token when possible')
+        .action(async () => {
+        await logout(context(program));
+    });
+    const auth = program.command('auth').description('inspect or manage Bench auth');
+    auth
+        .command('status')
+        .description('show local Bench auth status')
+        .action(async () => {
+        await authStatus(context(program));
+    });
+    const projects = program.command('projects').description('work with Wacht projects');
+    projects
+        .command('list')
+        .description('list projects visible to the current OAuth grant')
+        .action(async () => {
+        await listProjects(context(program));
+    });
+    projects
+        .command('create')
+        .description('create a Wacht project with its first staging deployment')
+        .option('--name <name>', 'project name')
+        .option('--method <method>', 'auth method; repeatable. Project/staging: email, phone, username, google_oauth, apple_oauth, facebook_oauth, github_oauth, discord_oauth, linkedin_oauth, gitlab_oauth, x_oauth', collect, [])
+        .option('--no-select', 'do not make the created staging deployment active')
+        .action(async (options) => {
+        await createProjectCommand(context(program), options);
+    });
+    const deployments = program.command('deployments').description('work with Wacht deployments');
+    deployments
+        .command('current')
+        .description('show the active deployment Bench will use')
+        .action(async () => {
+        await currentDeployment(context(program));
+    });
+    deployments
+        .command('select')
+        .description('select the active project/deployment for Bench')
+        .option('--project <id>', 'project id')
+        .option('--deployment <id>', 'deployment id')
+        .option('--mode <mode>', 'deployment mode: staging or production')
+        .action(async (options) => {
+        await selectDeployment(context(program), options);
+    });
+    deployments
+        .command('clear')
+        .description('clear the active deployment selection')
+        .action(async () => {
+        await clearDeployment(context(program));
+    });
+    deployments
+        .command('create')
+        .description('create a staging or production deployment')
+        .argument('[mode]', 'staging or production')
+        .option('--project <id>', 'project id; defaults to the active project')
+        .option('--domain <domain>', 'custom domain for production deployments')
+        .option('--method <method>', 'auth method; repeatable. Staging supports social providers; production supports email, phone, username', collect, [])
+        .option('--no-select', 'do not make the created deployment active')
+        .action(async (mode, options) => {
+        await createDeploymentCommand(context(program), { ...options, mode });
+    });
+    const skills = program.command('skills').description('install Wacht agent skills');
+    skills
+        .command('install')
+        .description('install the Wacht skills pack')
+        .option('--skill <name>', 'install one skill from the pack')
+        .action(async (options) => {
+        await installSkills(options.skill);
+    });
+    const mcp = program.command('mcp').description('print Wacht Docs MCP configuration');
+    mcp
+        .command('config')
+        .description('print MCP config JSON for an assistant client')
+        .option('--client <client>', 'cursor, claude, or codex', 'cursor')
+        .action((options) => {
+        printMcpConfig(options.client);
+    });
+    const config = program.command('config').description('manage Wacht deployment settings as code');
+    config
+        .command('pull')
+        .description('pull the active deployment settings into wacht.config.json')
+        .option('--file <path>', 'config file path', 'wacht.config.json')
+        .option('--deployment <id>', 'deployment id override; defaults to active deployment')
+        .action(async (options) => {
+        await configPull(context(program), options);
+    });
+    config
+        .command('schema')
+        .description('print the Wacht config JSON schema')
+        .option('--refresh', 'refresh the cached OpenAPI schema first')
+        .action(async (options) => {
+        await configSchemaCommand(context(program), options);
+    });
+    config
+        .command('template')
+        .description('print a minimal Wacht config template')
+        .action(() => {
+        printConfigTemplate(context(program));
+    });
+    config
+        .command('diff')
+        .description('compare a config file with the active deployment')
+        .option('--file <path>', 'config file path', 'wacht.config.json')
+        .option('--deployment <id>', 'deployment id override; defaults to config or active deployment')
+        .action(async (options) => {
+        await configDiff(context(program), options);
+    });
+    config
+        .command('apply')
+        .description('apply a config file to the active deployment')
+        .option('--file <path>', 'config file path', 'wacht.config.json')
+        .option('--deployment <id>', 'deployment id override; defaults to config or active deployment')
+        .option('--dry-run', 'preview changes without applying them')
+        .option('--yes', 'required to apply changes')
+        .option('--production', 'allow applying to a production deployment')
+        .option('--confirm <deployment_id>', 'required with --production; must match the deployment id')
+        .action(async (options) => {
+        await configApply(context(program), options);
+    });
+    const api = program
+        .command('api')
+        .description('call the Wacht Machine API')
+        .argument('[method]', 'HTTP method')
+        .argument('[path]', 'API path, for example /projects')
+        .option('--body <json>', 'JSON request body')
+        .option('--field <key=value>', 'URL-encoded form field; repeatable', collect, [])
+        .option('--form <key=value>', 'multipart form field; value @path is treated as a file; repeatable', collect, [])
+        .option('--file <key=path>', 'multipart file field; key=path or key=@path; repeatable', collect, [])
+        .option('--header <key=value>', 'request header; repeatable', collect, [])
+        .action(async (method, path, options) => {
+        await apiCommand(method, path, options, context(program));
+    });
+    api
+        .command('ls')
+        .description('list operations from the Wacht Platform OpenAPI schema')
+        .option('--tag <tag>', 'filter by OpenAPI tag')
+        .option('--search <text>', 'filter by operation id, summary, path, or tag')
+        .option('--refresh', 'refresh the cached OpenAPI schema first')
+        .action(async (options) => {
+        await openApiList(context(program), options);
+    });
+    api
+        .command('describe')
+        .description('describe an OpenAPI operation by operation id or METHOD path')
+        .argument('<operationOrMethod>', 'operation id, or HTTP method when path is also passed')
+        .argument('[path]', 'OpenAPI path, for example /users')
+        .option('--refresh', 'refresh the cached OpenAPI schema first')
+        .action(async (operationOrMethod, path, options) => {
+        await openApiDescribe(context(program), operationOrMethod, path, options);
+    });
+    api
+        .command('call')
+        .description('call an OpenAPI operation by operation id using the active deployment')
+        .argument('<operation>', 'OpenAPI operation id')
+        .option('--deployment <id>', 'deployment id override; defaults to active deployment')
+        .option('--param <key=value>', 'path or query parameter; repeatable', collect, [])
+        .option('--body <json>', 'JSON request body')
+        .option('--field <key=value>', 'URL-encoded form field; repeatable', collect, [])
+        .option('--form <key=value>', 'multipart form field; value @path is treated as a file; repeatable', collect, [])
+        .option('--file <key=path>', 'multipart file field; key=path or key=@path; repeatable', collect, [])
+        .option('--header <key=value>', 'request header; repeatable', collect, [])
+        .option('--refresh', 'refresh the cached OpenAPI schema first')
+        .action(async (operation, options) => {
+        await openApiCall(context(program), operation, options);
+    });
+    const schema = api.command('schema').description('manage cached OpenAPI schema');
+    schema
+        .command('refresh')
+        .description('download and cache the latest Wacht Platform OpenAPI schema')
+        .action(async () => {
+        await openApiRefresh(context(program));
+    });
+    // ─── Resources ────────────────────────────────────────────────
+    const users = program.command('users').description('list, get, or create users in the active deployment');
+    users
+        .command('list')
+        .description('list users in the active deployment')
+        .option('--deployment <id>', 'deployment id override')
+        .option('--limit <n>', 'page size')
+        .option('--offset <n>', 'page offset')
+        .option('--search <q>', 'search query')
+        .action(async (options) => {
+        await listUsers(context(program), options);
+    });
+    users
+        .command('get')
+        .description('get a user by id')
+        .argument('<userId>', 'user id')
+        .option('--deployment <id>', 'deployment id override')
+        .action(async (userId, options) => {
+        await getUser(context(program), userId, options);
+    });
+    users
+        .command('create')
+        .description('create a user via the Machine API')
+        .option('--deployment <id>', 'deployment id override')
+        .option('--body <json>', 'JSON request body')
+        .option('--field <key=value>', 'URL-encoded form field; repeatable', collect, [])
+        .option('--form <key=value>', 'multipart form field; repeatable', collect, [])
+        .option('--file <key=path>', 'multipart file field; repeatable', collect, [])
+        .option('--header <key=value>', 'request header; repeatable', collect, [])
+        .action(async (options) => {
+        await createUser(context(program), options);
+    });
+    const orgs = program.command('orgs').alias('organizations').description('list, get, or create organizations');
+    orgs
+        .command('list')
+        .description('list organizations in the active deployment')
+        .option('--deployment <id>', 'deployment id override')
+        .option('--limit <n>', 'page size')
+        .option('--offset <n>', 'page offset')
+        .option('--search <q>', 'search query')
+        .action(async (options) => {
+        await listOrgs(context(program), options);
+    });
+    orgs
+        .command('get')
+        .description('get an organization by id')
+        .argument('<orgId>', 'organization id')
+        .option('--deployment <id>', 'deployment id override')
+        .action(async (orgId, options) => {
+        await getOrg(context(program), orgId, options);
+    });
+    orgs
+        .command('create')
+        .description('create an organization')
+        .option('--deployment <id>', 'deployment id override')
+        .option('--body <json>', 'JSON request body')
+        .option('--field <key=value>', 'URL-encoded form field; repeatable', collect, [])
+        .option('--form <key=value>', 'multipart form field; repeatable', collect, [])
+        .option('--file <key=path>', 'multipart file field; repeatable', collect, [])
+        .option('--header <key=value>', 'request header; repeatable', collect, [])
+        .action(async (options) => {
+        await createOrg(context(program), options);
+    });
+    const workspaces = program.command('workspaces').description('list, get, or create workspaces');
+    workspaces
+        .command('list')
+        .description('list workspaces in the active deployment, optionally filtered by org')
+        .option('--deployment <id>', 'deployment id override')
+        .option('--org <id>', 'list workspaces under a specific organization')
+        .option('--limit <n>', 'page size')
+        .option('--offset <n>', 'page offset')
+        .option('--search <q>', 'search query')
+        .action(async (options) => {
+        await listWorkspaces(context(program), options);
+    });
+    workspaces
+        .command('get')
+        .description('get a workspace by id')
+        .argument('<workspaceId>', 'workspace id')
+        .option('--deployment <id>', 'deployment id override')
+        .action(async (workspaceId, options) => {
+        await getWorkspace(context(program), workspaceId, options);
+    });
+    workspaces
+        .command('create')
+        .description('create a workspace under an organization')
+        .option('--deployment <id>', 'deployment id override')
+        .requiredOption('--org <id>', 'organization id (workspaces are scoped to an org)')
+        .option('--body <json>', 'JSON request body')
+        .option('--field <key=value>', 'URL-encoded form field; repeatable', collect, [])
+        .option('--form <key=value>', 'multipart form field; repeatable', collect, [])
+        .option('--file <key=path>', 'multipart file field; repeatable', collect, [])
+        .option('--header <key=value>', 'request header; repeatable', collect, [])
+        .action(async (options) => {
+        await createWorkspace(context(program), options);
+    });
+    // ─── Shell completion ─────────────────────────────────────────
+    program
+        .command('completion')
+        .description('print shell completion script (bash, zsh, fish, powershell)')
+        .argument('[shell]', 'bash, zsh, fish, or powershell')
+        .action((shellArg) => {
+        const shell = (shellArg ?? '').toLowerCase();
+        if (!['bash', 'zsh', 'fish', 'powershell'].includes(shell)) {
+            console.error('Pass a shell: wacht completion bash | zsh | fish | powershell\n' +
+                '  bash:        wacht completion bash > /etc/bash_completion.d/wacht\n' +
+                '  zsh:         wacht completion zsh  > "${fpath[1]}/_wacht"\n' +
+                '  fish:        wacht completion fish > ~/.config/fish/completions/wacht.fish\n' +
+                '  powershell:  wacht completion powershell | Out-String | Invoke-Expression');
+            process.exitCode = 1;
+            return;
+        }
+        process.stdout.write(completionScript(shell));
+    });
+    await program.parseAsync(args, { from: 'user' });
+}

package/dist/completion.js

@@ -0,0 +1,132 @@
+// Static shell completion scripts for the `wacht` CLI.
+// Generated dynamically from the known top-level commands so adding a command
+// only requires updating the COMMANDS list below.
+const COMMANDS = [
+    'init',
+    'login',
+    'logout',
+    'auth',
+    'projects',
+    'deployments',
+    'users',
+    'orgs',
+    'workspaces',
+    'skills',
+    'mcp',
+    'config',
+    'api',
+    'completion',
+];
+const SUBCOMMANDS = {
+    auth: ['status'],
+    projects: ['list', 'create'],
+    deployments: ['current', 'select', 'clear', 'create'],
+    users: ['list', 'get', 'create'],
+    orgs: ['list', 'get', 'create'],
+    workspaces: ['list', 'get', 'create'],
+    skills: ['install'],
+    mcp: ['config'],
+    config: ['pull', 'schema', 'template', 'diff', 'apply'],
+    api: ['ls', 'describe', 'call', 'schema'],
+    completion: ['bash', 'zsh', 'fish', 'powershell'],
+};
+function bashScript() {
+    const tops = COMMANDS.join(' ');
+    const subs = Object.entries(SUBCOMMANDS)
+        .map(([cmd, list]) => `      ${cmd}) COMPREPLY=($(compgen -W "${list.join(' ')}" -- "$cur")); return 0;;`)
+        .join('\n');
+    return `# bash completion for wacht
+_wacht_complete() {
+  local cur prev words cword
+  _init_completion -n = || return
+
+  if [[ $cword -eq 1 ]]; then
+    COMPREPLY=($(compgen -W "${tops}" -- "$cur"))
+    return 0
+  fi
+
+  if [[ $cword -eq 2 ]]; then
+    case "\${words[1]}" in
+${subs}
+    esac
+  fi
+
+  COMPREPLY=()
+}
+complete -F _wacht_complete wacht
+`;
+}
+function zshScript() {
+    const cases = COMMANDS.map((cmd) => {
+        const subs = SUBCOMMANDS[cmd];
+        if (!subs)
+            return `        ${cmd})  ;;`;
+        const subList = subs.map((s) => `'${s}'`).join(' ');
+        return `        ${cmd})\n          _values 'subcommand' ${subList}\n          ;;`;
+    }).join('\n');
+    return `#compdef wacht
+# zsh completion for wacht
+_wacht() {
+  local context state line
+  _arguments -C \\
+    '1: :->command' \\
+    '2: :->subcommand' \\
+    '*::arg:->args'
+
+  case $state in
+    command)
+      _values 'wacht command' ${COMMANDS.map((c) => `'${c}'`).join(' ')}
+      ;;
+    subcommand)
+      case $words[2] in
+${cases}
+      esac
+      ;;
+  esac
+}
+_wacht "$@"
+`;
+}
+function fishScript() {
+    const lines = [`# fish completion for wacht`];
+    for (const cmd of COMMANDS) {
+        lines.push(`complete -c wacht -n '__fish_use_subcommand' -a '${cmd}'`);
+    }
+    for (const [cmd, subs] of Object.entries(SUBCOMMANDS)) {
+        for (const sub of subs) {
+            lines.push(`complete -c wacht -n '__fish_seen_subcommand_from ${cmd}' -a '${sub}'`);
+        }
+    }
+    return `${lines.join('\n')}\n`;
+}
+function powershellScript() {
+    const tops = COMMANDS.join("','");
+    const cases = Object.entries(SUBCOMMANDS)
+        .map(([cmd, subs]) => `    '${cmd}' { @('${subs.join("','")}') }`)
+        .join('\n');
+    return `# PowerShell completion for wacht
+Register-ArgumentCompleter -Native -CommandName wacht -ScriptBlock {
+  param($wordToComplete, $commandAst, $cursorPosition)
+  $tokens = $commandAst.CommandElements | ForEach-Object { $_.Value }
+  if ($tokens.Length -le 2) {
+    @('${tops}') | Where-Object { $_ -like "$wordToComplete*" } |
+      ForEach-Object { [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_) }
+    return
+  }
+  $sub = switch ($tokens[1]) {
+${cases}
+    default { @() }
+  }
+  $sub | Where-Object { $_ -like "$wordToComplete*" } |
+    ForEach-Object { [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_) }
+}
+`;
+}
+export function completionScript(shell) {
+    switch (shell) {
+        case 'bash': return bashScript();
+        case 'zsh': return zshScript();
+        case 'fish': return fishScript();
+        case 'powershell': return powershellScript();
+    }
+}