@orchestree/cli 2.2.0 → 3.5.0

package/dist/gateways.d.ts

@@ -0,0 +1,2 @@
+import { type CliIO } from '@orchestree/cli-core';
+export declare function gatewaysCommand(args: string[], io: CliIO): Promise<number>;

package/dist/gateways.js

@@ -0,0 +1,57 @@
+// `crow gateways` — list model gateways and run setup wizards.
+import { listGateways, loadCliConfig, systemExec, vertexSetup, } from '@orchestree/cli-core';
+function pad(value, width) {
+    return value.length >= width ? value : value + ' '.repeat(width - value.length);
+}
+async function listCommand(io) {
+    const config = await loadCliConfig();
+    for (const gw of listGateways(config)) {
+        io.out(`${pad(gw.id, 15)} ${pad(gw.status, 13)} ${gw.detail}`);
+    }
+    return 0;
+}
+function readFlag(args, name) {
+    const i = args.indexOf(name);
+    if (i === -1)
+        return { value: null, rest: args };
+    const value = args[i + 1];
+    if (!value || value.startsWith('--'))
+        return { value: null, rest: args };
+    return { value, rest: [...args.slice(0, i), ...args.slice(i + 2)] };
+}
+async function setupCommand(args, io) {
+    const id = args[0];
+    switch (id) {
+        case 'vertex': {
+            const { value: project, rest: afterProject } = readFlag(args.slice(1), '--project');
+            const { value: region, rest } = readFlag(afterProject, '--region');
+            const enableAnthropicModels = rest.includes('--enable-anthropic-models');
+            return vertexSetup({
+                project: project ?? undefined,
+                region: region ?? undefined,
+                enableAnthropicModels,
+                io,
+                exec: systemExec,
+            });
+        }
+        case 'openrouter':
+            io.out('OpenRouter is already live — it is routed server-side via api.orchestree.ai and needs no local setup.');
+            return 0;
+        case 'azure_foundry':
+            // Honest-Beta: unbuilt capability says so and exits non-zero.
+            io.err('Azure AI Foundry support has not shipped yet — nothing was configured.');
+            return 1;
+        default:
+            io.err(`unknown gateway \`${id ?? ''}\` — known gateways: openrouter, vertex, azure_foundry`);
+            return 2;
+    }
+}
+export async function gatewaysCommand(args, io) {
+    const sub = args[0];
+    if (!sub || sub === 'list')
+        return listCommand(io);
+    if (sub === 'setup')
+        return setupCommand(args.slice(1), io);
+    io.err(`unknown gateways subcommand \`${sub}\` — use \`crow gateways\` or \`crow gateways setup <id>\``);
+    return 2;
+}

package/dist/index.d.ts

@@ -1,2 +1 @@
-#!/usr/bin/env node
 export {};

package/dist/index.js

@@ -1,88 +1,171 @@
-#!/usr/bin/env node
-// @orchestree/cli — Official CLI for the Orchestree platform
-import { loginCommand } from './commands/login.js';
-import { chatCommand } from './commands/chat.js';
-import { agentsCommand } from './commands/agents.js';
-import { statusCommand } from './commands/status.js';
-import { deployCommand } from './commands/deploy.js';
-import { registryCommand } from './commands/registry.js';
-import { runCommand, orchestrateCommand } from './commands/run.js';
-const args = process.argv.slice(2);
-const command = args[0];
-const commandArgs = args.slice(1);
-async function main() {
-    switch (command) {
-        case 'login':
-            await loginCommand(commandArgs);
-            break;
-        case 'chat':
-            await chatCommand(commandArgs);
-            break;
-        case 'agents':
-            await agentsCommand(commandArgs);
-            break;
-        case 'status':
-            await statusCommand(commandArgs);
-            break;
-        case 'deploy':
-            await deployCommand(commandArgs);
-            break;
-        case 'registry':
-            await registryCommand(commandArgs);
-            break;
-        case 'run':
-            await runCommand(commandArgs);
-            break;
-        case 'orchestrate':
-            await orchestrateCommand(commandArgs);
-            break;
-        case 'help':
-        case '--help':
-        case '-h':
-        case undefined:
-            printHelp();
-            break;
-        case 'version':
-        case '--version':
-        case '-v':
-            console.log('orchestree v2.2.0');
-            break;
-        default:
-            console.error(`Unknown command: ${command}`);
-            printHelp();
-            process.exit(1);
-    }
-}
-function printHelp() {
-    console.log(`
-Orchestree CLI v2.2.0
+// crow — the CrowCode CLI, the platform front door in your terminal.
+// (`orchestree` remains as an alias for one major version.)
+//
+//   crow login [--stdin] [--api <base>]   sign in with an API key
+//   crow logout                           clear every credential backend
+//   crow whoami                           org · key name · scope
+//   crow gateways [setup <id>]            model gateway status + setup
+//   crow crowcode [...]                   the CrowCode coding agent
+//   crow crowgent [...]                   fleet CLI (not shipped yet)
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+import { DEFAULT_API_BASE, crowPaint, loginCommand, logoutCommand, terminalIO, whoamiCommand, } from '@orchestree/cli-core';
+import { gatewaysCommand } from './gateways.js';
+import { completionsCommand, doctorCommand, updateCommand } from './maintenance.js';
+// Same words on every terminal — crowPaint degrades to plain text when
+// stdout is not a TTY or NO_COLOR is set, so piped `crow --help` stays clean.
+function renderHelp() {
+    const p = crowPaint();
+    const cmd = (s) => p.accent(s);
+    const dim = (s) => p.dim(s);
+    return `${p.accentBright(p.bold('CrowCode CLI (crow)'))} — The Everything Platform in your terminal
+
+${p.bold('usage:')}
+  ${cmd('crow')}                                  launch the CrowCode coding agent
+  ${cmd('crow login')} [--stdin] [--api <base>]   sign in with an Orchestree API key
+                                        ${dim('(hidden prompt; --stdin reads the key from a pipe)')}
+  ${cmd('crow logout')}                           sign out — clears every credential backend
+  ${cmd('crow whoami')}                           show org · key name · scope for the active credential
+  ${cmd('crow gateways')}                         list model gateways and their status
+  ${cmd('crow gateways setup')} <id> [--project <p>] [--region <r>]
+                                        configure a gateway (vertex)
+  ${cmd('crow crowcode')} [args...]               launch the CrowCode coding agent
+  ${cmd('crow crowgent')} [args...]               fleet CLI — not shipped yet
+  ${cmd('crow --version')} | ${cmd('crow --help')}
 
-Usage: orchestree <command> [options]
+${p.bold('agent shortcuts')} ${dim('(forwarded to the CrowCode agent)')}:
+  ${cmd('crow')} "fix the failing test"           one-shot: run the task, print, exit
+  ${cmd('crow -p')} "prompt" [--output-format plain|json|streaming-json]
+  ${cmd('crow -c')} | ${cmd('crow -r')} [<id>]                continue / resume a session
+  ${cmd('crow models')}                           list model tiers
+  ${cmd('crow sessions')} [search <q> | delete <id>]
+  ${cmd('crow export')} <session-id> [file.md]    session transcript as Markdown
 
-Commands:
-  login [api-key]                   Save API key to config
-  chat "message" [--agent <slug>]   Chat with an agent
-  agents list                       List your agents
-  agents types [b2c|b2b]            List available agent types
-  agents create <slug> [name]       Create a new agent
-  agents get <id>                   Get agent details
-  status                            Agent heartbeat overview
-  deploy <agent-id> <channel>       Deploy agent to channel
-  registry search [options]         Search 11K+ agent registry
-  registry info <slug>              Get agent details from registry
-  registry stats                    Show registry statistics
-  run <slug> "message" [--stream]   Execute a specific agent
-  orchestrate "message" [--stream]  Auto-orchestrate with best agent
-  help                              Show this help
-  version                           Show version
+${p.bold('maintenance:')}
+  ${cmd('crow update')} [--check]                 update to the latest release
+  ${cmd('crow doctor')}                           diagnose the install (PATH shadowing, CDN, API)
+  ${cmd('crow completions')} <zsh|bash>           print shell completions
 
-Environment:
-  ORCHESTREE_API_KEY                API key (overrides config file)
+${p.bold('auth notes:')}
+  ${dim('·')} keys are stored in the OS keychain (0600 file fallback with a warning)
+  ${dim('·')} ORCHESTREE_API_KEY overrides stored credentials — CI only; any agent
+    subprocess this CLI spawns can read the environment
+  ${dim('·')} the key is never accepted as a command-line argument
 
-Config: ~/.orchestree/config.json
-`);
+${dim('alias: `orchestree` runs this same CLI (kept for one major version)')}
+`;
+}
+function versionString() {
+    try {
+        const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+        return pkg.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+function readFlag(args, name) {
+    const i = args.indexOf(name);
+    if (i === -1)
+        return { value: null, rest: args };
+    const value = args[i + 1];
+    if (!value || value.startsWith('--'))
+        return { value: null, rest: args };
+    return { value, rest: [...args.slice(0, i), ...args.slice(i + 2)] };
+}
+async function runCrowcode(args) {
+    const require = createRequire(import.meta.url);
+    let entry;
+    try {
+        entry = require.resolve('@orchestree/crowcode-cli/bin/crowcode.js');
+    }
+    catch {
+        process.stderr.write('crowcode is not installed alongside this CLI — run `npm i -g @orchestree/cli`\n');
+        return 1;
+    }
+    return new Promise((resolve) => {
+        const child = spawn(process.execPath, [entry, ...args], { stdio: 'inherit' });
+        child.on('close', (code) => resolve(code ?? 1));
+    });
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    const cmd = argv[0];
+    const io = terminalIO();
+    if (!cmd) {
+        // Bare `crow` is the product: launch the CrowCode coding agent.
+        process.exitCode = await runCrowcode([]);
+        return;
+    }
+    if (cmd === '--help' || cmd === '-h' || cmd === 'help') {
+        process.stdout.write(renderHelp());
+        return;
+    }
+    if (cmd === '--version' || cmd === '-v' || cmd === 'version') {
+        process.stdout.write(`crow ${versionString()}\n`);
+        return;
+    }
+    switch (cmd) {
+        case 'login': {
+            const { value: apiBase, rest } = readFlag(argv.slice(1), '--api');
+            const stdin = rest.includes('--stdin');
+            const leftovers = rest.filter((a) => a !== '--stdin');
+            if (leftovers.length > 0) {
+                // The key itself is NEVER accepted via argv.
+                io.err('crow login does not accept the key as an argument — it would leak into shell history and process lists.');
+                io.err('Use the hidden prompt (`crow login`) or pipe it: `crow login --stdin < keyfile`');
+                process.exitCode = 2;
+                return;
+            }
+            process.exitCode = await loginCommand({
+                apiBase: apiBase ?? DEFAULT_API_BASE,
+                stdin,
+                io,
+            });
+            return;
+        }
+        case 'logout':
+            process.exitCode = await logoutCommand({ apiBase: DEFAULT_API_BASE, io });
+            return;
+        case 'whoami': {
+            const { value: apiBase } = readFlag(argv.slice(1), '--api');
+            process.exitCode = await whoamiCommand({ apiBase: apiBase ?? DEFAULT_API_BASE, io });
+            return;
+        }
+        case 'gateways':
+            process.exitCode = await gatewaysCommand(argv.slice(1), io);
+            return;
+        case 'crowcode':
+            process.exitCode = await runCrowcode(argv.slice(1));
+            return;
+        case 'models':
+        case 'sessions':
+        case 'export':
+            // Session/model management lives in the agent — forward verbatim.
+            process.exitCode = await runCrowcode(argv);
+            return;
+        case 'update':
+            process.exitCode = await updateCommand(argv.slice(1), versionString(), io);
+            return;
+        case 'doctor':
+            process.exitCode = await doctorCommand(versionString(), io);
+            return;
+        case 'completions':
+            process.exitCode = completionsCommand(argv[1], io);
+            return;
+        case 'crowgent':
+            // Honest-Beta: unbuilt capability says so and exits non-zero.
+            io.err('the crowgent fleet CLI has not shipped yet (Wave D of the CLI suite) — nothing was run');
+            process.exitCode = 1;
+            return;
+        default:
+            // Everything else — prompts (`crow "fix the test"`) and agent flags
+            // (`crow -p … --output-format json`, `crow -c`) — is the agent's.
+            process.exitCode = await runCrowcode(argv);
+    }
 }
 main().catch((err) => {
-    console.error('Fatal error:', err.message);
+    process.stderr.write(`${err.message}\n`);
     process.exit(1);
 });

package/dist/maintenance.d.ts

@@ -0,0 +1,10 @@
+import { type CliIO } from '@orchestree/cli-core';
+export declare const CDN_LATEST_URL = "https://media.orchestree.ai/cli/latest";
+export declare const INSTALLER_URL = "https://orchestree.ai/crow";
+/** Numeric semver compare: >0 when a is newer than b. */
+export declare function compareVersions(a: string, b: string): number;
+/** Every `crow` executable reachable through PATH, in PATH order. */
+export declare function pathShadows(binName?: string): string[];
+export declare function updateCommand(args: string[], currentVersion: string, io: CliIO): Promise<number>;
+export declare function doctorCommand(currentVersion: string, io: CliIO): Promise<number>;
+export declare function completionsCommand(shell: string | undefined, io: CliIO): number;

package/dist/maintenance.js

@@ -0,0 +1,217 @@
+// Self-maintenance: `crow update`, `crow doctor`, `crow completions`.
+// Everything reports what it actually observed — no simulated checks.
+import { spawn } from 'node:child_process';
+import { accessSync, constants, realpathSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { DEFAULT_API_BASE, crowPaint } from '@orchestree/cli-core';
+export const CDN_LATEST_URL = 'https://media.orchestree.ai/cli/latest';
+export const INSTALLER_URL = 'https://orchestree.ai/crow';
+async function fetchText(url, timeoutMs = 8_000) {
+    const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+    if (!res.ok)
+        throw new Error(`${url} → HTTP ${res.status}`);
+    return (await res.text()).trim();
+}
+/** Numeric semver compare: >0 when a is newer than b. */
+export function compareVersions(a, b) {
+    const pa = a.split('.').map((n) => Number.parseInt(n, 10) || 0);
+    const pb = b.split('.').map((n) => Number.parseInt(n, 10) || 0);
+    for (let i = 0; i < 3; i++) {
+        const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (d !== 0)
+            return d;
+    }
+    return 0;
+}
+/** The real on-disk home of the code that is currently running. */
+function installOrigin() {
+    try {
+        return realpathSync(fileURLToPath(import.meta.url));
+    }
+    catch {
+        return process.argv[1] ?? '(unknown)';
+    }
+}
+/** Every `crow` executable reachable through PATH, in PATH order. */
+export function pathShadows(binName = 'crow') {
+    const dirs = (process.env.PATH ?? '').split(path.delimiter).filter(Boolean);
+    const found = [];
+    for (const dir of dirs) {
+        const candidate = path.join(dir, binName);
+        try {
+            accessSync(candidate, constants.X_OK);
+            const real = realpathSync(candidate);
+            if (!found.includes(real))
+                found.push(real);
+        }
+        catch {
+            // not here — keep walking PATH
+        }
+    }
+    return found;
+}
+export async function updateCommand(args, currentVersion, io) {
+    const checkOnly = args.includes('--check');
+    let latest;
+    try {
+        latest = await fetchText(CDN_LATEST_URL);
+    }
+    catch (err) {
+        io.err(`could not reach the release CDN (${CDN_LATEST_URL}): ${err.message}`);
+        return 1;
+    }
+    if (!/^\d+\.\d+\.\d+$/.test(latest)) {
+        io.err(`release CDN returned an unexpected version pointer: ${JSON.stringify(latest.slice(0, 40))}`);
+        return 1;
+    }
+    const behind = compareVersions(latest, currentVersion) > 0;
+    if (!behind) {
+        io.out(`crow ${currentVersion} is up to date (latest: ${latest})`);
+        return 0;
+    }
+    io.out(`update available: crow ${currentVersion} → ${latest}`);
+    if (checkOnly) {
+        io.out('run `crow update` to install it');
+        return 0;
+    }
+    const origin = installOrigin();
+    const crowHome = path.join(os.homedir(), '.crow');
+    if (!origin.startsWith(crowHome)) {
+        io.err(`note: this copy runs from ${origin}, not ${crowHome} — the installer refreshes ${crowHome}; run \`crow doctor\` if the old copy keeps winning on PATH`);
+    }
+    io.out(`running the installer: curl -fsSL ${INSTALLER_URL} | sh`);
+    return new Promise((resolve) => {
+        const child = spawn('sh', ['-c', `curl -fsSL ${INSTALLER_URL} | sh`], { stdio: 'inherit' });
+        child.on('close', (code) => resolve(code ?? 1));
+    });
+}
+export async function doctorCommand(currentVersion, io) {
+    const p = crowPaint();
+    const pass = (label, detail) => io.out(`  ${p.ok('✓')} ${p.bold(label.padEnd(16))} ${detail}`);
+    const warn = (label, detail) => io.out(`  ${p.warn('!')} ${p.bold(label.padEnd(16))} ${detail}`);
+    const fail = (label, detail) => io.out(`  ${p.err('✗')} ${p.bold(label.padEnd(16))} ${detail}`);
+    let problems = 0;
+    // 1. Node runtime
+    const major = Number.parseInt(process.versions.node.split('.')[0], 10);
+    if (major >= 18)
+        pass('node', `v${process.versions.node} (${process.execPath})`);
+    else {
+        fail('node', `v${process.versions.node} — crow needs Node >= 18`);
+        problems++;
+    }
+    // 2. Install origin
+    const origin = installOrigin();
+    const crowHome = path.join(os.homedir(), '.crow');
+    if (origin.startsWith(crowHome))
+        pass('install', origin);
+    else
+        warn('install', `${origin} — not the standard ${crowHome} install (npm link or npm -g?)`);
+    // 3. PATH shadowing — the exact failure mode behind "old interface" bugs.
+    const shadows = pathShadows();
+    if (shadows.length === 0) {
+        warn('path', '`crow` is not on PATH (running via an absolute path?)');
+    }
+    else if (shadows.length === 1) {
+        pass('path', shadows[0]);
+    }
+    else {
+        fail('path', `${shadows.length} different \`crow\` binaries on PATH — the first one wins:`);
+        for (const s of shadows)
+            io.out(`      ${s === shadows[0] ? p.warn('→') : ' '} ${s}`);
+        io.out(`      remove stale copies (e.g. \`npm rm -g @orchestree/cli\`) so ${crowHome}/bin wins`);
+        problems++;
+    }
+    // 4. Release CDN + version currency
+    try {
+        const latest = await fetchText(CDN_LATEST_URL);
+        if (compareVersions(latest, currentVersion) > 0) {
+            warn('version', `${currentVersion} installed, ${latest} available — run \`crow update\``);
+        }
+        else {
+            pass('version', `${currentVersion} (latest: ${latest})`);
+        }
+    }
+    catch (err) {
+        fail('cdn', `${CDN_LATEST_URL} unreachable: ${err.message}`);
+        problems++;
+    }
+    // 5. API reachability — any HTTP answer proves the wire works.
+    try {
+        const res = await fetch(`${DEFAULT_API_BASE}/health`, {
+            signal: AbortSignal.timeout(8_000),
+        });
+        pass('api', `${DEFAULT_API_BASE} reachable (HTTP ${res.status})`);
+    }
+    catch (err) {
+        fail('api', `${DEFAULT_API_BASE} unreachable: ${err.message}`);
+        problems++;
+    }
+    io.out('');
+    io.out(problems === 0 ? p.ok('no problems found') : p.err(`${problems} problem${problems === 1 ? '' : 's'} found`));
+    return problems === 0 ? 0 : 1;
+}
+const SUBCOMMANDS = 'login logout whoami gateways crowcode models sessions export update doctor completions help version';
+const ZSH_COMPLETION = `#compdef crow
+# crow zsh completion — generated by \`crow completions zsh\`
+# install: crow completions zsh > "\${fpath[1]}/_crow" && autoload -Uz compinit && compinit
+_crow() {
+  local -a subcmds
+  subcmds=(
+    'login:sign in with an Orchestree API key'
+    'logout:clear stored credentials'
+    'whoami:show the active credential'
+    'gateways:model gateway status + setup'
+    'crowcode:launch the CrowCode coding agent'
+    'models:list model tiers'
+    'sessions:list, search, or delete sessions'
+    'export:export a session transcript as Markdown'
+    'update:update crow to the latest release'
+    'doctor:diagnose the installation'
+    'completions:print shell completions'
+  )
+  if (( CURRENT == 2 )); then
+    _describe 'crow command' subcmds
+    return
+  fi
+  case "\${words[2]}" in
+    sessions) compadd list search delete ;;
+    completions) compadd zsh bash ;;
+    update) compadd -- --check ;;
+    gateways) compadd setup ;;
+  esac
+}
+_crow "$@"
+`;
+const BASH_COMPLETION = `# crow bash completion — generated by \`crow completions bash\`
+# install: crow completions bash >> ~/.bashrc  (or into bash_completion.d)
+_crow_completions() {
+  local cur prev
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  if [ "\$COMP_CWORD" -eq 1 ]; then
+    COMPREPLY=( \$(compgen -W "${SUBCOMMANDS}" -- "\$cur") )
+    return
+  fi
+  case "\$prev" in
+    sessions) COMPREPLY=( \$(compgen -W "list search delete" -- "\$cur") ) ;;
+    completions) COMPREPLY=( \$(compgen -W "zsh bash" -- "\$cur") ) ;;
+    update) COMPREPLY=( \$(compgen -W "--check" -- "\$cur") ) ;;
+    gateways) COMPREPLY=( \$(compgen -W "setup" -- "\$cur") ) ;;
+  esac
+}
+complete -F _crow_completions crow
+`;
+export function completionsCommand(shell, io) {
+    if (shell === 'zsh') {
+        process.stdout.write(ZSH_COMPLETION);
+        return 0;
+    }
+    if (shell === 'bash') {
+        process.stdout.write(BASH_COMPLETION);
+        return 0;
+    }
+    io.err('usage: crow completions <zsh|bash>');
+    return 2;
+}

package/package.json

@@ -1,57 +1,55 @@
 {
   "name": "@orchestree/cli",
-  "version": "2.2.0",
-  "description": "Command-line interface for the Orchestree Platform",
+  "version": "3.5.0",
+  "description": "CrowCode CLI (crow) — the Orchestree platform in your terminal: sign in, inspect your identity, manage model gateways, and launch the suite's agents. Installs the `crow` command (`orchestree` remains as an alias).",
   "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/multivitaminds/Orchestree.git",
+    "directory": "apps/orchestree-cli"
   },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE",
-    "bin"
-  ],
   "keywords": [
+    "crow",
+    "crowcode",
     "orchestree",
     "cli",
     "command-line",
     "devtools"
   ],
-  "author": "Orchestree <hello@orchestree.ai>",
-  "license": "MIT",
-  "homepage": "https://orchestree.ai/developer/cli",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/orchestree/orchestree.git",
-    "directory": "packages/cli"
-  },
-  "bugs": {
-    "url": "https://github.com/orchestree/orchestree/issues"
-  },
-  "scripts": {
-    "build": "tsc --outDir dist",
-    "dev": "tsc --outDir dist --watch",
-    "start": "node bin/orchestree.js",
-    "test": "echo \"Tests passed\" && exit 0",
-    "clean": "rm -rf dist",
-    "prepublishOnly": "npm run build"
+  "bin": {
+    "crow": "./bin/crow.js",
+    "orchestree": "./bin/orchestree.js"
   },
+  "files": [
+    "bin",
+    "dist",
+    "CHANGELOG.md"
+  ],
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20"
   },
-  "publishConfig": {
-    "access": "public"
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "echo 'No lint configured for orchestree-cli yet'"
   },
   "dependencies": {
-    "@orchestree/sdk": "^1.5.0"
+    "@orchestree/cli-core": "0.2.0",
+    "@orchestree/crowcode-cli": "0.5.0"
   },
-  "bin": {
-    "orchestree": "./bin/orchestree.js"
+  "devDependencies": {
+    "@orchestree/typescript-config": "0.0.0",
+    "@types/node": "^24.10.1",
+    "tsx": "^4.20.0",
+    "typescript": "~5.9.3",
+    "vitest": "^4.0.18"
   }
-}
+}

package/dist/commands/agents.d.ts

@@ -1 +0,0 @@
-export declare function agentsCommand(args: string[]): Promise<void>;