@genspark/cli 1.6.0 → 1.7.0

package/dist/commands/aidrive-download.d.ts

@@ -0,0 +1,23 @@
+import type { ApiResponse } from '../types.js';
+/**
+ * Name the operands of `gsk aidrive download <ai-drive-path> [local-path]`:
+ * first is the source, second the destination. With `explicitDrivePath` from
+ * `--path`/`-p`, the first operand is the destination instead.
+ */
+export declare function resolveAidriveDownloadOperands(operands: readonly string[], explicitDrivePath?: string): {
+    drivePath?: string;
+    localPath?: string;
+};
+/**
+ * Accept either spelling of an AI-Drive location — `aidrive:///a/b.pdf` (how
+ * attachments arrive) or the plain `/a/b.pdf` — and return the plain path the
+ * API takes. A path without the scheme passes through untouched.
+ */
+export declare function normalizeDrivePath(pathOrUrl: string): string;
+/**
+ * Pull the signed download URL out of a `get_readable_url` response.
+ * `data.result` is prose ("Readable URL for <path>: <url>") and not meant to
+ * be parsed; the structured value lives in `session_state.aidrive_result`.
+ */
+export declare function extractReadableUrl(response: Pick<ApiResponse, 'status' | 'session_state'>): string | undefined;
+//# sourceMappingURL=aidrive-download.d.ts.map

package/dist/commands/aidrive-download.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aidrive-download.d.ts","sourceRoot":"","sources":["../../src/commands/aidrive-download.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAE9C;;;;GAIG;AACH,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,iBAAiB,CAAC,EAAE,MAAM,GACzB;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAQ5C;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAG5D;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,IAAI,CAAC,WAAW,EAAE,QAAQ,GAAG,eAAe,CAAC,GACtD,MAAM,GAAG,SAAS,CAMpB"}

package/dist/commands/aidrive-download.js

@@ -0,0 +1,36 @@
+/**
+ * Name the operands of `gsk aidrive download <ai-drive-path> [local-path]`:
+ * first is the source, second the destination. With `explicitDrivePath` from
+ * `--path`/`-p`, the first operand is the destination instead.
+ */
+export function resolveAidriveDownloadOperands(operands, explicitDrivePath) {
+    const bareOperands = operands.filter((operand) => operand.length > 0 && !operand.startsWith('-'));
+    if (explicitDrivePath) {
+        return { drivePath: explicitDrivePath, localPath: bareOperands[0] };
+    }
+    return { drivePath: bareOperands[0], localPath: bareOperands[1] };
+}
+/**
+ * Accept either spelling of an AI-Drive location — `aidrive:///a/b.pdf` (how
+ * attachments arrive) or the plain `/a/b.pdf` — and return the plain path the
+ * API takes. A path without the scheme passes through untouched.
+ */
+export function normalizeDrivePath(pathOrUrl) {
+    // The scheme normally carries an empty host, hence the slash run.
+    return pathOrUrl.replace(/^aidrive:\/+/, '/');
+}
+/**
+ * Pull the signed download URL out of a `get_readable_url` response.
+ * `data.result` is prose ("Readable URL for <path>: <url>") and not meant to
+ * be parsed; the structured value lives in `session_state.aidrive_result`.
+ */
+export function extractReadableUrl(response) {
+    if (response.status !== 'ok')
+        return undefined;
+    const aidriveResult = response.session_state?.aidrive_result;
+    if (!aidriveResult || typeof aidriveResult !== 'object')
+        return undefined;
+    const url = aidriveResult.readable_url;
+    return typeof url === 'string' && url ? url : undefined;
+}
+//# sourceMappingURL=aidrive-download.js.map

package/dist/commands/aidrive-download.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aidrive-download.js","sourceRoot":"","sources":["../../src/commands/aidrive-download.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,UAAU,8BAA8B,CAC5C,QAA2B,EAC3B,iBAA0B;IAE1B,MAAM,YAAY,GAAG,QAAQ,CAAC,MAAM,CAClC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAC5D,CAAA;IACD,IAAI,iBAAiB,EAAE,CAAC;QACtB,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,CAAA;IACrE,CAAC;IACD,OAAO,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,CAAA;AACnE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAC,SAAiB;IAClD,kEAAkE;IAClE,OAAO,SAAS,CAAC,OAAO,CAAC,cAAc,EAAE,GAAG,CAAC,CAAA;AAC/C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAChC,QAAuD;IAEvD,IAAI,QAAQ,CAAC,MAAM,KAAK,IAAI;QAAE,OAAO,SAAS,CAAA;IAC9C,MAAM,aAAa,GAAG,QAAQ,CAAC,aAAa,EAAE,cAAc,CAAA;IAC5D,IAAI,CAAC,aAAa,IAAI,OAAO,aAAa,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAA;IACzE,MAAM,GAAG,GAAI,aAAyC,CAAC,YAAY,CAAA;IACnE,OAAO,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAA;AACzD,CAAC"}

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;GAkBG;AAqQH,KAAK,oBAAoB,GAAG,kBAAkB,GAAG,SAAS,GAAG,SAAS,CAAA;AAEtE,UAAU,mBAAmB;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,oBAAoB,CAAA;CAC3B;AAED,kFAAkF;AAClF,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,MAAM,EAAE,GACb,mBAAmB,EAAE,CAqBvB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;GAkBG;AAiRH,KAAK,oBAAoB,GAAG,kBAAkB,GAAG,SAAS,GAAG,SAAS,CAAA;AAEtE,UAAU,mBAAmB;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,oBAAoB,CAAA;CAC3B;AAED,kFAAkF;AAClF,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,MAAM,EAAE,GACb,mBAAmB,EAAE,CAqBvB"}

package/dist/index.js

@@ -26,15 +26,19 @@ import * as os from 'os';
 import * as pathModule from 'path';
 import { createRequire } from 'module';
 import { spawn } from 'child_process';
+import { Readable } from 'stream';
+import { pipeline } from 'stream/promises';
 import { ApiClient, isAuthError, unauthenticatedRequest, } from './client.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 { addRegisteredCommands, collectToolCommandTokens, staleCacheMissingToken, } from './staleCache.js';
 import { shimLegacyTaskInvocation } from './task-shim.js';
 import { getSandboxRuntime } from './runtime.js';
 import { registerDesignCommand } from './commands/design.js';
 import { collectUploadFiles, pickExistingUploadOperand, } from './commands/aidrive-upload.js';
+import { resolveAidriveDownloadOperands, normalizeDrivePath, extractReadableUrl, } from './commands/aidrive-download.js';
 import { parseLastSeenIndex, eventStdoutLine } from './commands/chat-events.js';
 import { mediaItemsKeyFor, mediaSummaryLines } from './mediaSummary.js';
 import { registerMeshCommand, getMeshInvocation, runMesh, } from './commands/mesh.js';
@@ -320,6 +324,8 @@ async function streamFileUpload(filePath, uploadUrl, headers, fileSize, method =
     });
 }
 function formatFileSize(bytes) {
+    if (bytes >= 1024 ** 3)
+        return `${(bytes / 1024 ** 3).toFixed(1)} GB`;
     if (bytes >= 1024 * 1024)
         return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
     return `${(bytes / 1024).toFixed(1)} KB`;
@@ -389,9 +395,13 @@ async function downloadToFile(url, savePath, client) {
     const resp = await fetch(downloadUrl);
     if (!resp.ok)
         throw new Error(`Download failed: HTTP ${resp.status}`);
-    const buffer = Buffer.from(await resp.arrayBuffer());
-    fs.writeFileSync(savePath, buffer);
-    info(`Downloaded ${(buffer.length / 1024).toFixed(1)} KB → ${savePath}`);
+    if (!resp.body)
+        throw new Error('Download failed: empty response body');
+    // Stream to disk: AI-Drive reads reach GB scale, past what the sandbox's
+    // swap-less RAM tolerates as a single buffer.
+    await pipeline(Readable.fromWeb(resp.body), fs.createWriteStream(savePath));
+    const sizeBytes = fs.statSync(savePath).size;
+    info(`Downloaded ${formatFileSize(sizeBytes)} → ${savePath}`);
     return pathModule.resolve(savePath);
 }
 function isLocalFilePath(value) {
@@ -817,12 +827,15 @@ function registerToolCommand(parentProgram, tool, clientFactory, vdProjectIdDefa
         cmd.option('--image <values...>', 'Design only: append ordered local visual references');
         cmd.option('--file <values...>', 'Design only: append ordered local context files');
     }
-    // For the aidrive tool, add client-side options used with --local_file upload
+    // For the aidrive tool, add client-side options used by the --local_file
+    // upload and by `download`'s local destination.
     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('--local_file <path>', 'upload: local file path to upload to AI Drive (supports files >5 MB; ' +
+            'alternative to --file_content). download: local destination path ' +
+            '(same as the second operand; default ./<basename of the drive path>)');
         cmd.option('--override', 'Overwrite an existing file at the destination path (used with --local_file)', false);
     }
     // For sb-git: `--execute [dest]` turns `clone-url` from a snippet-print
@@ -1190,6 +1203,75 @@ function registerToolCommand(parentProgram, tool, clientFactory, vdProjectIdDefa
                         process.exit(1);
                     }
                 }
+                // Copy an AI-Drive file OUT to local disk. Client-side because only
+                // this process can write the local filesystem: resolve the path to a
+                // signed URL, then save it with the same streaming helper `-o` uses.
+                // Never forwarded to the server, which answers a CLI too old to
+                // intercept it with the two-call equivalent.
+                if (tool.name === 'aidrive' && args.action === 'download') {
+                    const operandCandidates = primaryArgValue !== undefined && primaryArgValue === args.action
+                        ? invokedCmd.args.slice(1)
+                        : invokedCmd.args;
+                    const { drivePath: sourceOperand, localPath: operandDest } = resolveAidriveDownloadOperands(operandCandidates, typeof args.path === 'string' ? args.path : undefined);
+                    if (!sourceOperand) {
+                        logError('download needs the AI-Drive path: gsk aidrive download ' +
+                            '<ai-drive-path> [local-path] (or --path/-p). To save an ' +
+                            'external url INTO AI Drive instead, use ' +
+                            '`download_file --file_url <url>`.');
+                        process.exit(1);
+                    }
+                    // Attachments arrive spelled `aidrive:///a/b.pdf`; take that as-is
+                    // rather than making the caller strip the scheme.
+                    const drivePath = normalizeDrivePath(sourceOperand);
+                    const urlResult = await client.executeTool('aidrive', {
+                        action: 'get_readable_url',
+                        path: drivePath,
+                        workspace: args.workspace,
+                        share: args.share,
+                    });
+                    const readableUrl = extractReadableUrl(urlResult);
+                    if (!readableUrl) {
+                        logError(`Failed to resolve AI-Drive path ${drivePath}: ${urlResult.message}`);
+                        process.exit(1);
+                    }
+                    const destPath = (typeof opts.local_file === 'string' ? opts.local_file : '') ||
+                        operandDest ||
+                        pathModule.basename(drivePath);
+                    const savedPath = await downloadToFile(readableUrl, destPath, client);
+                    output({
+                        status: 'ok',
+                        message: 'AI-Drive file downloaded to local disk',
+                        data: { ai_drive_path: drivePath, local_path: savedPath },
+                    });
+                    return;
+                }
+                // `download_file` saves an external URL INTO the drive and cannot copy
+                // one out, yet it is the obvious spelling for "download a drive file"
+                // and both attempts used to fail silently: its handler never consumes
+                // `path`, and an `aidrive://` --file_url fails the server's URL
+                // validation (16 consecutive no-op calls observed in #52631). Name
+                // `download` instead of letting either shape exit 0 having done
+                // nothing.
+                if (tool.name === 'aidrive' && args.action === 'download_file') {
+                    const fileUrl = typeof args.file_url === 'string' ? args.file_url : '';
+                    if (fileUrl.startsWith('aidrive://')) {
+                        logError('download_file saves an external URL INTO AI Drive; it cannot ' +
+                            'copy one out. Use: gsk aidrive download ' +
+                            `${fileUrl} <local-path>`);
+                        process.exit(1);
+                    }
+                    if (!fileUrl) {
+                        const operandCandidates = primaryArgValue !== undefined && primaryArgValue === args.action
+                            ? invokedCmd.args.slice(1)
+                            : invokedCmd.args;
+                        const { drivePath } = resolveAidriveDownloadOperands(operandCandidates, typeof args.path === 'string' ? args.path : undefined);
+                        logError('download_file needs `--file_url <external-url>` — it saves an ' +
+                            'external URL INTO AI Drive. To copy a drive file OUT to ' +
+                            'local disk: gsk aidrive download ' +
+                            `${drivePath || '<ai-drive-path>'} <local-path>`);
+                        process.exit(1);
+                    }
+                }
                 // 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.
@@ -2164,8 +2246,8 @@ async function phoneCallAction(recipient, opts, invokedAs) {
             info('=== Call Dispatched (async) ===');
             info(`  Recipient:  ${data.recipient || recipient}`);
             info(`  Project ID: ${data.project_id}`);
-            info(`  Poll:  gsk call-status ${data.project_id}`);
-            info(`  Stop:  gsk call-hangup ${data.project_id}`);
+            info(`  Poll:  gsk telephony call status ${data.project_id}`);
+            info(`  Stop:  gsk telephony call hangup ${data.project_id}`);
             output(result);
             return;
         }
@@ -2436,6 +2518,41 @@ async function main() {
     const forceRefresh = globalOpts.refresh || false;
     // Try to load tools from cache
     let tools = forceRefresh ? null : loadToolsCache(baseUrl);
+    // Needed both for the stale-cache check and for dynamic registration below.
+    const vdProjectId = resolveVdProjectId();
+    // Stale-cache self-heal (#51775): the server omits gatekeeper-gated tools
+    // per user, so a cached tree written before a gate flipped ON rejects the
+    // newly enabled command for up to the cache TTL. When argv clearly cannot
+    // resolve against the cached tree, drop the cache and take the fetch
+    // branch below — one manifest GET instead of a 24h blind window.
+    // When the heal path drops the cache, keep the stale tree as a fallback:
+    // a failed manifest GET must not leave the invocation with ZERO dynamic
+    // commands (strictly worse than the stale cache it replaced).
+    let staleFallbackTools = null;
+    if (tools && globalOpts.apiKey) {
+        let missing = null;
+        try {
+            const { operands } = program.parseOptions(process.argv.slice(2));
+            const index = collectToolCommandTokens(tools, Boolean(vdProjectId));
+            // phone-call / call-for-me dial by DEFAULT subcommand, so their second
+            // token may be a recipient — never provably a miss. (`telephony call
+            // <recipient>` is level-3 and outside the two-level check.)
+            addRegisteredCommands(index, program.commands, [
+                'phone-call',
+                'call-for-me',
+            ]);
+            missing = staleCacheMissingToken(index, operands);
+        }
+        catch {
+            // Conservative: any hiccup in the pre-parse means we keep the cache.
+        }
+        if (missing) {
+            debug(`'${missing}' is not in the cached command tree — bypassing the ` +
+                'tools cache and refetching the manifest (stale-cache self-heal)');
+            staleFallbackTools = tools;
+            tools = null;
+        }
+    }
     if (tools) {
         debug(`Loaded ${tools.length} tools from cache`);
     }
@@ -2475,12 +2592,18 @@ async function main() {
             debug('No API key available, skipping tool fetch');
         }
     }
+    // Self-heal refetch failed (network/auth): fall back to the stale cache
+    // so this invocation still registers every previously known command.
+    if (!tools && staleFallbackTools) {
+        debug('Manifest refetch failed — falling back to the cached (possibly ' +
+            'stale) command tree');
+        tools = staleFallbackTools;
+    }
     // Register dynamic tool commands
     // Skip phone_call — the hardcoded `phone-call` command (dial default
     // subcommand) handles dialing with streaming UX the generic handler lacks.
     // Hide the `vd` subcommand group entirely unless the user has opted in
     // via config.vd_project_id or GSK_VD_PROJECT_ID env var.
-    const vdProjectId = resolveVdProjectId();
     if (tools) {
         for (const tool of tools) {
             if (tool.name === 'phone_call')