@promptcellar/pc 0.1.0 → 0.3.0

package/README.md

@@ -14,7 +14,7 @@ npm install -g @promptcellar/pc
 # Login with your API key
 pc login
 
-# Set up auto-capture for Claude Code
+# Set up auto-capture for your AI CLI tools
 pc setup
 
 # Check status
@@ -38,12 +38,15 @@ pc setup     # Configure auto-capture for CLI tools
 pc unsetup   # Remove auto-capture hooks
 ```
 
-Currently supports:
-- Claude Code (via Stop hooks)
+Supported tools (auto-detected during setup):
+- **Claude Code** - via Stop hooks
+- **Codex CLI** - via notify hook
+- **Gemini CLI** - via AfterAgent hook
 
 Coming soon:
 - Cursor
 - Windsurf
+- Aider
 
 ### Manual Capture
 

package/bin/pc.js

@@ -13,11 +13,12 @@ import { update } from '../src/commands/update.js';
 program
   .name('pc')
   .description('PromptCellar CLI - sync prompts between your terminal and the cloud')
-  .version('0.1.0');
+  .version('0.3.0');
 
 program
   .command('login')
-  .description('Authenticate with PromptCellar')
+  .description('Authenticate with PromptCellar via browser')
+  .option('-u, --url <url>', 'API URL (for self-hosted instances)')
   .action(login);
 
 program

package/hooks/codex-capture.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+
+/**
+ * Codex CLI notify hook for capturing prompts to PromptCellar.
+ *
+ * Codex calls this script with a JSON argument containing:
+ * - type: event type (e.g., 'agent-turn-complete')
+ * - thread-id: session identifier
+ * - turn-id: turn identifier
+ * - cwd: working directory
+ * - input-messages: array of user messages
+ * - last-assistant-message: final assistant response
+ */
+
+import { capturePrompt } from '../src/lib/api.js';
+import { getFullContext } from '../src/lib/context.js';
+import { isLoggedIn } from '../src/lib/config.js';
+
+async function main() {
+  // Codex passes JSON as first argument
+  const jsonArg = process.argv[2];
+
+  if (!jsonArg) {
+    // No argument, nothing to do
+    process.exit(0);
+  }
+
+  if (!isLoggedIn()) {
+    // Silently exit if not logged in
+    process.exit(0);
+  }
+
+  try {
+    const event = JSON.parse(jsonArg);
+
+    // Only capture on agent-turn-complete
+    if (event.type !== 'agent-turn-complete') {
+      process.exit(0);
+    }
+
+    // Extract the user's input messages
+    const inputMessages = event['input-messages'] || [];
+    if (inputMessages.length === 0) {
+      process.exit(0);
+    }
+
+    // Get the first user message as the prompt
+    const userMessage = inputMessages.find(m => m.role === 'user');
+    if (!userMessage || !userMessage.content) {
+      process.exit(0);
+    }
+
+    // Extract content (handle both string and array formats)
+    let content = userMessage.content;
+    if (Array.isArray(content)) {
+      content = content
+        .filter(c => c.type === 'text')
+        .map(c => c.text)
+        .join('\n');
+    }
+
+    if (!content.trim()) {
+      process.exit(0);
+    }
+
+    // Build context
+    const context = getFullContext('codex');
+
+    // Override working directory if provided
+    if (event.cwd) {
+      context.working_directory = event.cwd;
+    }
+
+    // Add session info
+    if (event['thread-id']) {
+      context.session_id = event['thread-id'];
+    }
+
+    await capturePrompt({
+      content: content.trim(),
+      ...context
+    });
+
+  } catch (error) {
+    // Fail silently to not disrupt Codex
+    process.exit(0);
+  }
+}
+
+main();

package/hooks/gemini-capture.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+/**
+ * Gemini CLI AfterAgent hook for capturing prompts to PromptCellar.
+ *
+ * Gemini hooks receive JSON via stdin with:
+ * - event_type: the hook event (e.g., 'AfterAgent')
+ * - prompt: the user's prompt
+ * - prompt_response: the agent's response (for AfterAgent)
+ * - session_id: session identifier
+ * - working_directory: current working directory
+ *
+ * The hook must output valid JSON to stdout.
+ */
+
+import { capturePrompt } from '../src/lib/api.js';
+import { getFullContext } from '../src/lib/context.js';
+import { isLoggedIn } from '../src/lib/config.js';
+
+async function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', chunk => data += chunk);
+    process.stdin.on('end', () => resolve(data));
+
+    // Timeout after 1 second if no input
+    setTimeout(() => resolve(data), 1000);
+  });
+}
+
+function respond(success = true) {
+  // Gemini expects JSON output
+  const response = {
+    action: 'continue',
+    success
+  };
+  console.log(JSON.stringify(response));
+}
+
+async function main() {
+  try {
+    const input = await readStdin();
+
+    if (!input.trim()) {
+      respond(true);
+      process.exit(0);
+    }
+
+    if (!isLoggedIn()) {
+      respond(true);
+      process.exit(0);
+    }
+
+    const event = JSON.parse(input);
+
+    // Only capture AfterAgent events with a prompt
+    if (event.event_type !== 'AfterAgent' || !event.prompt) {
+      respond(true);
+      process.exit(0);
+    }
+
+    const content = event.prompt.trim();
+    if (!content) {
+      respond(true);
+      process.exit(0);
+    }
+
+    // Build context
+    const context = getFullContext('gemini');
+
+    // Override with event data if available
+    if (event.working_directory) {
+      context.working_directory = event.working_directory;
+    }
+    if (event.session_id) {
+      context.session_id = event.session_id;
+    }
+
+    await capturePrompt({
+      content,
+      ...context
+    });
+
+    respond(true);
+  } catch (error) {
+    // Still respond successfully to not block Gemini
+    respond(true);
+  }
+}
+
+main();

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@promptcellar/pc",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "CLI for PromptCellar - sync prompts between your terminal and the cloud",
   "type": "module",
   "main": "src/index.js",
   "bin": {
-    "pc": "bin/pc.js",
-    "pc-capture": "hooks/prompt-capture.js"
+    "pc": "./bin/pc.js",
+    "pc-capture": "./hooks/prompt-capture.js",
+    "pc-codex-capture": "./hooks/codex-capture.js",
+    "pc-gemini-capture": "./hooks/gemini-capture.js"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -38,6 +40,7 @@
     "ora": "^8.0.0",
     "inquirer": "^9.2.0",
     "socket.io-client": "^4.6.0",
-    "node-fetch": "^3.3.0"
+    "node-fetch": "^3.3.0",
+    "open": "^10.0.0"
   }
 }

package/src/commands/login.js

@@ -1,56 +1,127 @@
-import inquirer from 'inquirer';
 import ora from 'ora';
 import chalk from 'chalk';
-import { setApiKey, setApiUrl, isLoggedIn } from '../lib/config.js';
-import { testConnection } from '../lib/api.js';
+import open from 'open';
+import { setApiKey, setApiUrl, isLoggedIn, getApiUrl } from '../lib/config.js';
 
-export async function login() {
-  if (isLoggedIn()) {
-    const { overwrite } = await inquirer.prompt([{
-      type: 'confirm',
-      name: 'overwrite',
-      message: 'Already logged in. Replace existing credentials?',
-      default: false
-    }]);
-
-    if (!overwrite) {
-      console.log('Login cancelled.');
-      return;
-    }
+const DEFAULT_API_URL = 'https://prompts.weldedanvil.com';
+
+async function initiateDeviceAuth(apiUrl) {
+  const response = await fetch(`${apiUrl}/auth/device`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ device_name: getDeviceName() })
+  });
+
+  if (!response.ok) {
+    throw new Error('Failed to initiate device authentication');
   }
 
-  const answers = await inquirer.prompt([
-    {
-      type: 'input',
-      name: 'apiKey',
-      message: 'Enter your PromptCellar API key:',
-      validate: (input) => {
-        if (!input.trim()) return 'API key is required';
-        if (!input.startsWith('pk_')) return 'Invalid API key format (should start with pk_)';
-        return true;
-      }
-    },
-    {
-      type: 'input',
-      name: 'apiUrl',
-      message: 'API URL (press enter for default):',
-      default: 'https://prompts.weldedanvil.com'
+  return response.json();
+}
+
+async function pollForApproval(apiUrl, deviceCode, interval, expiresIn) {
+  const startTime = Date.now();
+  const expiresAt = startTime + (expiresIn * 1000);
+
+  while (Date.now() < expiresAt) {
+    await sleep(interval * 1000);
+
+    const response = await fetch(`${apiUrl}/auth/device/poll`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ device_code: deviceCode })
+    });
+
+    const data = await response.json();
+
+    if (response.ok && data.access_token) {
+      return data;
+    }
+
+    if (data.error === 'authorization_pending') {
+      continue;
+    }
+
+    if (data.error === 'expired_token') {
+      throw new Error('Authorization request expired. Please try again.');
     }
-  ]);
 
-  const spinner = ora('Testing connection...').start();
+    if (data.error === 'access_denied') {
+      throw new Error('Authorization denied.');
+    }
+  }
+
+  throw new Error('Authorization request timed out. Please try again.');
+}
 
-  setApiKey(answers.apiKey.trim());
-  setApiUrl(answers.apiUrl.trim());
+function getDeviceName() {
+  const os = process.platform;
+  const hostname = process.env.HOSTNAME || process.env.COMPUTERNAME || 'Unknown';
 
-  const result = await testConnection();
+  const osNames = {
+    darwin: 'macOS',
+    linux: 'Linux',
+    win32: 'Windows'
+  };
+
+  return `${osNames[os] || os} - ${hostname}`;
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+export async function login(options) {
+  const apiUrl = options?.url || DEFAULT_API_URL;
+
+  if (isLoggedIn()) {
+    console.log(chalk.yellow('Already logged in.'));
+    console.log('Run ' + chalk.cyan('pc logout') + ' first to switch accounts.\n');
+    return;
+  }
+
+  console.log(chalk.bold('\nPromptCellar CLI Login\n'));
+
+  const spinner = ora('Initiating login...').start();
+
+  try {
+    // Step 1: Request device code
+    const authData = await initiateDeviceAuth(apiUrl);
+    spinner.stop();
+
+    // Step 2: Show code and open browser
+    console.log(chalk.bold('Your verification code:\n'));
+    console.log(chalk.cyan.bold(`    ${authData.user_code}\n`));
+    console.log('Opening your browser to authorize this device...\n');
+    console.log(chalk.dim(`If the browser doesn't open, visit: ${authData.verification_url}\n`));
+
+    // Open browser with the code pre-filled
+    const verifyUrl = `${authData.verification_url}?code=${authData.user_code}`;
+    await open(verifyUrl).catch(() => {
+      // Browser failed to open, user will have to do it manually
+    });
+
+    // Step 3: Poll for approval
+    spinner.start('Waiting for authorization...');
+
+    const result = await pollForApproval(
+      apiUrl,
+      authData.device_code,
+      authData.interval,
+      authData.expires_in
+    );
+
+    // Step 4: Save credentials
+    setApiKey(result.access_token);
+    setApiUrl(apiUrl);
 
-  if (result.success) {
     spinner.succeed(chalk.green('Logged in successfully!'));
-    console.log('\nRun ' + chalk.cyan('pc setup') + ' to configure auto-capture for your CLI tools.');
-  } else {
-    spinner.fail(chalk.red('Connection failed: ' + result.error));
-    console.log('Check your API key and try again.');
+    console.log(`\nWelcome, ${chalk.cyan(result.user_email)}!`);
+    console.log('\nRun ' + chalk.cyan('pc setup') + ' to configure auto-capture for your CLI tools.\n');
+
+  } catch (error) {
+    spinner.fail(chalk.red('Login failed: ' + error.message));
+    console.log('\nPlease try again or visit ' + chalk.cyan(apiUrl) + ' to sign up.\n');
   }
 }
 

package/src/commands/setup.js

@@ -3,11 +3,42 @@ import chalk from 'chalk';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { homedir } from 'os';
+import { execFileSync } from 'child_process';
 
+// Config paths
 const CLAUDE_HOOKS_PATH = join(homedir(), '.claude', 'hooks.json');
+const CODEX_CONFIG_PATH = join(homedir(), '.codex', 'config.toml');
+const GEMINI_SETTINGS_PATH = join(homedir(), '.gemini', 'settings.json');
+
 const HOOK_SCRIPT_NAME = 'pc-capture';
 
-function getHooksConfig() {
+// Detect which tools are installed
+function detectInstalledTools() {
+  const tools = [];
+
+  // Check for Claude Code
+  try {
+    execFileSync('which', ['claude'], { stdio: 'pipe' });
+    tools.push('claude');
+  } catch { /* not installed */ }
+
+  // Check for Codex CLI
+  try {
+    execFileSync('which', ['codex'], { stdio: 'pipe' });
+    tools.push('codex');
+  } catch { /* not installed */ }
+
+  // Check for Gemini CLI
+  try {
+    execFileSync('which', ['gemini'], { stdio: 'pipe' });
+    tools.push('gemini');
+  } catch { /* not installed */ }
+
+  return tools;
+}
+
+// Claude Code hooks
+function getClaudeHooksConfig() {
   if (existsSync(CLAUDE_HOOKS_PATH)) {
     try {
       return JSON.parse(readFileSync(CLAUDE_HOOKS_PATH, 'utf8'));
@@ -18,7 +49,7 @@ function getHooksConfig() {
   return {};
 }
 
-function saveHooksConfig(config) {
+function saveClaudeHooksConfig(config) {
   const dir = dirname(CLAUDE_HOOKS_PATH);
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true });
@@ -26,20 +57,85 @@ function saveHooksConfig(config) {
   writeFileSync(CLAUDE_HOOKS_PATH, JSON.stringify(config, null, 2));
 }
 
-function isHookInstalled(config) {
+function isClaudeHookInstalled(config) {
   const stopHooks = config.Stop || [];
   return stopHooks.some(hook =>
     hook.command && hook.command.includes(HOOK_SCRIPT_NAME)
   );
 }
 
+// Codex config (TOML)
+function getCodexConfig() {
+  if (existsSync(CODEX_CONFIG_PATH)) {
+    try {
+      return readFileSync(CODEX_CONFIG_PATH, 'utf8');
+    } catch {
+      return '';
+    }
+  }
+  return '';
+}
+
+function isCodexHookInstalled(config) {
+  return config.includes('pc-codex-capture');
+}
+
+function saveCodexConfig(content) {
+  const dir = dirname(CODEX_CONFIG_PATH);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(CODEX_CONFIG_PATH, content);
+}
+
+// Gemini settings (JSON)
+function getGeminiSettings() {
+  if (existsSync(GEMINI_SETTINGS_PATH)) {
+    try {
+      return JSON.parse(readFileSync(GEMINI_SETTINGS_PATH, 'utf8'));
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+
+function isGeminiHookInstalled(settings) {
+  const hooks = settings.hooks?.AfterAgent || [];
+  return hooks.some(h =>
+    h.hooks?.some(hook => hook.command?.includes('pc-gemini-capture'))
+  );
+}
+
+function saveGeminiSettings(settings) {
+  const dir = dirname(GEMINI_SETTINGS_PATH);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(GEMINI_SETTINGS_PATH, JSON.stringify(settings, null, 2));
+}
+
 export async function setup() {
   console.log(chalk.bold('\nPromptCellar CLI Setup\n'));
 
+  const installedTools = detectInstalledTools();
+
   const tools = [
-    { name: 'Claude Code', value: 'claude', checked: true },
-    { name: 'Cursor (coming soon)', value: 'cursor', disabled: true },
-    { name: 'Windsurf (coming soon)', value: 'windsurf', disabled: true }
+    {
+      name: `Claude Code${installedTools.includes('claude') ? chalk.green(' (detected)') : ''}`,
+      value: 'claude',
+      checked: installedTools.includes('claude')
+    },
+    {
+      name: `Codex CLI${installedTools.includes('codex') ? chalk.green(' (detected)') : ''}`,
+      value: 'codex',
+      checked: installedTools.includes('codex')
+    },
+    {
+      name: `Gemini CLI${installedTools.includes('gemini') ? chalk.green(' (detected)') : ''}`,
+      value: 'gemini',
+      checked: installedTools.includes('gemini')
+    }
   ];
 
   const { selectedTools } = await inquirer.prompt([{
@@ -57,6 +153,10 @@ export async function setup() {
   for (const tool of selectedTools) {
     if (tool === 'claude') {
       await setupClaudeCode();
+    } else if (tool === 'codex') {
+      await setupCodex();
+    } else if (tool === 'gemini') {
+      await setupGemini();
     }
   }
 
@@ -67,9 +167,9 @@ export async function setup() {
 async function setupClaudeCode() {
   console.log(chalk.cyan('\nConfiguring Claude Code...'));
 
-  const config = getHooksConfig();
+  const config = getClaudeHooksConfig();
 
-  if (isHookInstalled(config)) {
+  if (isClaudeHookInstalled(config)) {
     console.log(chalk.yellow('  Hook already installed.'));
 
     const { reinstall } = await inquirer.prompt([{
@@ -99,26 +199,150 @@ async function setupClaudeCode() {
     description: 'Capture prompts to PromptCellar'
   });
 
-  saveHooksConfig(config);
+  saveClaudeHooksConfig(config);
+  console.log(chalk.green('  Hook installed successfully.'));
+}
+
+async function setupCodex() {
+  console.log(chalk.cyan('\nConfiguring Codex CLI...'));
+
+  let config = getCodexConfig();
+
+  if (isCodexHookInstalled(config)) {
+    console.log(chalk.yellow('  Hook already installed.'));
+
+    const { reinstall } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'reinstall',
+      message: 'Reinstall the hook?',
+      default: false
+    }]);
+
+    if (!reinstall) {
+      return;
+    }
+
+    // Remove existing notify line
+    config = config.split('\n')
+      .filter(line => !line.includes('pc-codex-capture'))
+      .join('\n');
+  }
+
+  // Add the notify hook
+  const notifyLine = 'notify = ["pc-codex-capture"]';
+
+  if (config.includes('notify')) {
+    // Replace existing notify
+    config = config.replace(/notify\s*=\s*\[.*\]/, notifyLine);
+  } else {
+    // Add new notify line
+    config = config.trim() + '\n\n# PromptCellar capture hook\n' + notifyLine + '\n';
+  }
+
+  saveCodexConfig(config);
+  console.log(chalk.green('  Hook installed successfully.'));
+}
+
+async function setupGemini() {
+  console.log(chalk.cyan('\nConfiguring Gemini CLI...'));
+
+  const settings = getGeminiSettings();
+
+  if (isGeminiHookInstalled(settings)) {
+    console.log(chalk.yellow('  Hook already installed.'));
+
+    const { reinstall } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'reinstall',
+      message: 'Reinstall the hook?',
+      default: false
+    }]);
+
+    if (!reinstall) {
+      return;
+    }
+
+    // Remove existing hook
+    if (settings.hooks?.AfterAgent) {
+      settings.hooks.AfterAgent = settings.hooks.AfterAgent.filter(h =>
+        !h.hooks?.some(hook => hook.command?.includes('pc-gemini-capture'))
+      );
+    }
+  }
+
+  // Ensure hooks are enabled
+  if (!settings.hooksConfig) {
+    settings.hooksConfig = {};
+  }
+  settings.hooksConfig.enabled = true;
+
+  // Add the AfterAgent hook
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  if (!settings.hooks.AfterAgent) {
+    settings.hooks.AfterAgent = [];
+  }
+
+  settings.hooks.AfterAgent.push({
+    matcher: '*',
+    hooks: [{
+      name: 'promptcellar-capture',
+      type: 'command',
+      command: 'pc-gemini-capture',
+      timeout: 5000
+    }]
+  });
+
+  saveGeminiSettings(settings);
   console.log(chalk.green('  Hook installed successfully.'));
 }
 
 export async function unsetup() {
   console.log(chalk.bold('\nRemoving PromptCellar hooks...\n'));
 
-  const config = getHooksConfig();
+  let removed = false;
 
-  if (!isHookInstalled(config)) {
-    console.log(chalk.yellow('No hooks installed.'));
-    return;
+  // Remove Claude hook
+  const claudeConfig = getClaudeHooksConfig();
+  if (isClaudeHookInstalled(claudeConfig)) {
+    claudeConfig.Stop = (claudeConfig.Stop || []).filter(hook =>
+      !hook.command || !hook.command.includes(HOOK_SCRIPT_NAME)
+    );
+    saveClaudeHooksConfig(claudeConfig);
+    console.log(chalk.green('  Removed Claude Code hook.'));
+    removed = true;
   }
 
-  config.Stop = (config.Stop || []).filter(hook =>
-    !hook.command || !hook.command.includes(HOOK_SCRIPT_NAME)
-  );
+  // Remove Codex hook
+  let codexConfig = getCodexConfig();
+  if (isCodexHookInstalled(codexConfig)) {
+    codexConfig = codexConfig.split('\n')
+      .filter(line => !line.includes('pc-codex-capture') && !line.includes('# PromptCellar'))
+      .join('\n');
+    saveCodexConfig(codexConfig);
+    console.log(chalk.green('  Removed Codex CLI hook.'));
+    removed = true;
+  }
+
+  // Remove Gemini hook
+  const geminiSettings = getGeminiSettings();
+  if (isGeminiHookInstalled(geminiSettings)) {
+    if (geminiSettings.hooks?.AfterAgent) {
+      geminiSettings.hooks.AfterAgent = geminiSettings.hooks.AfterAgent.filter(h =>
+        !h.hooks?.some(hook => hook.command?.includes('pc-gemini-capture'))
+      );
+    }
+    saveGeminiSettings(geminiSettings);
+    console.log(chalk.green('  Removed Gemini CLI hook.'));
+    removed = true;
+  }
 
-  saveHooksConfig(config);
-  console.log(chalk.green('Hooks removed successfully.'));
+  if (!removed) {
+    console.log(chalk.yellow('No hooks installed.'));
+  } else {
+    console.log(chalk.green('\nHooks removed successfully.'));
+  }
 }
 
 export default setup;