@genspark/cli 1.0.3 → 1.0.5

package/dist/index.js

@@ -18,32 +18,34 @@
  *   Tool name: "web_search" -> Command: `gsk web_search`, Alias: `gsk search`
  *   Tool name: "crawler"    -> Command: `gsk crawler`, Alias: `gsk crawl`
  */
-import { Command } from "commander";
-import * as fs from "fs";
-import * as pathModule from "path";
-import { spawn } from "child_process";
-import { ApiClient, unauthenticatedRequest } from "./client.js";
-import { setDebugEnabled, setOutputFormat, debug, info, error as logError, output, } from "./logger.js";
-import { loadConfigFile, saveConfigFile, getConfigPath, loadToolsCache, saveToolsCache, } from "./config.js";
-import { checkForUpdates } from "./updater.js";
-const VERSION = "1.1.0";
-const DEFAULT_BASE_URL = "https://www.genspark.ai";
+import { Command } from 'commander';
+import * as fs from 'fs';
+import * as http from 'http';
+import * as https from 'https';
+import * as pathModule from 'path';
+import { spawn } from 'child_process';
+import { ApiClient, unauthenticatedRequest } from './client.js';
+import { setDebugEnabled, setOutputFormat, debug, info, error as logError, output, } from './logger.js';
+import { loadConfigFile, saveConfigFile, getConfigPath, loadToolsCache, saveToolsCache, } from './config.js';
+import { checkForUpdates } from './updater.js';
+const VERSION = '1.1.0';
+const DEFAULT_BASE_URL = 'https://www.genspark.ai';
 const DEFAULT_TIMEOUT = 300000; // 5 minutes (video generation can be slow)
 // Load config file (lowest priority)
 const fileConfig = loadConfigFile();
 // Create main program
 const program = new Command();
 program
-    .name("gsk")
-    .description("Genspark Tool CLI - Search, crawl, analyze, and generate media")
+    .name('gsk')
+    .description('Genspark Tool CLI - Search, crawl, analyze, and generate media')
     .version(VERSION)
-    .option("--api-key <key>", "API key (or set GSK_API_KEY env var)")
-    .option("--base-url <url>", `Base URL for API (default: ${DEFAULT_BASE_URL})`, DEFAULT_BASE_URL)
-    .option("--project-id <id>", "Project ID for access control (or set GSK_PROJECT_ID env var)")
-    .option("--debug", "Enable debug output and request more details from server", false)
-    .option("--timeout <ms>", "Request timeout in milliseconds", String(DEFAULT_TIMEOUT))
-    .option("--output <format>", "Output format: json or text", "json")
-    .option("--refresh", "Force refresh of cached tool schemas from server");
+    .option('--api-key <key>', 'API key (or set GSK_API_KEY env var)')
+    .option('--base-url <url>', `Base URL for API (default: ${DEFAULT_BASE_URL})`, DEFAULT_BASE_URL)
+    .option('--project-id <id>', 'Project ID for access control (or set GSK_PROJECT_ID env var)')
+    .option('--debug', 'Enable debug output and request more details from server', false)
+    .option('--timeout <ms>', 'Request timeout in milliseconds', String(DEFAULT_TIMEOUT))
+    .option('--output <format>', 'Output format: json or text', 'json')
+    .option('--refresh', 'Force refresh of cached tool schemas from server');
 /**
  * Get global options with priority:
  * 1. Command-line options (highest)
@@ -81,75 +83,193 @@ function createClient() {
     setDebugEnabled(options.debug);
     setOutputFormat(options.output);
     if (!options.apiKey) {
-        logError("API key is required. Provide it via:");
-        logError("  1. --api-key option");
-        logError("  2. GSK_API_KEY environment variable");
+        logError('API key is required. Provide it via:');
+        logError('  1. --api-key option');
+        logError('  2. GSK_API_KEY environment variable');
         logError(`  3. Config file: ${getConfigPath()}`);
         process.exit(1);
     }
     debug(`Base URL: ${options.baseUrl}`);
     debug(`Timeout: ${options.timeout}ms`);
     debug(`Debug mode: ${options.debug}`);
-    debug(`Project ID: ${options.projectId || "(not set)"}`);
+    debug(`Project ID: ${options.projectId || '(not set)'}`);
     return new ApiClient(options);
 }
 // ============================================
 // Shared helpers for local file handling
 // ============================================
 const CONTENT_TYPE_MAP = {
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".png": "image/png",
-    ".gif": "image/gif",
-    ".webp": "image/webp",
-    ".pdf": "application/pdf",
-    ".txt": "text/plain",
-    ".json": "application/json",
-    ".html": "text/html",
-    ".css": "text/css",
-    ".js": "application/javascript",
-    ".ts": "application/typescript",
-    ".md": "text/markdown",
-    ".xml": "application/xml",
-    ".csv": "text/csv",
-    ".zip": "application/zip",
-    ".mp3": "audio/mpeg",
-    ".mp4": "video/mp4",
-    ".wav": "audio/wav",
-    ".webm": "video/webm",
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.pdf': 'application/pdf',
+    '.txt': 'text/plain',
+    '.json': 'application/json',
+    '.html': 'text/html',
+    '.css': 'text/css',
+    '.js': 'application/javascript',
+    '.ts': 'application/typescript',
+    '.md': 'text/markdown',
+    '.xml': 'application/xml',
+    '.csv': 'text/csv',
+    '.zip': 'application/zip',
+    '.mp3': 'audio/mpeg',
+    '.mp4': 'video/mp4',
+    '.wav': 'audio/wav',
+    '.webm': 'video/webm',
 };
+/**
+ * Stream a local file to a URL using Node.js http/https.request +
+ * fs.createReadStream so the file is never fully buffered in memory.
+ * Suitable for files of any size.
+ *
+ * Reports upload progress to stderr for files larger than PROGRESS_THRESHOLD.
+ * Returns the response body as a string (empty for typical blob-storage PUTs).
+ */
+async function streamFileUpload(filePath, uploadUrl, headers, fileSize, method = 'PUT') {
+    const PROGRESS_THRESHOLD = 5 * 1024 * 1024; // 5 MB
+    const showProgress = fileSize > PROGRESS_THRESHOLD;
+    return new Promise((resolve, reject) => {
+        const parsedUrl = new URL(uploadUrl);
+        const isHttps = parsedUrl.protocol === 'https:';
+        const transport = isHttps ? https : http;
+        // Declare before transport.request so closures below don't reference it
+        // in the temporal dead zone.
+        let progressTimer = null;
+        const req = transport.request({
+            hostname: parsedUrl.hostname,
+            port: parsedUrl.port
+                ? parseInt(parsedUrl.port, 10)
+                : isHttps
+                    ? 443
+                    : 80,
+            path: parsedUrl.pathname + parsedUrl.search,
+            method,
+            headers: { ...headers, 'Content-Length': String(fileSize) },
+        }, res => {
+            // Always collect the full response body before resolving/rejecting
+            let body = '';
+            res.on('data', (chunk) => {
+                body += chunk.toString();
+            });
+            res.on('end', () => {
+                if (progressTimer)
+                    clearInterval(progressTimer);
+                if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                    resolve(body);
+                }
+                else {
+                    // Stop the file stream and close the request on non-2xx so we
+                    // don't keep piping data into a request the server has rejected.
+                    fileStream.destroy();
+                    req.destroy();
+                    reject(new Error(`Upload failed: HTTP ${res.statusCode}${body ? ': ' + body.substring(0, 200) : ''}`));
+                }
+            });
+            res.on('error', (err) => {
+                if (progressTimer)
+                    clearInterval(progressTimer);
+                reject(err);
+            });
+        });
+        const fileStream = fs.createReadStream(filePath);
+        req.on('error', (err) => {
+            if (progressTimer)
+                clearInterval(progressTimer);
+            fileStream.destroy(); // prevent the readable from continuing to push data
+            reject(err);
+        });
+        let uploadedBytes = 0;
+        if (showProgress) {
+            const totalMB = (fileSize / (1024 * 1024)).toFixed(1);
+            progressTimer = setInterval(() => {
+                const pct = Math.floor((uploadedBytes / fileSize) * 100);
+                const doneMB = (uploadedBytes / (1024 * 1024)).toFixed(1);
+                process.stderr.write(`\r[INFO] Uploading... ${pct}%  ${doneMB} / ${totalMB} MB  `);
+            }, 1000);
+        }
+        fileStream.on('data', (chunk) => {
+            uploadedBytes +=
+                typeof chunk === 'string' ? Buffer.byteLength(chunk) : chunk.length;
+        });
+        fileStream.on('end', () => {
+            if (progressTimer) {
+                clearInterval(progressTimer);
+                process.stderr.write('\r\x1b[K'); // clear the progress line
+            }
+        });
+        fileStream.on('error', (err) => {
+            if (progressTimer)
+                clearInterval(progressTimer);
+            req.destroy(); // close the HTTP request so the TCP connection is not leaked
+            reject(err);
+        });
+        fileStream.pipe(req);
+    });
+}
+function formatFileSize(bytes) {
+    if (bytes >= 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / 1024).toFixed(1)} KB`;
+}
 async function uploadLocalFile(filePath, client) {
     const fileName = pathModule.basename(filePath);
     const ext = pathModule.extname(filePath).toLowerCase();
-    const contentType = CONTENT_TYPE_MAP[ext] || "application/octet-stream";
-    const stats = fs.statSync(filePath);
-    info(`Uploading ${fileName} (${(stats.size / 1024).toFixed(1)} KB, ${contentType})...`);
+    const contentType = CONTENT_TYPE_MAP[ext] || 'application/octet-stream';
+    const fileSize = fs.statSync(filePath).size;
+    info(`Uploading ${fileName} (${formatFileSize(fileSize)}, ${contentType})...`);
     const globalOpts = getGlobalOptions();
     const uploadUrlResult = await client.getUploadUrl({
         content_type: contentType,
         name: fileName,
         project_id: globalOpts.projectId,
     });
-    if (uploadUrlResult.status !== "ok" || !uploadUrlResult.data) {
+    if (uploadUrlResult.status !== 'ok' || !uploadUrlResult.data) {
         throw new Error(`Failed to get upload URL: ${uploadUrlResult.message}`);
     }
     const { upload_url, file_wrapper_url } = uploadUrlResult.data;
     debug(`Upload URL: ${upload_url.substring(0, 80)}...`);
-    const fileBuffer = fs.readFileSync(filePath);
-    const uploadResponse = await fetch(upload_url, {
-        method: "PUT",
-        headers: { "Content-Type": contentType, "x-ms-blob-type": "BlockBlob" },
-        body: fileBuffer,
-    });
-    if (!uploadResponse.ok)
-        throw new Error(`Upload failed: HTTP ${uploadResponse.status}`);
+    // Stream the file directly to Azure Blob Storage — no full-file buffering
+    await streamFileUpload(filePath, upload_url, { 'Content-Type': contentType, 'x-ms-blob-type': 'BlockBlob' }, fileSize);
     info(`Uploaded → ${file_wrapper_url}`);
     return file_wrapper_url;
 }
+/**
+ * Upload a local file directly to AI Drive using the dedicated tool_cli
+ * endpoint (POST /api/tool_cli/aidrive/upload). The file is streamed without
+ * buffering the whole content in memory, so large files (100 MB+) work fine.
+ *
+ * This avoids the roundabout blob-upload + download_file two-step approach.
+ */
+async function uploadToAiDrive(filePath, uploadPath, override = false) {
+    const fileName = pathModule.basename(filePath);
+    const ext = pathModule.extname(filePath).toLowerCase();
+    const contentType = CONTENT_TYPE_MAP[ext] || 'application/octet-stream';
+    const fileSize = fs.statSync(filePath).size;
+    info(`Uploading ${fileName} (${formatFileSize(fileSize)}, ${contentType}) directly to AI Drive...`);
+    const globalOpts = getGlobalOptions();
+    const baseUrl = globalOpts.baseUrl.replace(/\/$/, '');
+    const uploadUrl = `${baseUrl}/api/tool_cli/aidrive/upload?upload_path=${encodeURIComponent(uploadPath)}${override ? '&override=true' : ''}`;
+    const headers = { 'Content-Type': contentType };
+    if (globalOpts.apiKey)
+        headers['X-Api-Key'] = globalOpts.apiKey;
+    if (globalOpts.projectId)
+        headers['X-Project-ID'] = globalOpts.projectId;
+    debug(`AI Drive upload URL: ${uploadUrl}`);
+    const responseBody = await streamFileUpload(filePath, uploadUrl, headers, fileSize, 'POST');
+    try {
+        return JSON.parse(responseBody);
+    }
+    catch {
+        throw new Error(`Unexpected response from AI Drive upload: ${responseBody.substring(0, 200)}`);
+    }
+}
 async function downloadToFile(wrapperUrl, savePath, client) {
     info(`Downloading to ${savePath}...`);
     const result = await client.getDownloadUrl({ file_wrapper_url: wrapperUrl });
-    if (result.status !== "ok" || !result.data)
+    if (result.status !== 'ok' || !result.data)
         throw new Error(`Failed to get download URL: ${result.message}`);
     const resp = await fetch(result.data.download_url);
     if (!resp.ok)
@@ -160,9 +280,9 @@ async function downloadToFile(wrapperUrl, savePath, client) {
     return pathModule.resolve(savePath);
 }
 function isLocalFilePath(value) {
-    return (!value.startsWith("http://") &&
-        !value.startsWith("https://") &&
-        !value.startsWith("/api/") &&
+    return (!value.startsWith('http://') &&
+        !value.startsWith('https://') &&
+        !value.startsWith('/api/') &&
         fs.existsSync(value));
 }
 async function resolveFileArg(value, client) {
@@ -179,10 +299,10 @@ async function resolveLocalFiles(args, client) {
     const resolved = { ...args };
     for (const [key, value] of Object.entries(resolved)) {
         // Handle array of URLs (e.g., image_urls)
-        if (key.endsWith("_urls") && Array.isArray(value)) {
+        if (key.endsWith('_urls') && Array.isArray(value)) {
             const resolvedUrls = [];
             for (const item of value) {
-                if (typeof item === "string") {
+                if (typeof item === 'string') {
                     resolvedUrls.push(await resolveFileArg(item, client));
                 }
                 else {
@@ -192,8 +312,8 @@ async function resolveLocalFiles(args, client) {
             resolved[key] = resolvedUrls;
         }
         // Handle single URL (e.g., url, audio_url)
-        else if ((key === "url" || key.endsWith("_url")) &&
-            typeof value === "string") {
+        else if ((key === 'url' || key.endsWith('_url')) &&
+            typeof value === 'string') {
             resolved[key] = await resolveFileArg(value, client);
         }
     }
@@ -201,6 +321,9 @@ async function resolveLocalFiles(args, client) {
 }
 // ============================================
 // Dynamic tool command registration
+// Map of group name -> parent Command for hierarchical subcommands
+// (e.g., "email" -> Command for `gsk email [subcommand]`)
+const _groupCommands = new Map();
 // ============================================
 /**
  * Extract a file URL from nested result data using dot-separated path keys.
@@ -209,14 +332,14 @@ async function resolveLocalFiles(args, client) {
 function extractFileUrl(data, keys) {
     for (const key of keys) {
         let current = data;
-        for (const part of key.split(".")) {
-            if (current == null || typeof current !== "object") {
+        for (const part of key.split('.')) {
+            if (current == null || typeof current !== 'object') {
                 current = undefined;
                 break;
             }
             current = current[part];
         }
-        if (typeof current === "string" && current.length > 0)
+        if (typeof current === 'string' && current.length > 0)
             return current;
     }
     return null;
@@ -225,7 +348,27 @@ function extractFileUrl(data, keys) {
  * Register a dynamic tool command from a server-provided schema
  */
 function registerToolCommand(parentProgram, tool, clientFactory) {
-    const cmd = parentProgram.command(tool.name).description(tool.description);
+    // If the tool has a group, register as a subcommand under the group parent
+    // e.g., tool.name="email_list" with cli.group="email" creates `gsk email list`
+    let targetProgram = parentProgram;
+    let cmdName = tool.name;
+    if (tool.cli.group) {
+        const groupName = tool.cli.group;
+        if (!_groupCommands.has(groupName)) {
+            const groupCmd = parentProgram
+                .command(groupName)
+                .description(`Commands for ${groupName}`);
+            _groupCommands.set(groupName, groupCmd);
+        }
+        targetProgram = _groupCommands.get(groupName);
+        // Derive subcommand name: strip group prefix from tool name
+        // e.g., "email_list" with group "email" -> "list"
+        const prefix = groupName + '_';
+        cmdName = tool.name.startsWith(prefix)
+            ? tool.name.slice(prefix.length)
+            : tool.name;
+    }
+    const cmd = targetProgram.command(cmdName).description(tool.description);
     // Register aliases
     for (const alias of tool.cli.aliases) {
         cmd.alias(alias);
@@ -236,7 +379,7 @@ function registerToolCommand(parentProgram, tool, clientFactory) {
     if (tool.cli.primary_arg && props[tool.cli.primary_arg]) {
         const param = props[tool.cli.primary_arg];
         const isRequired = required.includes(tool.cli.primary_arg);
-        const bracket = isRequired ? "<value>" : "[value]";
+        const bracket = isRequired ? '<value>' : '[value]';
         cmd.argument(bracket, param.description || tool.cli.primary_arg);
     }
     // Add remaining params as --options
@@ -247,8 +390,8 @@ function registerToolCommand(parentProgram, tool, clientFactory) {
         const isRequired = required.includes(name);
         const paramType = Array.isArray(param.type) ? param.type[0] : param.type;
         const shortAlias = aliases[name];
-        const shortPrefix = shortAlias ? `-${shortAlias}, ` : "";
-        if (paramType === "array") {
+        const shortPrefix = shortAlias ? `-${shortAlias}, ` : '';
+        if (paramType === 'array') {
             const flag = `${shortPrefix}--${name} <values...>`;
             if (isRequired) {
                 cmd.requiredOption(flag, param.description || name);
@@ -257,7 +400,7 @@ function registerToolCommand(parentProgram, tool, clientFactory) {
                 cmd.option(flag, param.description || name);
             }
         }
-        else if (paramType === "boolean") {
+        else if (paramType === 'boolean') {
             cmd.option(`${shortPrefix}--${name}`, param.description || name);
         }
         else {
@@ -273,13 +416,18 @@ function registerToolCommand(parentProgram, tool, clientFactory) {
     // Add -o/--output-file option for tools that produce downloadable files
     const outputFileKeys = tool.cli.output_file_keys || [];
     if (outputFileKeys.length > 0) {
-        cmd.option("-o, --output-file <path>", "Download the generated file to a local path");
+        cmd.option('-o, --output-file <path>', 'Download the generated file to a local path');
+    }
+    // For the aidrive tool, add client-side options used with --local_file upload
+    if (tool.name === 'aidrive') {
+        cmd.option('--local_file <path>', 'Local file path to upload to AI Drive (supports files >5 MB; alternative to --file_content)');
+        cmd.option('--override', 'Overwrite an existing file at the destination path (used with --local_file)', false);
     }
     // Generic action handler
     cmd.action(async (primaryArgValue, opts) => {
         // Commander passes opts as second arg when there's an argument,
         // or as first arg when there's no argument
-        if (typeof primaryArgValue === "object" && primaryArgValue !== null) {
+        if (typeof primaryArgValue === 'object' && primaryArgValue !== null) {
             opts = primaryArgValue;
             primaryArgValue = undefined;
         }
@@ -299,30 +447,62 @@ function registerToolCommand(parentProgram, tool, clientFactory) {
                     const paramType = Array.isArray(param.type)
                         ? param.type[0]
                         : param.type;
-                    if (paramType === "integer" || paramType === "number") {
+                    if (paramType === 'integer' || paramType === 'number') {
                         const num = Number(args[name]);
                         if (!isNaN(num)) {
-                            args[name] = paramType === "integer" ? Math.floor(num) : num;
+                            args[name] = paramType === 'integer' ? Math.floor(num) : num;
                         }
                     }
                 }
             }
+            // aidrive: strip client-side-only options before sending to API.
+            // --local_file and --override are only meaningful to the CLI and must
+            // never be forwarded to the server (other aidrive actions like ls,
+            // mkdir, move don't know about them).
+            if (tool.name === 'aidrive') {
+                delete args.local_file;
+                delete args.override;
+            }
+            // aidrive: handle --local_file for the upload action.
+            // Stream the file directly to AI Drive via the dedicated tool_cli
+            // endpoint (POST /api/tool_cli/aidrive/upload) — no blob middleman.
+            if (tool.name === 'aidrive' &&
+                primaryArgValue === 'upload' &&
+                opts.local_file) {
+                const localFilePath = opts.local_file;
+                const override = !!opts.override;
+                if (!fs.existsSync(localFilePath)) {
+                    logError(`File not found: ${localFilePath}`);
+                    process.exit(1);
+                }
+                // args.upload_path is safe here: args = { ...opts } at line above, and
+                // only local_file/override were deleted from args — upload_path is intact.
+                const rawUploadPath = args.upload_path ||
+                    `/${pathModule.basename(localFilePath)}`;
+                const uploadPath = rawUploadPath.startsWith('/')
+                    ? rawUploadPath
+                    : `/${rawUploadPath}`;
+                // Stream directly to AI Drive — single request, no blob middleman
+                const result = await uploadToAiDrive(localFilePath, uploadPath, override);
+                output(result);
+                return;
+            }
             // Resolve local file paths to uploaded URLs
             const resolvedArgs = await resolveLocalFiles(args, client);
             const result = await client.executeTool(tool.name, resolvedArgs);
             // If -o was specified and tool succeeded, download the output file
             if (outputFilePath &&
                 outputFileKeys.length > 0 &&
-                result.status === "ok" &&
+                result.status === 'ok' &&
                 result.data &&
-                typeof result.data === "object") {
+                typeof result.data === 'object') {
                 const fileUrl = extractFileUrl(result.data, outputFileKeys);
                 if (fileUrl) {
                     const localPath = await downloadToFile(fileUrl, outputFilePath, client);
                     result.data.local_path = localPath;
                 }
                 else {
-                    info("Warning: Could not find a file URL in the result to download");
+                    info('Warning: Could not find a file URL in the result to download');
                 }
             }
             output(result);
@@ -338,9 +518,9 @@ function registerToolCommand(parentProgram, tool, clientFactory) {
 // ============================================
 // List tools
 program
-    .command("list-tools")
-    .alias("ls")
-    .description("List all available tools")
+    .command('list-tools')
+    .alias('ls')
+    .description('List all available tools')
     .action(async () => {
     try {
         const client = createClient();
@@ -354,9 +534,9 @@ program
 });
 // Upload file - get upload URL, upload file, return file wrapper URL
 program
-    .command("upload")
-    .description("Upload a local file and get a file wrapper URL")
-    .argument("<file>", "Local file path to upload")
+    .command('upload')
+    .description('Upload a local file and get a file wrapper URL')
+    .argument('<file>', 'Local file path to upload')
     .action(async (filePath) => {
     try {
         if (!fs.existsSync(filePath)) {
@@ -367,11 +547,11 @@ program
         const file_wrapper_url = await uploadLocalFile(filePath, client);
         const fileName = pathModule.basename(filePath);
         const ext = pathModule.extname(filePath).toLowerCase();
-        const contentType = CONTENT_TYPE_MAP[ext] || "application/octet-stream";
+        const contentType = CONTENT_TYPE_MAP[ext] || 'application/octet-stream';
         const stats = fs.statSync(filePath);
         output({
-            status: "ok",
-            message: "File uploaded successfully",
+            status: 'ok',
+            message: 'File uploaded successfully',
             data: {
                 file_wrapper_url,
                 file_name: fileName,
@@ -387,17 +567,17 @@ program
 });
 // Download file - get download URL from file wrapper URL
 program
-    .command("download")
-    .description("Get a download URL for a file wrapper URL")
-    .argument("<file_wrapper_url>", "File wrapper URL (e.g., /api/files/s/xxxxx)")
-    .option("-s, --save <path>", "Download and save to local file path")
+    .command('download')
+    .description('Get a download URL for a file wrapper URL')
+    .argument('<file_wrapper_url>', 'File wrapper URL (e.g., /api/files/s/xxxxx)')
+    .option('-s, --save <path>', 'Download and save to local file path')
     .action(async (fileWrapperUrl, opts) => {
     try {
         const client = createClient();
         const result = await client.getDownloadUrl({
             file_wrapper_url: fileWrapperUrl,
         });
-        if (result.status !== "ok" || !result.data) {
+        if (result.status !== 'ok' || !result.data) {
             logError(`Failed to get download URL: ${result.message}`);
             process.exit(1);
         }
@@ -412,8 +592,8 @@ program
             const localPath = pathModule.resolve(opts.save);
             info(`Downloaded ${(buffer.length / 1024).toFixed(1)} KB → ${localPath}`);
             output({
-                status: "ok",
-                message: "File downloaded successfully",
+                status: 'ok',
+                message: 'File downloaded successfully',
                 data: {
                     ...result.data,
                     local_path: localPath,
@@ -433,8 +613,8 @@ program
 });
 // Login - browser-based device flow authentication
 program
-    .command("login")
-    .description("Log in to Genspark via browser to obtain an API key")
+    .command('login')
+    .description('Log in to Genspark via browser to obtain an API key')
     .action(async () => {
     const globalOpts = getGlobalOptions();
     setDebugEnabled(globalOpts.debug);
@@ -442,78 +622,78 @@ program
     const baseUrl = globalOpts.baseUrl;
     try {
         // Step 1: Request device code
-        info("Requesting device code...");
-        const deviceResp = await unauthenticatedRequest(baseUrl, "/api/cli_auth/device_code", "POST");
+        info('Requesting device code...');
+        const deviceResp = await unauthenticatedRequest(baseUrl, '/api/cli_auth/device_code', 'POST');
         const { device_code, auth_url, poll_interval, expires_in } = deviceResp;
         // Step 2: Open browser (use spawn to avoid shell command injection)
-        info("Opening browser for login...");
+        info('Opening browser for login...');
         info(`Login URL: ${auth_url}`);
         // Validate auth_url is a same-origin HTTP(S) URL before passing to spawn
         try {
             const parsed = new URL(auth_url);
             const base = new URL(baseUrl);
-            if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-                throw new Error("auth_url is not http(s)");
+            if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+                throw new Error('auth_url is not http(s)');
             }
             if (parsed.host !== base.host) {
-                throw new Error("auth_url host does not match baseUrl host");
+                throw new Error('auth_url host does not match baseUrl host');
             }
             let cmd;
             let args;
-            if (process.platform === "win32") {
+            if (process.platform === 'win32') {
                 // Avoid cmd.exe which interprets & in URLs as command separators
-                cmd = "rundll32";
-                args = ["url.dll,FileProtocolHandler", auth_url];
+                cmd = 'rundll32';
+                args = ['url.dll,FileProtocolHandler', auth_url];
             }
-            else if (process.platform === "darwin") {
-                cmd = "open";
+            else if (process.platform === 'darwin') {
+                cmd = 'open';
                 args = [auth_url];
             }
             else {
-                cmd = "xdg-open";
+                cmd = 'xdg-open';
                 args = [auth_url];
             }
-            const child = spawn(cmd, args, { stdio: "ignore", detached: true });
-            child.on("error", () => {
-                info("Could not open browser automatically.");
-                info("Please open the URL above manually.");
+            const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
+            child.on('error', () => {
+                info('Could not open browser automatically.');
+                info('Please open the URL above manually.');
             });
             child.unref();
         }
         catch {
-            info("Could not open browser automatically.");
-            info("Please open the URL above manually.");
+            info('Could not open browser automatically.');
+            info('Please open the URL above manually.');
         }
         info(`Waiting for authorization (expires in ${expires_in}s, press Ctrl+C to cancel)...`);
         // Step 3: Poll for token
         const startTime = Date.now();
         const timeoutMs = expires_in * 1000;
         while (Date.now() - startTime < timeoutMs) {
-            await new Promise((resolve) => setTimeout(resolve, poll_interval * 1000));
+            await new Promise(resolve => setTimeout(resolve, poll_interval * 1000));
             const elapsedSec = Math.round((Date.now() - startTime) / 1000);
             const remainingSec = expires_in - elapsedSec;
-            const tokenResp = await unauthenticatedRequest(baseUrl, `/api/cli_auth/token?code=${encodeURIComponent(device_code)}`, "GET");
-            if (tokenResp.status === "approved" && tokenResp.api_key) {
+            const tokenResp = await unauthenticatedRequest(baseUrl, `/api/cli_auth/token?code=${encodeURIComponent(device_code)}`, 'GET');
+            if (tokenResp.status === 'approved' && tokenResp.api_key) {
                 // Save to config
                 const config = loadConfigFile();
                 config.api_key = tokenResp.api_key;
                 saveConfigFile(config);
-                info("Login successful! API key saved.");
+                info('Login successful! API key saved.');
                 output({
-                    status: "ok",
-                    message: "Login successful",
+                    status: 'ok',
+                    message: 'Login successful',
                     data: { config_path: getConfigPath() },
                 });
                 return;
             }
-            if (tokenResp.status === "expired") {
-                logError("Authorization expired. Please try again.");
+            if (tokenResp.status === 'expired') {
+                logError('Authorization expired. Please try again.');
                 process.exit(1);
             }
             // status === "pending" — keep polling with countdown
             info(`Still waiting for authorization... (${remainingSec}s remaining)`);
         }
-        logError("Authorization timed out. Please try again.");
+        logError('Authorization timed out. Please try again.');
         process.exit(1);
     }
     catch (err) {
@@ -523,8 +703,8 @@ program
 });
 // Logout - remove API key from config
 program
-    .command("logout")
-    .description("Log out by removing the saved API key")
+    .command('logout')
+    .description('Log out by removing the saved API key')
     .action(() => {
     const globalOpts = getGlobalOptions();
     setDebugEnabled(globalOpts.debug);
@@ -532,15 +712,15 @@ program
     try {
         const config = loadConfigFile();
         if (!config.api_key) {
-            info("Already logged out (no API key in config).");
+            info('Already logged out (no API key in config).');
             return;
         }
         delete config.api_key;
         saveConfigFile(config);
-        info("Logged out. API key removed.");
+        info('Logged out. API key removed.');
         output({
-            status: "ok",
-            message: "Logged out",
+            status: 'ok',
+            message: 'Logged out',
             data: { config_path: getConfigPath() },
         });
     }
@@ -549,6 +729,160 @@ program
         process.exit(1);
     }
 });
+// Login info - show current user identity
+program
+    .command('login-info')
+    .alias('me')
+    .description('Show current user info (email, plan)')
+    .action(async () => {
+    try {
+        const client = createClient();
+        const userInfo = await client.getMe();
+        output({
+            status: 'ok',
+            message: 'success',
+            data: userInfo,
+        });
+    }
+    catch (err) {
+        logError(err.message);
+        process.exit(1);
+    }
+});
+// Init OpenCode - generate opencode.json config
+program
+    .command('init-opencode')
+    .description('Generate an opencode.json config file for OpenCode AI coding tool')
+    .option('--model <model>', 'Default model to use (e.g., claude-opus-4-6-1m)')
+    .option('-o, --out <path>', 'Output file path', pathModule.resolve('.opencode.json'))
+    .action(async (opts) => {
+    try {
+        const client = createClient();
+        const config = await client.getOpencodeConfig(opts.model);
+        const outputPath = pathModule.resolve(opts.out);
+        fs.writeFileSync(outputPath, JSON.stringify(config, null, 2) + '\n');
+        info(`Wrote OpenCode config to ${outputPath}`);
+        output({
+            status: 'ok',
+            message: `Config written to ${outputPath}`,
+            data: { path: outputPath },
+        });
+    }
+    catch (err) {
+        logError(err.message);
+        process.exit(1);
+    }
+});
+// ============================================
+// Phone Call Command
+// ============================================
+program
+    .command('call')
+    .description('Make an AI phone call on your behalf. Validates prerequisites, resolves contact info, and initiates the call.')
+    .argument('<recipient>', 'Name of the person or business to call')
+    .requiredOption('-c, --contact_info <value>', 'Phone number (e.g. +1-555-123-4567) or Google Maps place_id')
+    .option('--is_place_id', 'Treat contact_info as a Google Maps place_id (for businesses)', false)
+    .requiredOption('-p, --purpose <value>', "Purpose of the call (e.g. 'Check reservation availability')")
+    .option('--dry-run', 'Only validate and resolve contact info, do not initiate the call')
+    .action(async (recipient, opts) => {
+    try {
+        const client = createClient();
+        if (opts.dryRun) {
+            // Dry run: just call the phone_call tool to validate and resolve
+            info('Dry run: validating prerequisites and resolving contact info...');
+            const result = await client.executeTool('phone_call', {
+                recipient,
+                contact_info: opts.contact_info,
+                is_place_id: opts.is_place_id,
+                purpose: opts.purpose,
+            });
+            if (result.status === 'ok' && result.session_state) {
+                const contacts = result.session_state.local_results;
+                if (contacts && contacts.length > 0) {
+                    const c = contacts[0];
+                    info('');
+                    info('=== Contact Resolved ===');
+                    info(`  Name:    ${c.title || recipient}`);
+                    info(`  Phone:   ${c.phone || '(from place_id)'}`);
+                    if (c.address)
+                        info(`  Address: ${c.address}`);
+                    if (c.rating)
+                        info(`  Rating:  ${c.rating}`);
+                    info(`  Purpose: ${opts.purpose}`);
+                    info('');
+                    info('Dry run complete. Use without --dry-run to initiate the call.');
+                }
+            }
+            output(result);
+            return;
+        }
+        // Full call: use the streaming initiate endpoint
+        info(`Initiating AI phone call to "${recipient}"...`);
+        info(`  Purpose: ${opts.purpose}`);
+        info('');
+        const result = await client.requestStreaming('/phone_call/initiate', {
+            recipient,
+            contact_info: opts.contact_info,
+            is_place_id: opts.is_place_id,
+            purpose: opts.purpose,
+        }, (msg) => {
+            // Display streaming status updates to stderr
+            const step = msg.step || '';
+            if (step === 'resolved') {
+                const contact = msg.contact;
+                if (contact) {
+                    info('Contact resolved:');
+                    info(`  Name:    ${contact.title || recipient}`);
+                    info(`  Phone:   ${contact.phone || '(from place_id)'}`);
+                    if (contact.address)
+                        info(`  Address: ${contact.address}`);
+                }
+            }
+            else if (step === 'calling') {
+                info(`Dialing... (project: ${msg.project_id || 'unknown'})`);
+            }
+            else if (msg.heartbeat) {
+                const elapsed = msg.elapsed_seconds;
+                const callStep = msg.call_step;
+                info(`  Call in progress... ${elapsed ? `(${elapsed}s)` : ''}${callStep && callStep !== 'in_progress' ? ` [${callStep}]` : ''}`);
+            }
+            else if (msg.message) {
+                info(`  ${msg.message}`);
+            }
+        });
+        // Display final result
+        const data = (result.data || {});
+        const callStatus = data.call_status || 'unknown';
+        const callSummary = data.call_summary || '';
+        const isFailure = result.status === 'error' ||
+            ['failed', 'canceled', 'busy', 'no-answer'].includes(callStatus);
+        info('');
+        info(isFailure ? '=== Call Failed ===' : '=== Call Complete ===');
+        info(`  Recipient: ${data.recipient || recipient}`);
+        info(`  Status:    ${callStatus}`);
+        if (data.duration_seconds)
+            info(`  Duration:  ${data.duration_seconds}s`);
+        info('');
+        info('=== Call Summary ===');
+        if (callSummary) {
+            info(callSummary);
+        }
+        else if (isFailure) {
+            info(result.message && result.message !== `Phone call completed (${callStatus})`
+                ? result.message
+                : 'Call failed. The call could not be completed.');
+        }
+        else {
+            info('Call completed. No summary available.');
+        }
+        info('');
+        output(result);
+    }
+    catch (err) {
+        logError(err.message);
+        process.exit(1);
+    }
+});
 // ============================================
 // Dynamic Tool Registration & Startup
 // ============================================
@@ -568,17 +902,15 @@ async function main() {
     const baseUrl = globalOpts.baseUrl;
     const forceRefresh = globalOpts.refresh || false;
     // Try to load tools from cache
-    let tools = forceRefresh
-        ? null
-        : loadToolsCache(baseUrl);
+    let tools = forceRefresh ? null : loadToolsCache(baseUrl);
     if (tools) {
         debug(`Loaded ${tools.length} tools from cache`);
     }
     else {
         // Need to fetch from server
         debug(forceRefresh
-            ? "Force refreshing tools from server..."
-            : "No cached tools found, fetching from server...");
+            ? 'Force refreshing tools from server...'
+            : 'No cached tools found, fetching from server...');
         // Only fetch if we have an API key
         if (globalOpts.apiKey) {
             try {
@@ -594,7 +926,7 @@ async function main() {
             }
         }
         else {
-            debug("No API key available, skipping tool fetch");
+            debug('No API key available, skipping tool fetch');
         }
     }
     // Register dynamic tool commands
@@ -606,7 +938,7 @@ async function main() {
     // Parse and run
     program.parse();
 }
-main().catch((err) => {
+main().catch(err => {
     logError(err.message);
     process.exit(1);
 });