@invokehq/cli 0.1.14 → 0.2.0

package/index.js

@@ -1,13 +1,137 @@
 #!/usr/bin/env node
 const { Command } = require('commander');
+const axios = require('axios');
 const chalk = require('chalk');
 const fs = require('fs-extra');
+const os = require('os');
 const path = require('path');
+const readline = require('readline');
 const pkg = require(path.resolve(__dirname, 'package.json'));
-const os = require('os');
+
 const program = new Command();
+const DEFAULT_BASE_URL = process.env.INVOKE_BASE_URL || process.env.AGENTGATE_API_URL || 'https://api.invokehq.run';
 const CONTEXT_DIR = path.join(process.cwd(), '.agentgate');
 const CONTEXT_FILE = path.join(CONTEXT_DIR, 'context.json');
+const CONFIG_DIR = path.join(os.homedir(), '.invoke');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+async function readConfig() {
+  if (!(await fs.pathExists(CONFIG_FILE))) {
+    return {};
+  }
+  return fs.readJson(CONFIG_FILE);
+}
+
+async function writeConfig(config) {
+  await fs.ensureDir(CONFIG_DIR);
+  await fs.writeJson(CONFIG_FILE, config, { spaces: 2 });
+  await fs.chmod(CONFIG_FILE, 0o600).catch(() => {});
+}
+
+async function readContext() {
+  if (!(await fs.pathExists(CONTEXT_FILE))) {
+    return null;
+  }
+  return fs.readJson(CONTEXT_FILE);
+}
+
+async function promptSecret(query) {
+  if (!process.stdin.isTTY) {
+    return '';
+  }
+
+  return new Promise((resolve) => {
+    const mutableStdout = new (require('stream').Writable)({
+      write(chunk, encoding, callback) {
+        if (!this.muted) {
+          process.stdout.write(chunk, encoding);
+        }
+        callback();
+      }
+    });
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: mutableStdout,
+      terminal: true
+    });
+
+    mutableStdout.muted = false;
+    rl.question(chalk.cyan(query), (answer) => {
+      rl.close();
+      process.stdout.write('\n');
+      resolve(answer.trim());
+    });
+    mutableStdout.muted = true;
+  });
+}
+
+function maskKey(apiKey) {
+  if (!apiKey) {
+    return 'not set';
+  }
+  if (apiKey.length <= 10) {
+    return `${apiKey.slice(0, 4)}...`;
+  }
+  return `${apiKey.slice(0, 8)}...${apiKey.slice(-4)}`;
+}
+
+function parseJsonArg(value) {
+  if (!value) {
+    return {};
+  }
+  const source = value.startsWith('@')
+    ? fs.readFileSync(path.resolve(process.cwd(), value.slice(1)), 'utf8')
+    : value;
+  try {
+    const parsed = JSON.parse(source);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      throw new Error('JSON value must be an object');
+    }
+    return parsed;
+  } catch (error) {
+    throw new Error(`Invalid JSON: ${error.message}`);
+  }
+}
+
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+async function runtimeRequest(method, route, { data, query, allowMissingKey = false } = {}) {
+  const config = await readConfig();
+  const baseUrl = (process.env.INVOKE_BASE_URL || process.env.AGENTGATE_API_URL || config.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '');
+  const apiKey = process.env.INVOKE_API_KEY || process.env.AGENTGATE_API_KEY || process.env.TRACE_API_KEY || config.apiKey;
+
+  if (!apiKey && !allowMissingKey) {
+    throw new Error('Not logged in. Run "invoke login" first.');
+  }
+
+  try {
+    const response = await axios({
+      method,
+      url: `${baseUrl}${route}`,
+      params: query,
+      data,
+      timeout: 15000,
+      headers: {
+        'User-Agent': `invoke-cli/${pkg.version}`,
+        'Content-Type': 'application/json',
+        ...(apiKey ? { 'X-API-Key': apiKey } : {})
+      }
+    });
+    return { baseUrl, data: response.data };
+  } catch (error) {
+    if (error.response) {
+      const detail = error.response.data?.detail || error.response.data?.error || error.response.statusText;
+      throw new Error(`Invoke API ${error.response.status}: ${typeof detail === 'string' ? detail : JSON.stringify(detail)}`);
+    }
+    if (error.code === 'ECONNREFUSED') {
+      throw new Error(`Could not reach Invoke runtime at ${baseUrl}`);
+    }
+    throw error;
+  }
+}
 
 function parseGitHubPath(input) {
   // Handles https://github.com/owner/repo and git@github.com:owner/repo
@@ -17,30 +141,85 @@ function parseGitHubPath(input) {
 }
 
 program
-  .name('agentgate')
+  .name('invoke')
+  .alias('agentgate')
   .version(pkg.version);
 
 program
   .command('login')
   .description('Authenticate to your Invoke runtime')
-  .option('--api-key <key>', 'Invoke API key for non-interactive login')
-  .option('--base-url <url>', 'Invoke runtime URL', 'https://api.invokehq.run')
+  .option('--base-url <url>', 'Invoke runtime URL')
   .action(async (options) => {
-    const apiKey = options.apiKey || process.env.INVOKE_API_KEY;
+    const baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '');
+    let apiKey = process.env.INVOKE_API_KEY || process.env.AGENTGATE_API_KEY || process.env.TRACE_API_KEY;
+
+    if (!apiKey) {
+      console.log(chalk.dim(`Using Invoke runtime: ${baseUrl}`));
+      console.log(chalk.dim('Paste your Invoke API key. Input is hidden.'));
+      apiKey = await promptSecret('Invoke API key: ');
+    }
 
     if (!apiKey) {
-      console.error('Missing API key. Set INVOKE_API_KEY or run: invoke login --api-key <key>');
+      console.error(chalk.red('Error: no API key provided. Run "invoke login" or set INVOKE_API_KEY for automation.'));
       process.exit(1);
     }
 
-    await fs.ensureDir(path.join(os.homedir(), '.invoke'));
-    await fs.writeJson(path.join(os.homedir(), '.invoke', 'config.json'), {
-      baseUrl: options.baseUrl.replace(/\/+$/, ''),
+    await writeConfig({
+      baseUrl,
       apiKey,
       updatedAt: new Date().toISOString()
-    }, { spaces: 2 });
+    });
+
+    console.log(chalk.green(`✔ Logged in to Invoke (${baseUrl})`));
+  });
+
+program
+  .command('logout')
+  .description('Remove saved Invoke credentials')
+  .action(async () => {
+    await fs.remove(CONFIG_FILE);
+    console.log(chalk.green('✔ Logged out'));
+  });
 
-    console.log(`Logged in to Invoke (${options.baseUrl})`);
+program
+  .command('status')
+  .description('Show login and project context')
+  .action(async () => {
+    const config = await readConfig();
+    const context = await readContext();
+    console.log(chalk.bold('Invoke CLI status'));
+    console.log(`Version: ${pkg.version}`);
+    console.log(`Runtime: ${config.baseUrl || DEFAULT_BASE_URL}`);
+    console.log(`API key: ${maskKey(process.env.INVOKE_API_KEY || process.env.AGENTGATE_API_KEY || process.env.TRACE_API_KEY || config.apiKey)}`);
+    console.log(`Config: ${await fs.pathExists(CONFIG_FILE) ? CONFIG_FILE : 'not saved'}`);
+    console.log(`Project: ${context ? `${context.provider}:${context.repoIdentifier}` : 'not wrapped'}`);
+  });
+
+program
+  .command('config')
+  .description('Show or update CLI config')
+  .argument('[key]', 'Config key to set, currently only base-url')
+  .argument('[value]', 'Value for the config key')
+  .action(async (key, value) => {
+    const config = await readConfig();
+    if (!key) {
+      printJson({
+        baseUrl: config.baseUrl || DEFAULT_BASE_URL,
+        apiKey: maskKey(config.apiKey),
+        configFile: CONFIG_FILE
+      });
+      return;
+    }
+    if (key !== 'base-url') {
+      console.error(chalk.red('Error: only "base-url" can be set.'));
+      process.exit(1);
+    }
+    if (!value) {
+      console.error(chalk.red('Error: missing value.'));
+      process.exit(1);
+    }
+    await writeConfig({ ...config, baseUrl: value.replace(/\/+$/, ''), updatedAt: new Date().toISOString() });
+    console.log(chalk.green(`✔ base-url set to ${value.replace(/\/+$/, '')}`));
   });
 
 program
@@ -80,31 +259,163 @@ program
 
 program
   .command('upload')
-  .description('Upload context to AgentGate')
+  .description('Mark local context as active')
   .action(async () => {
     if (!await fs.pathExists(CONTEXT_FILE)) {
-      console.error(chalk.red('Error: No context found. Run "agentgate wrap github --path <url>" first.'));
+      console.error(chalk.red('Error: No context found. Run "invoke wrap github --path <url>" first.'));
       return;
     }
 
-    const apiKey = process.env.AGENTGATE_API_KEY || process.env.TRACE_API_KEY;
-    if (!apiKey) {
-      console.warn(chalk.yellow('⚠ Warning: No AGENTGATE_API_KEY found in environment. The backend may reject this context.'));
-    }
-
     try {
       const context = await fs.readJson(CONTEXT_FILE);
-      console.log(chalk.blue(`[AgentGate] Synchronizing context for ${chalk.bold(context.repoIdentifier)} with backend...`));
-      
+      console.log(chalk.blue(`[Invoke] Activating context for ${chalk.bold(context.repoIdentifier)}...`));
       context.status = 'active';
       context.lastUploaded = new Date().toISOString();
-      
       await fs.writeJson(CONTEXT_FILE, context, { spaces: 2 });
-      await new Promise(r => setTimeout(r, 500)); // Simulating network latency
-      console.log(chalk.green(`✔ Success: Repository context is now active.`));
+      console.log(chalk.green('✔ Context is active.'));
     } catch (err) {
       console.error(chalk.red('Upload failed:'), err.message);
     }
   });
 
-program.parse(process.argv);
+program
+  .command('tools')
+  .description('List available tools')
+  .argument('[query]', 'Optional discovery query')
+  .option('--limit <number>', 'Maximum tools to return', '10')
+  .option('--json', 'Print raw JSON')
+  .action(async (query, options) => {
+    try {
+      const limit = Number.parseInt(options.limit, 10);
+      const route = query ? '/discover' : '/tools';
+      const { data } = await runtimeRequest('get', route, { query: query ? { q: query, limit } : undefined });
+      if (options.json) {
+        printJson(data);
+        return;
+      }
+      const tools = data.tools || [];
+      if (!tools.length) {
+        console.log(chalk.yellow('No tools found.'));
+        return;
+      }
+      for (const tool of tools) {
+        const key = tool.key || tool.name || tool.id;
+        const summary = tool.description || tool.summary || tool.capability_card?.description || '';
+        console.log(`${chalk.cyan(key)}${summary ? ` - ${summary}` : ''}`);
+      }
+    } catch (error) {
+      console.error(chalk.red(error.message));
+      process.exit(1);
+    }
+  });
+
+program
+  .command('call')
+  .description('Call a tool through Invoke')
+  .argument('<tool>', 'Tool key, for example linear.create_issue')
+  .argument('[params]', 'JSON params object, or @file.json', '{}')
+  .option('--agent-id <id>', 'Agent identifier', 'cli')
+  .option('--idempotency-key <key>', 'Idempotency key for safe retries')
+  .option('--json', 'Print raw JSON')
+  .action(async (tool, paramsArg, options) => {
+    try {
+      const params = parseJsonArg(paramsArg);
+      const context = await readContext();
+      const body = {
+        tool,
+        params,
+        agent_id: options.agentId,
+        context: {
+          source: 'invoke-cli',
+          ...(context ? { project: context } : {})
+        }
+      };
+      if (options.idempotencyKey) {
+        body.idempotency_key = options.idempotencyKey;
+      }
+      const { data } = await runtimeRequest('post', '/call', { data: body });
+      if (options.json) {
+        printJson(data);
+        return;
+      }
+      console.log(chalk.green(`Status: ${data.status || (data.success ? 'success' : 'unknown')}`));
+      if (data.approval_id) {
+        console.log(chalk.yellow(`Approval required: ${data.approval_id}`));
+      }
+      if (data.latency_ms !== undefined) {
+        console.log(`Latency: ${data.latency_ms}ms`);
+      }
+      printJson(data.result || data);
+    } catch (error) {
+      console.error(chalk.red(error.message));
+      process.exit(1);
+    }
+  });
+
+async function listApprovals(options = {}) {
+  const { data } = await runtimeRequest('get', '/approvals');
+  if (options.json) {
+    printJson(data);
+    return;
+  }
+  const limit = Number.parseInt(options.limit || '20', 10);
+  const items = (data.approvals || []).slice(0, limit);
+  if (!items.length) {
+    console.log(chalk.green('No pending approvals.'));
+    return;
+  }
+  for (const item of items) {
+    console.log(`${chalk.cyan(item.id)} ${item.status || ''} ${item.tool || item.tool_key || ''} ${item.reason || ''}`);
+  }
+}
+
+const approvals = program
+  .command('approvals')
+  .description('List and manage pending approvals')
+  .option('--limit <number>', 'Maximum approvals to show', '20')
+  .option('--json', 'Print raw JSON')
+  .action(async (options) => {
+    try {
+      await listApprovals(options);
+    } catch (error) {
+      console.error(chalk.red(error.message));
+      process.exit(1);
+    }
+  });
+
+approvals
+  .command('list')
+  .description('List approvals')
+  .option('--limit <number>', 'Maximum approvals to show', '20')
+  .option('--json', 'Print raw JSON')
+  .action(async (options) => {
+    try {
+      await listApprovals(options);
+    } catch (error) {
+      console.error(chalk.red(error.message));
+      process.exit(1);
+    }
+  });
+
+for (const action of ['approve', 'reject']) {
+  approvals
+    .command(`${action} <id>`)
+    .description(`${action[0].toUpperCase()}${action.slice(1)} an approval`)
+    .option('--json', 'Print raw JSON')
+    .action(async (id, options) => {
+      try {
+        const { data } = await runtimeRequest('post', `/approvals/${id}/${action}`, { data: {} });
+        if (options.json) {
+          printJson(data);
+          return;
+        }
+        console.log(chalk.green(`✔ ${action}d ${id}`));
+        printJson(data);
+      } catch (error) {
+        console.error(chalk.red(error.message));
+        process.exit(1);
+      }
+    });
+}
+
+program.parse(process.argv);

package/package.json

@@ -1,35 +1,35 @@
-{
-  "name": "@invokehq/cli",
-  "version": "0.1.14",
-  "description": "Invoke CLI",
-  "main": "trace.js",
-  "bin": {
-    "invoke": "index.js",
-    "agentgate": "index.js"
-  },
-  "scripts": {
-    "build": "echo 'no build step'"
-  },
-  "files": [
-    "index.js",
-    "trace.js"
-  ],
-  "dependencies": {
-    "axios": "^1.6.0",
-    "axios-retry": "^4.5.0",
-    "chalk": "^4.1.2",
-    "commander": "^11.0.0",
-    "dotenv": "^16.4.5",
-    "fs-extra": "^11.1.1"
-  },
-  "engines": {
-    "node": ">=16.0.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/joel4893/agentgate-cli.git"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}
+{
+  "name": "@invokehq/cli",
+  "version": "0.2.0",
+  "description": "Invoke CLI",
+  "main": "trace.js",
+  "bin": {
+    "invoke": "index.js",
+    "agentgate": "index.js"
+  },
+  "scripts": {
+    "build": "echo 'no build step'"
+  },
+  "files": [
+    "index.js",
+    "trace.js"
+  ],
+  "dependencies": {
+    "axios": "^1.6.0",
+    "axios-retry": "^4.5.0",
+    "chalk": "^4.1.2",
+    "commander": "^11.0.0",
+    "dotenv": "^16.4.5",
+    "fs-extra": "^11.1.1"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/joel4893/agentgate-cli.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/trace.js

@@ -1,12 +1,15 @@
 const fs = require('fs-extra');
 const path = require('path');
 const axios = require('axios');
+const os = require('os');
 
 // Load .env from the project root where the CLI is being executed
 require('dotenv').config({ path: path.resolve(process.cwd(), '.env') });
 
 // Load package info once at startup
 const pkg = require(path.resolve(__dirname, 'package.json'));
+const CONFIG_FILE = path.join(os.homedir(), '.invoke', 'config.json');
+const DEFAULT_BASE_URL = process.env.INVOKE_BASE_URL || process.env.AGENTGATE_API_URL || "https://api.invokehq.run";
 
 const trace = {
     call: async (action, params) => {
@@ -18,19 +21,28 @@ const trace = {
         }
         const context = await fs.readJson(contextPath);
 
-        // The SDK now points to the Agentgate Backend Service
-        const AGENTGATE_SERVER = process.env.AGENTGATE_API_URL || "http://localhost:8000/call";
+        // Attempt to load stored config from 'invoke login'
+        let storedConfig = {};
+        if (fs.existsSync(CONFIG_FILE)) {
+            storedConfig = fs.readJsonSync(CONFIG_FILE);
+        }
+
+        const baseUrl = process.env.INVOKE_BASE_URL || process.env.AGENTGATE_API_URL || storedConfig.baseUrl || DEFAULT_BASE_URL;
+        const endpoint = baseUrl.endsWith('/call') ? baseUrl : `${baseUrl.replace(/\/+$/, '')}/call`;
+        
+        const apiKey = process.env.INVOKE_API_KEY || process.env.AGENTGATE_API_KEY || process.env.TRACE_API_KEY || storedConfig.apiKey;
 
         try {
-            const response = await axios.post(AGENTGATE_SERVER, {
+            const response = await axios.post(endpoint, {
                 action,
                 repository: context.repoIdentifier,
                 parameters: params
             }, {
                 timeout: 10000, // 10 second timeout
                 headers: {
-                    'User-Agent': `agentgate-cli-sdk/${pkg.version}`,
-                    'Content-Type': 'application/json'
+                    'User-Agent': `invoke-cli-sdk/${pkg.version}`,
+                    'Content-Type': 'application/json',
+                    ...(apiKey ? { 'X-API-Key': apiKey } : {})
                 }
             });
 
@@ -47,4 +59,4 @@ const trace = {
     }
 };
 
-module.exports = { trace };
+module.exports = { trace };