orquesta-cli 0.2.25 → 0.2.27

package/dist/cli.js

@@ -53,7 +53,8 @@ program
     .option('--sync', 'Sync configurations with Orquesta and exit')
     .option('--scan', 'Scan for available LLM providers (env vars + local ports)')
     .option('--add-provider <providerId>', 'Add a specific provider by ID (e.g., openai, anthropic, ollama)')
-    .option('--init', 'Initialize Claude Code hook integration for this project (requires --token)')
+    .option('--init', 'Enable the Claude Code hook in this directory (reuses your login; or pass --token)')
+    .option('--disable-hook', 'Disable the Claude Code hook in this directory')
     .action(async (options) => {
     if (options.appendSystemPrompt) {
         setAppendedSystemPrompt(options.appendSystemPrompt);
@@ -63,12 +64,22 @@ program
         return;
     }
     if (options.init) {
-        if (!options.token) {
-            console.error('Error: --init requires --token. Usage: orquesta --init --token <token>');
+        await configManager.initialize();
+        const saved = configManager.getOrquestaConfig();
+        const token = options.token || saved?.token;
+        if (!token) {
+            console.error(chalk.red('Error: not connected to Orquesta.'));
+            console.error('Run ' + chalk.cyan('orquesta --login') + ' first, or pass ' + chalk.cyan('orquesta --init --token oat_…') + '.');
             process.exit(1);
         }
         const { initHooks } = await import('./orquesta/hook-init.js');
-        await initHooks(options.token);
+        const preferredProjectId = options.project || (options.token ? undefined : saved?.projectId);
+        await initHooks(token, undefined, preferredProjectId);
+        return;
+    }
+    if (options.disableHook) {
+        const { disableHooks } = await import('./orquesta/hook-init.js');
+        disableHooks();
         return;
     }
     await configManager.initialize();
@@ -312,7 +323,9 @@ program.on('command:*', () => {
     console.log(chalk.white('  --token <token>         Connect to Orquesta dashboard\n'));
     console.log(chalk.white('  --project <id>          Select project when connecting\n'));
     console.log(chalk.white('  --switch-project [id]   Switch to a different project\n'));
-    console.log(chalk.white('  --status                Show Orquesta connection status\n'));
+    console.log(chalk.white('  --status                Show connection + hook status\n'));
+    console.log(chalk.white('  --init                  Enable the Claude Code hook here\n'));
+    console.log(chalk.white('  --disable-hook          Disable the Claude Code hook here\n'));
     console.log(chalk.white('  --sync                  Sync configurations with Orquesta\n'));
     console.log(chalk.white('  --disconnect            Disconnect from Orquesta\n'));
     console.log(chalk.white('  --scan                  Scan for available LLM providers\n'));

package/dist/orquesta/hook-init.d.ts

@@ -1,4 +1,4 @@
-export declare function initHooks(token: string, apiUrl?: string): Promise<void>;
+export declare function initHooks(token: string, apiUrl?: string, preferredProjectId?: string): Promise<void>;
 export declare function writeHookFiles(opts: {
     projectId: string;
     token: string;
@@ -7,4 +7,9 @@ export declare function writeHookFiles(opts: {
     agentBin?: string;
     quiet?: boolean;
 }): boolean;
+export declare function readHookConfig(cwd?: string): {
+    projectId: string;
+    apiUrl?: string;
+} | null;
+export declare function disableHooks(cwd?: string): void;
 //# sourceMappingURL=hook-init.d.ts.map

package/dist/orquesta/hook-init.js

@@ -31,12 +31,47 @@ function resolveAgentBin() {
     console.warn('  \x1b[33m  npm install -g orquesta-agent\x1b[0m\n');
     return 'orquesta-agent';
 }
-export async function initHooks(token, apiUrl = 'https://getorquesta.com') {
+async function resolveTargetProject(projects, preferredProjectId) {
+    if (preferredProjectId) {
+        const match = projects.find((p) => p.id === preferredProjectId);
+        if (match) {
+            console.log(`  Project: ${match.name}\n`);
+            return match;
+        }
+        console.warn(`  \x1b[33m⚠ Your saved project isn't visible to this token — pick one below.\x1b[0m\n`);
+    }
+    if (projects.length === 1) {
+        console.log(`  Project: ${projects[0].name}\n`);
+        return projects[0];
+    }
+    if (!process.stdin.isTTY) {
+        console.error(`  Error: this token can reach ${projects.length} projects and none was specified.\n` +
+            `  Re-run with: orquesta --init --project <projectId>`);
+        process.exit(1);
+    }
+    console.log('  Which project should this directory report to?\n');
+    projects.forEach((p, i) => console.log(`    ${i + 1}. ${p.name}`));
+    console.log();
+    const readline = await import('readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((resolve) => {
+        rl.question(`  Enter number (1-${projects.length}): `, (a) => { rl.close(); resolve(a.trim()); });
+    });
+    const num = parseInt(answer, 10);
+    const pick = (!isNaN(num) && num >= 1 && num <= projects.length) ? projects[num - 1] : null;
+    if (!pick) {
+        console.error('  Invalid selection.');
+        process.exit(1);
+        throw new Error();
+    }
+    console.log(`  Project: ${pick.name}\n`);
+    return pick;
+}
+export async function initHooks(token, apiUrl = 'https://getorquesta.com', preferredProjectId) {
     console.log('\n  Initializing Orquesta hook integration...\n');
     const agentBin = resolveAgentBin();
     console.log('  Validating token...');
-    let projectId;
-    let projectName;
+    let projects;
     try {
         const res = await fetch(`${apiUrl}/api/orquesta-cli/projects`, {
             headers: { 'Authorization': `Bearer ${token}` },
@@ -46,27 +81,25 @@ export async function initHooks(token, apiUrl = 'https://getorquesta.com') {
             console.error(`  Error: Invalid token`);
             process.exit(1);
         }
-        const firstProject = data.projects?.[0];
-        if (!firstProject) {
-            console.error('  Error: No projects found for this token');
-            process.exit(1);
-            throw new Error();
-        }
-        projectId = firstProject.id;
-        projectName = firstProject.name;
-        console.log(`  Connected to: ${projectName}\n`);
+        projects = data.projects ?? [];
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : 'Unknown error';
         console.error(`  Error: Could not reach ${apiUrl} (${msg})`);
         process.exit(1);
+        throw new Error();
     }
-    writeHookFiles({ projectId, token, apiUrl, agentBin });
+    if (projects.length === 0) {
+        console.error('  Error: No projects found for this token');
+        process.exit(1);
+    }
+    const chosen = await resolveTargetProject(projects, preferredProjectId);
+    writeHookFiles({ projectId: chosen.id, token, apiUrl, agentBin });
     console.log(`
-  Done! Now run \`claude\` in this directory — all activity will
-  be tracked in Orquesta automatically.
+  Done! "${chosen.name}" is wired to this directory.
+  Run \`claude\` here and every session streams into Orquesta automatically.
 
-  Dashboard: ${apiUrl}/dashboard/projects/${projectId}
+  Dashboard: ${apiUrl}/dashboard/projects/${chosen.id}
 `);
 }
 export function writeHookFiles(opts) {
@@ -123,4 +156,64 @@ export function writeHookFiles(opts) {
         return false;
     }
 }
+export function readHookConfig(cwd = process.cwd()) {
+    try {
+        const p = path.join(cwd, '.orquesta.json');
+        if (!fs.existsSync(p))
+            return null;
+        const data = JSON.parse(fs.readFileSync(p, 'utf8'));
+        if (!data.projectId)
+            return null;
+        return { projectId: data.projectId, apiUrl: data.apiUrl };
+    }
+    catch {
+        return null;
+    }
+}
+export function disableHooks(cwd = process.cwd()) {
+    console.log('\n  Disabling Orquesta hook for this directory...\n');
+    let changed = false;
+    const settingsPath = path.join(cwd, '.claude', 'settings.json');
+    if (fs.existsSync(settingsPath)) {
+        try {
+            const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+            if (settings.hooks && typeof settings.hooks === 'object') {
+                for (const event of Object.keys(settings.hooks)) {
+                    const before = settings.hooks[event];
+                    if (!Array.isArray(before))
+                        continue;
+                    const after = before.filter((e) => !e.hooks?.some((h) => h.command?.includes('orquesta-agent hook')));
+                    if (after.length !== before.length)
+                        changed = true;
+                    if (after.length === 0)
+                        delete settings.hooks[event];
+                    else
+                        settings.hooks[event] = after;
+                }
+                if (Object.keys(settings.hooks).length === 0)
+                    delete settings.hooks;
+                fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+                if (changed)
+                    console.log('  Removed Orquesta hooks from .claude/settings.json');
+            }
+        }
+        catch {
+            console.warn('  \x1b[33m⚠ Could not parse .claude/settings.json — left untouched.\x1b[0m');
+        }
+    }
+    const orquestaJson = path.join(cwd, '.orquesta.json');
+    if (fs.existsSync(orquestaJson)) {
+        try {
+            fs.unlinkSync(orquestaJson);
+            changed = true;
+            console.log('  Removed .orquesta.json');
+        }
+        catch {
+            console.warn('  \x1b[33m⚠ Could not remove .orquesta.json.\x1b[0m');
+        }
+    }
+    console.log(changed
+        ? '\n  Done. Claude Code runs in this directory no longer report to Orquesta.\n'
+        : '\n  Nothing to do — no Orquesta hook was configured here.\n');
+}
 //# sourceMappingURL=hook-init.js.map

package/dist/setup/first-run-setup.js

@@ -4,7 +4,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { configManager } from '../core/config/config-manager.js';
 import { syncOrquestaConfigs, fetchOrquestaProjects } from '../orquesta/config-sync.js';
-import { writeHookFiles } from '../orquesta/hook-init.js';
+import { writeHookFiles, readHookConfig } from '../orquesta/hook-init.js';
 import { scanProviders, toEndpointConfig } from '../core/config/auto-detect.js';
 const ORQUESTA_API_URL = process.env['ORQUESTA_API_URL'] || 'https://getorquesta.com';
 export function needsFirstRunSetup() {
@@ -283,5 +283,19 @@ export function showConnectionStatus() {
     console.log(chalk.dim(`  Connected: ${orquestaConfig.connectedAt ? new Date(orquestaConfig.connectedAt).toLocaleString() : 'Unknown'}`));
     console.log(chalk.dim(`  Last sync: ${orquestaConfig.lastSyncAt ? new Date(orquestaConfig.lastSyncAt).toLocaleString() : 'Never'}`));
     console.log(chalk.dim(`  Auto-sync: ${orquestaConfig.autoSync !== false ? 'Enabled' : 'Disabled'}`));
+    const hook = readHookConfig();
+    console.log();
+    if (hook) {
+        const sameAsConnected = hook.projectId === orquestaConfig.projectId;
+        const name = sameAsConnected && orquestaConfig.projectName ? orquestaConfig.projectName : hook.projectId;
+        console.log(chalk.green('Claude Code hook: enabled in this directory'));
+        console.log(chalk.dim(`  Streaming into: ${name}`));
+        console.log(chalk.dim(`  Project ID: ${hook.projectId}`));
+        console.log(chalk.dim(`  Disable with: orquesta --disable-hook`));
+    }
+    else {
+        console.log(chalk.yellow('Claude Code hook: not enabled in this directory'));
+        console.log(chalk.dim(`  Enable with: orquesta --init`));
+    }
 }
 //# sourceMappingURL=first-run-setup.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orquesta-cli",
-  "version": "0.2.25",
+  "version": "0.2.27",
   "description": "Orquesta CLI - AI-powered coding assistant with team collaboration",
   "type": "module",
   "main": "dist/index.js",