@respan/cli 0.5.2 → 0.6.0

package/dist/commands/auth/login.js

@@ -113,8 +113,8 @@ class AuthLogin extends BaseCommand {
         const method = await select({
             message: 'How would you like to authenticate?',
             choices: [
-                { name: 'Browser login (recommended)', value: 'browser' },
-                { name: 'API key', value: 'api_key' },
+                { name: 'API key (recommended)', value: 'api_key' },
+                { name: 'Browser login', value: 'browser' },
             ],
         });
         if (method === 'api_key') {

package/dist/commands/integrate/claude-code.js

@@ -1,7 +1,7 @@
 import * as fs from 'node:fs';
-import { execSync } from 'node:child_process';
+// execSync no longer needed — JS hooks don't require pip install
 import { BaseCommand } from '../../lib/base-command.js';
-import { integrateFlags, deepMerge, readJsonFile, writeJsonFile, writeTextFile, expandHome, parseAttrs, getHookScript, resolveScope, findProjectRoot, } from '../../lib/integrate.js';
+import { integrateFlags, deepMerge, readJsonFile, writeJsonFile, writeTextFile, expandHome, parseAttrs, getJsHookScript, resolveScope, findProjectRoot, } from '../../lib/integrate.js';
 class IntegrateClaudeCode extends BaseCommand {
     async run() {
         const { flags } = await this.parse(IntegrateClaudeCode);
@@ -22,42 +22,23 @@ class IntegrateClaudeCode extends BaseCommand {
             const doLocal = scope === 'local' || scope === 'both';
             // ── Global: hook script + registration ────────────────────────
             if (doGlobal) {
-                // 1. Ensure Python 'requests' is available
-                if (!dryRun) {
-                    try {
-                        execSync('python3 -c "import requests"', { stdio: 'pipe' });
-                    }
-                    catch {
-                        this.log('Installing Python requests package...');
-                        try {
-                            execSync('pip3 install requests', { stdio: 'pipe' });
-                            this.log('Installed requests.');
-                        }
-                        catch {
-                            this.warn('Could not install Python requests package automatically.\n' +
-                                'Install it manually: pip3 install requests');
-                        }
-                    }
-                }
-                else {
-                    this.log('[dry-run] Would verify Python requests package');
-                }
-                // 2. Write hook script
-                const hookPath = expandHome('~/.respan/hook.py');
+                // 1. Write JS hook script (no Python dependency needed)
+                const hookDir = expandHome('~/.respan/hooks');
+                const hookPath = `${hookDir}/claude-code.cjs`;
                 if (dryRun) {
                     this.log(`[dry-run] Would write hook script to: ${hookPath}`);
                 }
                 else {
-                    writeTextFile(hookPath, getHookScript());
+                    writeTextFile(hookPath, getJsHookScript('claude-code'));
                     fs.chmodSync(hookPath, 0o755);
                     this.log(`Wrote hook script: ${hookPath}`);
                 }
-                // 3. Register Stop hook in global settings (no credentials here)
+                // 2. Register Stop hook in global settings (no credentials here)
                 const globalSettingsPath = expandHome('~/.claude/settings.json');
                 const globalSettings = readJsonFile(globalSettingsPath);
                 const hookEntry = {
                     matcher: '',
-                    hooks: [{ type: 'command', command: `python3 ${hookPath}` }],
+                    hooks: [{ type: 'command', command: `node ${hookPath}` }],
                 };
                 const hooksSection = (globalSettings.hooks || {});
                 const stopHooks = Array.isArray(hooksSection.Stop)
@@ -68,7 +49,7 @@ class IntegrateClaudeCode extends BaseCommand {
                         ? entry.hooks
                         : [];
                     return inner.some((h) => typeof h.command === 'string' &&
-                        (h.command.includes('respan') || h.command.includes('hook.py')));
+                        (h.command.includes('respan') || h.command.includes('hook.py') || h.command.includes('claude-code.js')));
                 });
                 if (existingIdx >= 0) {
                     stopHooks[existingIdx] = hookEntry;

package/dist/commands/integrate/codex-cli.d.ts

@@ -19,5 +19,13 @@ export default class IntegrateCodexCli extends BaseCommand {
         verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
+    /**
+     * Update or insert the `notify` line in a TOML config string.
+     *
+     * TOML bare keys must appear before the first [table] header.
+     * If a `notify` line already exists, replace it in-place.
+     * Otherwise, insert the notify line before the first [table] header.
+     */
+    private updateTomlNotify;
     private resolveApiKey;
 }

package/dist/commands/integrate/codex-cli.js

@@ -1,83 +1,141 @@
-import * as path from 'node:path';
+import * as fs from 'node:fs';
 import { BaseCommand } from '../../lib/base-command.js';
-import { integrateFlags, readTextFile, writeTextFile, expandHome, parseAttrs, toOtelResourceAttrs, resolveScope, findProjectRoot, } from '../../lib/integrate.js';
+import { integrateFlags, readTextFile, writeTextFile, writeJsonFile, readJsonFile, expandHome, parseAttrs, getJsHookScript, resolveScope, findProjectRoot, } from '../../lib/integrate.js';
 class IntegrateCodexCli extends BaseCommand {
     async run() {
         const { flags } = await this.parse(IntegrateCodexCli);
         this.globalFlags = flags;
         try {
-            const apiKey = this.resolveApiKey();
-            const baseUrl = (flags['base-url']).replace(/\/+$/, '');
+            // Verify the user is authenticated (key is read by hook from ~/.respan/)
+            this.resolveApiKey();
             const projectId = flags['project-id'];
+            const customerId = flags['customer-id'];
+            const spanName = flags['span-name'];
+            const workflowName = flags['workflow-name'];
             const attrs = parseAttrs(flags.attrs);
             const dryRun = flags['dry-run'];
-            const scope = resolveScope(flags, 'local');
-            // Resolve target config file
-            const configPath = scope === 'global'
-                ? expandHome('~/.codex/config.toml')
-                : path.join(findProjectRoot(), '.codex', 'config.toml');
-            const existing = readTextFile(configPath);
-            // Check for existing [otel] block
-            if (/^\[otel\]/m.test(existing)) {
-                this.warn(`[otel] section already exists in ${configPath} — skipping to avoid overwrite.`);
-                this.warn('Remove or rename the existing [otel] section and re-run to update.');
-                return;
+            // Codex CLI default: both global + local
+            const scope = resolveScope(flags, 'both');
+            const doGlobal = scope === 'global' || scope === 'both';
+            const doLocal = scope === 'local' || scope === 'both';
+            // ── Global: hook script + notify registration ──────────────────
+            if (doGlobal) {
+                // 1. Write JS hook script (no Python dependency needed)
+                const hookDir = expandHome('~/.respan/hooks');
+                const hookPath = `${hookDir}/codex-cli.cjs`;
+                if (dryRun) {
+                    this.log(`[dry-run] Would write hook script to: ${hookPath}`);
+                }
+                else {
+                    writeTextFile(hookPath, getJsHookScript('codex-cli'));
+                    fs.chmodSync(hookPath, 0o755);
+                    this.log(`Wrote hook script: ${hookPath}`);
+                }
+                // 2. Register notify hook in ~/.codex/config.toml
+                const configPath = expandHome('~/.codex/config.toml');
+                const existing = readTextFile(configPath);
+                const notifyValue = `notify = ["node", "${hookPath}"]`;
+                const updated = this.updateTomlNotify(existing, notifyValue);
+                if (dryRun) {
+                    this.log(`[dry-run] Would update: ${configPath}`);
+                    this.log(updated);
+                }
+                else {
+                    writeTextFile(configPath, updated);
+                    this.log(`Updated config: ${configPath}`);
+                }
             }
-            // Build resource attributes
-            const resourceAttrs = {
-                'service.name': 'codex-cli',
-                ...attrs,
-            };
-            if (projectId) {
-                resourceAttrs['respan.project_id'] = projectId;
+            // ── Local: .codex/respan.json ──────────────────────────────────
+            if (doLocal) {
+                const projectRoot = findProjectRoot();
+                const respanConfigPath = `${projectRoot}/.codex/respan.json`;
+                const respanConfig = readJsonFile(respanConfigPath);
+                const newConfig = { ...respanConfig };
+                if (customerId) {
+                    newConfig.customer_id = customerId;
+                }
+                if (spanName) {
+                    newConfig.span_name = spanName;
+                }
+                if (workflowName) {
+                    newConfig.workflow_name = workflowName;
+                }
+                if (projectId) {
+                    newConfig.project_id = projectId;
+                }
+                // Custom attrs go as top-level keys (unknown keys = custom properties)
+                for (const [k, v] of Object.entries(attrs)) {
+                    newConfig[k] = v;
+                }
+                if (Object.keys(newConfig).length > 0) {
+                    if (dryRun) {
+                        this.log(`[dry-run] Would write: ${respanConfigPath}`);
+                        this.log(JSON.stringify(newConfig, null, 2));
+                    }
+                    else {
+                        writeJsonFile(respanConfigPath, newConfig);
+                        this.log(`Wrote Respan config: ${respanConfigPath}`);
+                    }
+                }
             }
-            const otelResStr = toOtelResourceAttrs(resourceAttrs);
-            // Build TOML block
-            const endpoint = `${baseUrl}/v2/traces`;
-            const lines = [
-                '',
-                '# Respan observability (added by respan integrate codex-cli)',
-                '[otel]',
-                'log_user_prompt = true',
-            ];
-            if (otelResStr) {
-                lines.push(`resource_attributes = "${otelResStr}"`);
+            // ── Done ────────────────────────────────────────────────────────
+            this.log('');
+            if (doGlobal && doLocal) {
+                this.log('Codex CLI integration complete (global hook + project config).');
             }
-            lines.push('');
-            lines.push('[otel.exporter."otlp-http"]');
-            lines.push(`endpoint = "${endpoint}"`);
-            lines.push('protocol = "binary"');
-            lines.push('');
-            lines.push('[otel.exporter."otlp-http".headers]');
-            lines.push(`"Authorization" = "Bearer ${apiKey}"`);
-            lines.push('');
-            lines.push('[otel.trace_exporter."otlp-http"]');
-            lines.push(`endpoint = "${endpoint}"`);
-            lines.push('protocol = "binary"');
-            lines.push('');
-            lines.push('[otel.trace_exporter."otlp-http".headers]');
-            lines.push(`"Authorization" = "Bearer ${apiKey}"`);
-            lines.push('');
-            const block = lines.join('\n');
-            const updated = existing.trimEnd() + '\n' + block;
-            if (dryRun) {
-                this.log(`[dry-run] Would append to: ${configPath}`);
-                this.log(block);
+            else if (doGlobal) {
+                this.log('Codex CLI global hook installed.');
+                this.log('Run without --global in a project to configure tracing there.');
             }
             else {
-                writeTextFile(configPath, updated);
-                this.log(`Updated config: ${configPath}`);
+                this.log('Codex CLI tracing configured for this project.');
             }
             this.log('');
-            this.log(`Codex CLI integration complete (${scope}).`);
+            this.log('Auth:   ~/.respan/credentials.json  (from `respan auth login`)');
+            this.log('Config: .codex/respan.json                 (shareable, non-secret)');
+            this.log('');
+            this.log('Set properties via integrate flags or edit .codex/respan.json:');
+            this.log('  respan integrate codex-cli --customer-id "frank" --span-name "my-app"');
+            this.log('  respan integrate codex-cli --attrs \'{"team":"platform","env":"staging"}\'');
             this.log('');
-            this.log('Set dynamic attributes before a session:');
-            this.log('  export OTEL_RESOURCE_ATTRIBUTES="env=prod,task_id=T-123"');
+            this.log('Override per-session with env vars:');
+            this.log('  export RESPAN_CUSTOMER_ID="your-name"');
+            this.log("  export RESPAN_METADATA='{\"task_id\":\"T-123\"}'");
+            this.log('');
+            this.log('Debug: CODEX_RESPAN_DEBUG=true → check ~/.codex/state/respan_hook.log');
         }
         catch (error) {
             this.handleError(error);
         }
     }
+    /**
+     * Update or insert the `notify` line in a TOML config string.
+     *
+     * TOML bare keys must appear before the first [table] header.
+     * If a `notify` line already exists, replace it in-place.
+     * Otherwise, insert the notify line before the first [table] header.
+     */
+    updateTomlNotify(existing, notifyValue) {
+        const lines = existing.split('\n');
+        // Check if notify line already exists
+        const notifyIdx = lines.findIndex((line) => /^\s*notify\s*=/.test(line));
+        if (notifyIdx >= 0) {
+            // Replace existing notify line
+            lines[notifyIdx] = notifyValue;
+            return lines.join('\n');
+        }
+        // Find the first [table] header to insert before it
+        const firstTableIdx = lines.findIndex((line) => /^\s*\[/.test(line));
+        if (firstTableIdx >= 0) {
+            // Insert notify + comment before the first table header
+            lines.splice(firstTableIdx, 0, '# Respan observability (added by respan integrate codex-cli)', notifyValue, '');
+        }
+        else {
+            // No tables at all — append to end
+            lines.push('', '# Respan observability (added by respan integrate codex-cli)', notifyValue);
+        }
+        return lines.join('\n');
+    }
     resolveApiKey() {
         const auth = this.getAuth();
         if (auth.apiKey)
@@ -91,17 +149,18 @@ class IntegrateCodexCli extends BaseCommand {
 }
 IntegrateCodexCli.description = `Integrate Respan with Codex CLI.
 
-Codex CLI has native OTel traces (prompts, tool approvals, results)
-so we append an [otel] block to its TOML config.
+Installs a notify hook that reads session JSONL files and sends
+them to Respan as structured spans (chat, tool, reasoning).
 
 Scope:
-  --local    Write to .codex/config.toml in project root (default)
-  --global   Write to ~/.codex/config.toml
-  If [otel] already exists in the target file, warns and does not overwrite.`;
+  --global   Install hook script + register notify in ~/.codex/config.toml
+  --local    Write .codex/respan.json with customer_id, span_name, etc.
+  (default)  Both: install hook globally + config for current project`;
 IntegrateCodexCli.examples = [
     'respan integrate codex-cli',
     'respan integrate codex-cli --global',
-    'respan integrate codex-cli --project-id my-project --attrs \'{"env":"prod"}\'',
+    'respan integrate codex-cli --local --customer-id frank',
+    'respan integrate codex-cli --attrs \'{"env":"prod"}\'',
     'respan integrate codex-cli --dry-run',
 ];
 IntegrateCodexCli.flags = {

package/dist/commands/integrate/gemini-cli.js

@@ -1,78 +1,121 @@
+import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { BaseCommand } from '../../lib/base-command.js';
-import { integrateFlags, deepMerge, readJsonFile, writeJsonFile, readTextFile, writeTextFile, expandHome, parseAttrs, toOtelResourceAttrs, resolveScope, findProjectRoot, } from '../../lib/integrate.js';
+import { integrateFlags, deepMerge, readJsonFile, writeJsonFile, writeTextFile, expandHome, parseAttrs, getJsHookScript, resolveScope, findProjectRoot, DEFAULT_BASE_URL, } from '../../lib/integrate.js';
 class IntegrateGeminiCli extends BaseCommand {
     async run() {
         const { flags } = await this.parse(IntegrateGeminiCli);
         this.globalFlags = flags;
         try {
-            const apiKey = this.resolveApiKey();
-            const baseUrl = (flags['base-url']).replace(/\/+$/, '');
+            // Verify the user is authenticated (key is read by hook from ~/.respan/)
+            this.resolveApiKey();
             const projectId = flags['project-id'];
+            const customerId = flags['customer-id'];
+            const spanName = flags['span-name'];
+            const workflowName = flags['workflow-name'];
             const attrs = parseAttrs(flags.attrs);
             const dryRun = flags['dry-run'];
-            const scope = resolveScope(flags, 'local');
-            // Resolve target settings file
+            const scope = resolveScope(flags, 'global');
+            // ── 1. Install hook script ──────────────────────────────────
+            const hookDir = expandHome('~/.respan/hooks');
+            const hookPath = `${hookDir}/gemini-cli.cjs`;
+            if (dryRun) {
+                this.log(`[dry-run] Would write hook script to: ${hookPath}`);
+            }
+            else {
+                writeTextFile(hookPath, getJsHookScript('gemini-cli'));
+                fs.chmodSync(hookPath, 0o755);
+                this.log(`Wrote hook script: ${hookPath}`);
+            }
+            // ── 2. Register hooks in settings.json ────────────────────────
             const settingsPath = scope === 'global'
                 ? expandHome('~/.gemini/settings.json')
                 : path.join(findProjectRoot(), '.gemini', 'settings.json');
             const existing = readJsonFile(settingsPath);
-            // Build resource attributes
-            const resourceAttrs = {
-                'service.name': 'gemini-cli',
-                ...attrs,
+            const hookEntry = {
+                hooks: [{ type: 'command', command: `node ${hookPath}` }],
             };
-            if (projectId) {
-                resourceAttrs['respan.project_id'] = projectId;
+            const hooksSection = (existing.hooks || {});
+            // Register the same hook script for AfterModel, BeforeTool, and AfterTool.
+            // AfterModel captures streaming text; BeforeTool/AfterTool capture tool
+            // names, arguments, and output for rich tool spans.
+            const hookEvents = ['AfterModel', 'BeforeTool', 'AfterTool'];
+            const updatedHooks = { ...hooksSection };
+            for (const eventName of hookEvents) {
+                const eventHooks = Array.isArray(hooksSection[eventName])
+                    ? [...hooksSection[eventName]]
+                    : [];
+                // Replace existing respan hook or add new one
+                const existingIdx = eventHooks.findIndex((entry) => {
+                    const inner = Array.isArray(entry.hooks)
+                        ? entry.hooks
+                        : [];
+                    return inner.some((h) => typeof h.command === 'string' &&
+                        (h.command.includes('respan') || h.command.includes('gemini_hook') || h.command.includes('gemini-cli.js')));
+                });
+                if (existingIdx >= 0) {
+                    eventHooks[existingIdx] = hookEntry;
+                }
+                else {
+                    eventHooks.push(hookEntry);
+                }
+                updatedHooks[eventName] = eventHooks;
             }
-            // settings.json — only telemetry fields Gemini CLI supports
-            const patch = {
-                telemetry: {
-                    enabled: true,
-                    otlpEndpoint: `${baseUrl}/v2/traces`,
-                    otlpProtocol: 'http',
-                },
-            };
-            const merged = deepMerge(existing, patch);
-            // .env file — OTel SDK picks up headers & resource attrs from env
-            const envDir = scope === 'global'
-                ? expandHome('~/.gemini')
-                : path.join(findProjectRoot(), '.gemini');
-            const envPath = path.join(envDir, '.env');
-            const envLines = [];
-            envLines.push(`OTEL_EXPORTER_OTLP_HEADERS=Authorization=Bearer ${apiKey}`);
-            const otelResStr = toOtelResourceAttrs(resourceAttrs);
-            if (otelResStr) {
-                envLines.push(`OTEL_RESOURCE_ATTRIBUTES=${otelResStr}`);
+            // Remove legacy telemetry config (from older CLI versions) to avoid
+            // Gemini CLI sending broken OTEL requests to the wrong endpoint.
+            // The hooks handle all trace export now.
+            const mergeSource = { hooks: updatedHooks };
+            if (existing.telemetry) {
+                mergeSource.telemetry = undefined;
+            }
+            const merged = deepMerge(existing, mergeSource);
+            // Explicitly remove telemetry key if it existed
+            delete merged.telemetry;
+            // ── 3. Write respan.json with non-secret config ─────────────
+            const configPath = expandHome('~/.gemini/respan.json');
+            const respanConfig = readJsonFile(configPath);
+            const newConfig = { ...respanConfig };
+            const baseUrl = flags['base-url'];
+            if (baseUrl && baseUrl !== DEFAULT_BASE_URL) {
+                newConfig.base_url = baseUrl;
+            }
+            if (customerId)
+                newConfig.customer_id = customerId;
+            if (spanName)
+                newConfig.span_name = spanName;
+            if (workflowName)
+                newConfig.workflow_name = workflowName;
+            if (projectId)
+                newConfig.project_id = projectId;
+            for (const [k, v] of Object.entries(attrs)) {
+                newConfig[k] = v;
             }
-            // Merge with existing .env (replace our keys, keep the rest)
-            const existingEnv = readTextFile(envPath);
-            const envKeysToSet = new Set(envLines.map(l => l.split('=')[0]));
-            const keptLines = existingEnv
-                .split('\n')
-                .filter(line => {
-                const key = line.split('=')[0];
-                return !envKeysToSet.has(key);
-            });
-            const finalEnv = [...keptLines.filter(l => l.trim() !== ''), ...envLines].join('\n') + '\n';
             if (dryRun) {
                 this.log(`[dry-run] Would update: ${settingsPath}`);
                 this.log(JSON.stringify(merged, null, 2));
-                this.log('');
-                this.log(`[dry-run] Would update: ${envPath}`);
-                this.log(finalEnv);
+                if (Object.keys(newConfig).length > 0) {
+                    this.log('');
+                    this.log(`[dry-run] Would write: ${configPath}`);
+                    this.log(JSON.stringify(newConfig, null, 2));
+                }
             }
             else {
                 writeJsonFile(settingsPath, merged);
                 this.log(`Updated settings: ${settingsPath}`);
-                writeTextFile(envPath, finalEnv);
-                this.log(`Updated env: ${envPath}`);
+                if (Object.keys(newConfig).length > 0) {
+                    writeJsonFile(configPath, newConfig);
+                    this.log(`Wrote Respan config: ${configPath}`);
+                }
             }
             this.log('');
             this.log(`Gemini CLI integration complete (${scope}).`);
             this.log('');
-            this.log('Set dynamic attributes before a session:');
-            this.log('  export OTEL_RESOURCE_ATTRIBUTES="env=prod,task_id=T-123"');
+            this.log('Auth:   ~/.respan/credentials.json  (from `respan auth login`)');
+            this.log('Config: ~/.gemini/respan.json               (shareable, non-secret)');
+            this.log('');
+            this.log('Set properties via integrate flags or edit ~/.gemini/respan.json:');
+            this.log('  respan integrate gemini-cli --customer-id "frank" --span-name "my-app"');
+            this.log('  respan integrate gemini-cli --attrs \'{"team":"platform","env":"staging"}\'');
         }
         catch (error) {
             this.handleError(error);
@@ -91,16 +134,19 @@ class IntegrateGeminiCli extends BaseCommand {
 }
 IntegrateGeminiCli.description = `Integrate Respan with Gemini CLI.
 
-Gemini CLI has native OTel traces (tool_call, llm_call, agent_call)
-so we configure it to send telemetry directly to the Respan OTLP
-endpoint.
+Installs an AfterModel hook that captures LLM request/response data
+and sends it to Respan as structured spans with model, token counts,
+and input/output.
 
 Scope:
-  --local    Write to .gemini/settings.json in project root (default)
-  --global   Write to ~/.gemini/settings.json`;
+  --global   Write to ~/.gemini/settings.json (default)
+  --local    Write to .gemini/settings.json in project root
+
+Note: Gemini CLI ignores workspace-level telemetry settings, so
+--global is the default.`;
 IntegrateGeminiCli.examples = [
     'respan integrate gemini-cli',
-    'respan integrate gemini-cli --global',
+    'respan integrate gemini-cli --local',
     'respan integrate gemini-cli --project-id my-project --attrs \'{"env":"prod"}\'',
     'respan integrate gemini-cli --dry-run',
 ];