@genspark/cli 1.5.1 → 1.5.3

package/dist/index.js

@@ -27,13 +27,14 @@ import * as pathModule from 'path';
 import { createRequire } from 'module';
 import { spawn } from 'child_process';
 import { ApiClient, isAuthError, unauthenticatedRequest, } from './client.js';
-import { classifyFileArg, awaitLocalFileReady, decideAfterWait, localFileNotReadyError, } from './localFiles.js';
+import { classifyFileArg, awaitLocalFileReady, decideAfterWait, localFileNotReadyError, passthroughWarning, urlsParamItems, } from './localFiles.js';
 import { setDebugEnabled, setOutputFormat, debug, info, warn, error as logError, output, } from './logger.js';
 import { loadConfigFile, getConfigPath, loadToolsCache, normalizeBaseUrl, saveToolsCache, setConfigPathOverride, updateConfigFile, } from './config.js';
 import { checkForUpdates } from './updater.js';
+import { shimLegacyTaskInvocation } from './task-shim.js';
 import { getSandboxRuntime } from './runtime.js';
 import { registerDesignCommand } from './commands/design.js';
-import { pickExistingFileOperand } from './commands/aidrive-upload.js';
+import { collectUploadFiles, pickExistingUploadOperand, } from './commands/aidrive-upload.js';
 import { parseLastSeenIndex, eventStdoutLine } from './commands/chat-events.js';
 import { mediaItemsKeyFor, mediaSummaryLines } from './mediaSummary.js';
 import { registerMeshCommand, getMeshInvocation, runMesh, } from './commands/mesh.js';
@@ -351,7 +352,7 @@ async function uploadLocalFile(filePath, client) {
  *
  * This avoids the roundabout blob-upload + download_file two-step approach.
  */
-async function uploadToAiDrive(filePath, uploadPath, override = false) {
+async function uploadToAiDrive(filePath, uploadPath, override = false, workspace = 'personal') {
     const fileName = pathModule.basename(filePath);
     const ext = pathModule.extname(filePath).toLowerCase();
     const contentType = CONTENT_TYPE_MAP[ext] || 'application/octet-stream';
@@ -359,7 +360,7 @@ async function uploadToAiDrive(filePath, uploadPath, override = false) {
     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 uploadUrl = `${baseUrl}/api/tool_cli/aidrive/upload?upload_path=${encodeURIComponent(uploadPath)}&workspace=${encodeURIComponent(workspace)}${override ? '&override=true' : ''}`;
     const headers = { 'Content-Type': contentType };
     if (globalOpts.apiKey)
         headers['X-Api-Key'] = globalOpts.apiKey;
@@ -417,7 +418,9 @@ async function resolveFileArg(value, client) {
         case 'passthrough':
             // No local evidence beyond the parent directory: let the backend try
             // it as an AI Drive path (its failure mode is a per-URL actionable
-            // error, not a generic one).
+            // error, not a generic one). Warn first so a failed producer in the
+            // same batch is diagnosable from this call's own output.
+            warn(passthroughWarning(localPath, readiness));
             return value;
     }
 }
@@ -485,23 +488,29 @@ async function resolveLocalFiles(args, client) {
         }
         // Other array-of-URLs params (e.g. image_urls) — keep the existing
         // auto-upload-to-blob behaviour, which is the right thing for image
-        // generation sources etc.
-        else if (key.endsWith('_urls') && Array.isArray(value)) {
-            const resolvedUrls = [];
-            for (const item of value) {
-                if (typeof item === 'string') {
-                    resolvedUrls.push(await resolveFileArg(item, client));
-                }
-                else {
-                    resolvedUrls.push(item);
+        // generation sources etc. urlsParamItems also accepts a plain-string
+        // value (an --args-file authored with a string where the schema wants
+        // an array) so the local path still gets uploaded instead of leaking
+        // to the server; writing the array back restores the schema shape.
+        else {
+            const urlsItems = urlsParamItems(key, value);
+            if (urlsItems) {
+                const resolvedUrls = [];
+                for (const item of urlsItems) {
+                    if (typeof item === 'string') {
+                        resolvedUrls.push(await resolveFileArg(item, client));
+                    }
+                    else {
+                        resolvedUrls.push(item);
+                    }
                 }
+                resolved[key] = resolvedUrls;
+            }
+            // Handle single URL (e.g., url, audio_url)
+            else if ((key === 'url' || key.endsWith('_url')) &&
+                typeof value === 'string') {
+                resolved[key] = await resolveFileArg(value, client);
             }
-            resolved[key] = resolvedUrls;
-        }
-        // Handle single URL (e.g., url, audio_url)
-        else if ((key === 'url' || key.endsWith('_url')) &&
-            typeof value === 'string') {
-            resolved[key] = await resolveFileArg(value, client);
         }
     }
     return resolved;
@@ -754,9 +763,17 @@ function registerToolCommand(parentProgram, tool, clientFactory, vdProjectIdDefa
     if (outputFileKeys.length > 0) {
         cmd.option('-o, --output-file <path>', 'Download the generated file to a local path');
     }
+    // task ask (task_continue) shares the async-first submit → --follow
+    // upgrades the stub into a live SSE follow, same as task create.
+    // (Named --follow, not --attach: tools with an attachments array param
+    // already own --attach as a file alias.)
+    if (tool.name === 'task_continue') {
+        cmd.option('--follow', 'After the async submit, follow the durable run live (SSE) and exit with the terminal result', false);
+    }
     // For create_task, add --acp flag to enter ACP stdio bridge mode
     if (tool.name === 'create_task') {
         cmd.option('--acp', 'Start as ACP (Agent Client Protocol) stdio agent instead of one-shot execution', false);
+        cmd.option('--follow', 'After the async submit, follow the durable run live (SSE) and exit with the terminal result', false);
         cmd.option('-o, --output-file <path>', 'Export the artifact (pptx/docx/xlsx) to a local file after task completes');
         cmd.option('--session-id <id>', 'ACP session ID (used with get-project)');
         cmd.option('--file <values...>', 'Import local files (Design: structured context; other tasks: CSV/Excel file_urls)');
@@ -774,6 +791,9 @@ function registerToolCommand(parentProgram, tool, clientFactory, vdProjectIdDefa
     }
     // For the aidrive tool, add client-side options used with --local_file upload
     if (tool.name === 'aidrive') {
+        if (!Object.hasOwn(props, 'workspace')) {
+            cmd.option('--workspace <value>', 'AI Drive workspace: personal or public_brain');
+        }
         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);
     }
@@ -908,6 +928,11 @@ function registerToolCommand(parentProgram, tool, clientFactory, vdProjectIdDefa
             const outputFilePath = opts.outputFile;
             delete opts.outputFile;
             delete opts.acp; // ACP flag is client-side only
+            // -o exports an artifact of the FINISHED project — an async submit
+            // stub has nothing to export yet, so an export request implies the
+            // live follow.
+            const attachTask = !!opts.follow || !!outputFilePath;
+            delete opts.follow; // client-side only
             delete opts.sessionId; // get-project flag is client-side only
             const argsFilePath = opts.argsFile;
             delete opts.argsFile; // client-side only; merged below
@@ -1115,7 +1140,7 @@ function registerToolCommand(parentProgram, tool, clientFactory, vdProjectIdDefa
                 const operandCandidates = primaryArgValue !== undefined && primaryArgValue === args.action
                     ? cmd.args.slice(1)
                     : cmd.args;
-                const pathOperand = pickExistingFileOperand(operandCandidates);
+                const pathOperand = pickExistingUploadOperand(operandCandidates);
                 if (pathOperand) {
                     opts.local_file = pathOperand;
                 }
@@ -1135,6 +1160,7 @@ function registerToolCommand(parentProgram, tool, clientFactory, vdProjectIdDefa
                 opts.local_file) {
                 const localFilePath = opts.local_file;
                 const override = !!opts.override;
+                const workspace = args.workspace || 'personal';
                 if (!fs.existsSync(localFilePath)) {
                     logError(`File not found: ${localFilePath}`);
                     process.exit(1);
@@ -1146,9 +1172,35 @@ function registerToolCommand(parentProgram, tool, clientFactory, vdProjectIdDefa
                 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);
+                const localStat = fs.statSync(localFilePath);
+                const files = collectUploadFiles(localFilePath);
+                if (localStat.isDirectory()) {
+                    if (files.length === 0) {
+                        logError(`Folder has no files to upload: ${localFilePath}`);
+                        process.exit(1);
+                    }
+                    info(`Uploading folder ${localFilePath} (${files.length} files)...`);
+                    const uploaded = [];
+                    for (const file of files) {
+                        const destination = pathModule.posix.join(uploadPath, file.relativePath);
+                        const result = await uploadToAiDrive(file.absolutePath, destination, override, workspace);
+                        if (result.status !== 'ok') {
+                            output(result);
+                            process.exit(1);
+                        }
+                        uploaded.push(destination);
+                    }
+                    output({
+                        status: 'ok',
+                        message: `Uploaded ${uploaded.length} files`,
+                        data: { workspace, root: uploadPath, files: uploaded },
+                    });
+                }
+                else {
+                    // Stream directly to AI Drive — single request, no blob middleman
+                    const result = await uploadToAiDrive(localFilePath, uploadPath, override, workspace);
+                    output(result);
+                }
                 return;
             }
             const designAttachmentArgs = collectDesignAttachmentArgs(process.argv);
@@ -1200,7 +1252,36 @@ function registerToolCommand(parentProgram, tool, clientFactory, vdProjectIdDefa
             }
             // Resolve local file paths to uploaded URLs
             const resolvedArgs = await resolveLocalFiles(args, client);
-            const result = await client.executeTool(tool.name, resolvedArgs);
+            // The server owns the async-first default: create_task /
+            // task_continue return a submit stub ({status: "submitted",
+            // run_id, stream_url}) unless `--wait true` was passed. --attach
+            // upgrades the stub into a live SSE follow that exits with the
+            // run's terminal result — the work still executes server-side.
+            let result = await client.executeTool(tool.name, resolvedArgs);
+            const stubData = result.data;
+            if (attachTask &&
+                result.status === 'ok' &&
+                stubData &&
+                typeof stubData.stream_url === 'string' &&
+                (stubData.status === 'submitted' ||
+                    stubData.status === 'duplicate_submit_converged')) {
+                const meta = await client.attachGskTaskRun(stubData.stream_url);
+                const runStatus = String(meta.status || '');
+                const summary = meta.result_summary && typeof meta.result_summary === 'object'
+                    ? meta.result_summary
+                    : {};
+                result = {
+                    status: runStatus === 'succeeded' ? 'ok' : 'error',
+                    message: runStatus === 'succeeded'
+                        ? 'success'
+                        : `task ended with status ${runStatus || 'unknown'}`,
+                    data: {
+                        ...summary,
+                        run_id: stubData.run_id,
+                        run_status: runStatus,
+                    },
+                };
+            }
             const isSbGitCloneUrl = tool.name === 'sb-git' &&
                 resolvedArgs.action === 'clone-url';
             if (isSbGitCloneUrl &&
@@ -2105,19 +2186,23 @@ _groupCommands.set('phone-call', phoneCallCmd);
 // gk_tool_cli_conversation) and attach as dynamic subcommands via the
 // seeded _groupCommands entry; this static parent only gives the group a
 // real description instead of the generated "Commands for chat".
-const chatCmd = program
-    .command('chat')
-    .description('Headless agent conversations: start one and get ids back immediately, ' +
-    'poll status for replies, send follow-ups, stop, delete, rename ' +
-    '(see subcommands).');
-_groupCommands.set('chat', chatCmd);
-// `chat events` is static (not server-registered): it needs real-time
+// The task command tree. Verbs are server-registered (create / status /
+// info / ask / answer / messages / wait / stop / delete / rename attach as
+// dynamic subcommands via the seeded group); this static parent gives the
+// group a description, and hosts the one static verb below.
+const taskCmd = program
+    .command('task')
+    .description('Agent tasks and conversations: create one (submits and returns in ' +
+    'seconds), poll status, read outputs, send follow-ups, answer ' +
+    'agent questions, stop, delete, rename (see subcommands).');
+_groupCommands.set('task', taskCmd);
+// `task events` is static (not server-registered): it needs real-time
 // line-by-line output the generic dynamic-command handler cannot provide
 // (that path buffers intermediate NDJSON messages and only prints the
 // final result).
-chatCmd
+taskCmd
     .command('events <project_id>')
-    .description("Attach to the conversation's in-flight run and stream its events " +
+    .description("Attach to the task's in-flight run and stream its events " +
     'live (one JSON line per event on stdout): the first line is a ' +
     'project_data snapshot event, buffered events since run start ' +
     'replay next, then live events follow until the run ends. Every ' +
@@ -2167,10 +2252,78 @@ chatCmd
         process.exit(1);
     }
 });
+// `task export` is static: it composes two calls (task_status to resolve
+// the task type, then /export_artifact) plus an optional local download —
+// the generic dynamic handler maps one verb to one server tool.
+taskCmd
+    .command('export <project_id>')
+    .description("Convert and download a task's deliverable (docs → docx/pdf, " +
+    'slides → pptx/pdf, sheets → xlsx). Prints the download URL; with ' +
+    '-o <path> also saves the file locally. The task type is resolved ' +
+    'automatically from the project; `gsk task artifacts <project_id>` ' +
+    'lists what a task produced and which formats it can export.')
+    .option('--format <format>', 'export format: auto | docx | pdf | pptx | xlsx (auto picks the ' +
+    "task type's natural format)", 'auto')
+    .option('-o, --output-file <path>', 'save the exported file to this path')
+    .action(async (projectId, opts) => {
+    try {
+        const client = createClient();
+        const statusResult = await client.executeTool('task_status', {
+            id: projectId,
+        });
+        const statusData = statusResult.data;
+        const taskType = statusResult.status === 'ok' && statusData
+            ? statusData.task_type
+            : undefined;
+        if (!taskType) {
+            output(statusResult.status === 'ok'
+                ? {
+                    status: 'error',
+                    message: `Cannot resolve task type for ${projectId}`,
+                    data: null,
+                }
+                : statusResult);
+            process.exit(1);
+        }
+        const exportResult = await client.exportArtifact(projectId, taskType, opts.format || 'auto');
+        const expData = exportResult.data;
+        if (exportResult.status === 'ok' && expData && opts.outputFile) {
+            const downloadUrl = expData.download_url;
+            if (downloadUrl) {
+                expData.local_path = await downloadToFile(downloadUrl, opts.outputFile, client);
+            }
+            else {
+                // The converter can report ok with an empty URL (e.g. the
+                // share-link build failed server-side) — surface it instead
+                // of printing ok with no file on disk.
+                output({
+                    status: 'error',
+                    message: 'Export produced no download_url — nothing was saved ' +
+                        `to ${opts.outputFile}`,
+                    data: expData,
+                });
+                process.exit(1);
+            }
+        }
+        output(exportResult);
+        if (exportResult.status === 'error') {
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        logError(err.message);
+        process.exit(1);
+    }
+});
 // ============================================
 // Dynamic Tool Registration & Startup
 // ============================================
 async function main() {
+    // Pre-tree `gsk task <type>` compat (see shimLegacyTaskInvocation).
+    process.argv = [
+        ...process.argv.slice(0, 2),
+        ...shimLegacyTaskInvocation(process.argv.slice(2)),
+    ];
     // `gsk mesh ...` is a native-binary passthrough — intercept it before the
     // tool-fetch path and npm self-update gating (it needs neither). Handling it
     // outside commander keeps the rest of the CLI's option parsing intact (see