@machina.ai/cell-cli 1.36.0-rc1 → 1.38.1-rc1

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env -S node --no-warnings=DEP0040
+#!/usr/bin/env node
 /**
  * @license
  * Copyright 2025 Google LLC

package/dist/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env -S node --no-warnings=DEP0040
+#!/usr/bin/env node
 /**
  * @license
  * Copyright 2025 Google LLC

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@machina.ai/cell-cli",
-  "version": "1.36.0-rc1",
+  "version": "1.38.1-rc1",
   "description": "Cell CLI",
   "repository": {
     "type": "git",
@@ -15,11 +15,11 @@
     ""
   ],
   "config": {
-    "sandboxImageUri": "us-docker.pkg.dev/gemini-code-dev/gemini-cli/sandbox:0.36.0"
+    "sandboxImageUri": "us-docker.pkg.dev/gemini-code-dev/gemini-cli/sandbox:0.38.1"
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "^0.16.1",
-    "@google/gemini-cli-core": "npm:@machina.ai/cell-cli-core@1.36.0-rc1",
+    "@google/gemini-cli-core": "npm:@machina.ai/cell-cli-core@1.38.1-rc1",
     "@google/genai": "1.30.0",
     "@iarna/toml": "^2.2.5",
     "@machina.ai/api-proxy": "1.18.4-rc0",
@@ -40,7 +40,7 @@
     "fzf": "^0.5.2",
     "glob": "^12.0.0",
     "highlight.js": "^11.11.1",
-    "ink": "npm:@jrichman/ink@6.6.3",
+    "ink": "npm:@jrichman/ink@6.6.7",
     "ink-gradient": "^3.0.0",
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",

package/dist/src/acp/acpClient.js

@@ -3,7 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { CoreToolCallStatus, AuthType, logToolCall, convertToFunctionResponse, ToolConfirmationOutcome, clearCachedCredentialFile, isNodeError, getErrorMessage, isWithinRoot, getErrorStatus, MCPServerConfig, DiscoveredMCPTool, StreamEventType, ToolCallEvent, debugLogger, ReadManyFilesTool, REFERENCE_CONTENT_START, resolveModel, createWorkingStdio, startupProfiler, Kind, partListUnionToString, LlmRole, ApprovalMode, getVersion, convertSessionToClientHistory, DEFAULT_GEMINI_MODEL, DEFAULT_GEMINI_FLASH_MODEL, DEFAULT_GEMINI_FLASH_LITE_MODEL, PREVIEW_GEMINI_MODEL, PREVIEW_GEMINI_3_1_MODEL, PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL, PREVIEW_GEMINI_FLASH_MODEL, DEFAULT_GEMINI_MODEL_AUTO, PREVIEW_GEMINI_MODEL_AUTO, getDisplayString, } from '@google/gemini-cli-core';
+import { CoreToolCallStatus, AuthType, logToolCall, convertToFunctionResponse, ToolConfirmationOutcome, clearCachedCredentialFile, isNodeError, getErrorMessage, isWithinRoot, getErrorStatus, MCPServerConfig, DiscoveredMCPTool, StreamEventType, ToolCallEvent, debugLogger, ReadManyFilesTool, REFERENCE_CONTENT_START, createWorkingStdio, startupProfiler, Kind, partListUnionToString, LlmRole, ApprovalMode, getVersion, convertSessionToClientHistory, DEFAULT_GEMINI_MODEL, DEFAULT_GEMINI_FLASH_MODEL, DEFAULT_GEMINI_FLASH_LITE_MODEL, PREVIEW_GEMINI_MODEL, PREVIEW_GEMINI_3_1_MODEL, PREVIEW_GEMINI_3_1_FLASH_LITE_MODEL, PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL, PREVIEW_GEMINI_FLASH_MODEL, DEFAULT_GEMINI_MODEL_AUTO, PREVIEW_GEMINI_MODEL_AUTO, getDisplayString, processSingleFileContent, InvalidStreamError, updatePolicy, } from '@google/gemini-cli-core';
 import * as acp from '@agentclientprotocol/sdk';
 import { AcpFileSystemService } from './fileSystemService.js';
 import { getAcpErrorMessage } from './acpErrors.js';
@@ -12,6 +12,7 @@ function hasMeta(obj) {
     return typeof obj === 'object' && obj !== null && '_meta' in obj;
 }
 import { SettingScope, loadSettings, } from '../config/settings.js';
+import { createPolicyUpdater } from '../config/policy.js';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { z } from 'zod';
@@ -20,6 +21,15 @@ import { loadCliConfig } from '../config/config.js';
 import { runExitCleanup } from '../utils/cleanup.js';
 import { SessionSelector } from '../utils/sessionUtils.js';
 import { CommandHandler } from './commandHandler.js';
+const RequestPermissionResponseSchema = z.object({
+    outcome: z.discriminatedUnion('outcome', [
+        z.object({ outcome: z.literal('cancelled') }),
+        z.object({
+            outcome: z.literal('selected'),
+            optionId: z.string(),
+        }),
+    ]),
+});
 export async function runAcpClient(config, settings, argv) {
     // ... (skip unchanged lines) ...
     const { stdout: workingStdout } = createWorkingStdio();
@@ -302,6 +312,7 @@ export class GeminiAgent {
             mcpServers: mergedMcpServers,
         };
         const config = await loadCliConfig(settings, sessionId, this.argv, { cwd });
+        createPolicyUpdater(config.getPolicyEngine(), config.messageBus, config.storage);
         return config;
     }
     async cancel(params) {
@@ -504,7 +515,14 @@ export class Session {
             }
             const functionCalls = [];
             try {
-                const model = resolveModel(this.context.config.getModel(), (await this.context.config.getGemini31Launched?.()) ?? false);
+                const routingContext = {
+                    history: chat.getHistory(/*curated=*/ true),
+                    request: nextMessage?.parts ?? [],
+                    signal: pendingSend.signal,
+                    requestedModel: this.context.config.getModel(),
+                };
+                const router = this.context.config.getModelRouterService();
+                const { model } = await router.route(routingContext);
                 const responseStream = await chat.sendMessageStream({ model }, nextMessage?.parts ?? [], promptId, pendingSend.signal, LlmRole.MAIN);
                 nextMessage = null;
                 let turnInputTokens = 0;
@@ -571,6 +589,35 @@ export class Session {
                     (error instanceof Error && error.name === 'AbortError')) {
                     return { stopReason: CoreToolCallStatus.Cancelled };
                 }
+                if (error instanceof InvalidStreamError ||
+                    (error &&
+                        typeof error === 'object' &&
+                        'type' in error &&
+                        (error.type === 'NO_RESPONSE_TEXT' ||
+                            error.type === 'NO_FINISH_REASON' ||
+                            error.type === 'MALFORMED_FUNCTION_CALL' ||
+                            error.type === 'UNEXPECTED_TOOL_CALL'))) {
+                    // The stream ended with an empty response or malformed tool call.
+                    // Treat this as a graceful end to the model's turn rather than a crash.
+                    return {
+                        stopReason: 'end_turn',
+                        _meta: {
+                            quota: {
+                                token_count: {
+                                    input_tokens: totalInputTokens,
+                                    output_tokens: totalOutputTokens,
+                                },
+                                model_usage: Array.from(modelUsageMap.entries()).map(([modelName, counts]) => ({
+                                    model: modelName,
+                                    token_count: {
+                                        input_tokens: counts.input,
+                                        output_tokens: counts.output,
+                                    },
+                                })),
+                            },
+                        },
+                    };
+                }
                 throw new acp.RequestError(getErrorStatus(error) || 500, getAcpErrorMessage(error));
             }
             if (functionCalls.length > 0) {
@@ -687,7 +734,7 @@ export class Session {
                 }
                 const params = {
                     sessionId: this.id,
-                    options: toPermissionOptions(confirmationDetails, this.context.config),
+                    options: toPermissionOptions(confirmationDetails, this.context.config, this.settings.merged.security.enablePermanentToolApproval),
                     toolCall: {
                         toolCallId: callId,
                         status: 'pending',
@@ -697,14 +744,15 @@ export class Session {
                         kind: toAcpToolKind(tool.kind),
                     },
                 };
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                const output = await this.connection.requestPermission(params);
-                const outcome = output.outcome.outcome === CoreToolCallStatus.Cancelled
+                const output = RequestPermissionResponseSchema.parse(await this.connection.requestPermission(params));
+                const outcome = output.outcome.outcome === 'cancelled'
                     ? ToolConfirmationOutcome.Cancel
                     : z
                         .nativeEnum(ToolConfirmationOutcome)
                         .parse(output.outcome.optionId);
                 await confirmationDetails.onConfirm(outcome);
+                // Update policy to enable Always Allow persistence
+                await updatePolicy(tool, outcome, confirmationDetails, this.context, this.context.messageBus, invocation);
                 switch (outcome) {
                     case ToolConfirmationOutcome.Cancel:
                         return errorResponse(new Error(`Tool "${fc.name}" was canceled by the user.`));
@@ -864,6 +912,7 @@ export class Session {
         const pathSpecsToRead = [];
         const contentLabelsForDisplay = [];
         const ignoredPaths = [];
+        const directContents = [];
         const toolRegistry = this.context.toolRegistry;
         const readManyFilesTool = new ReadManyFilesTool(this.context.config, this.context.messageBus);
         const globTool = toolRegistry.getTool('glob');
@@ -880,23 +929,160 @@ export class Session {
             }
             let currentPathSpec = pathName;
             let resolvedSuccessfully = false;
+            let readDirectly = false;
             try {
                 const absolutePath = path.resolve(this.context.config.getTargetDir(), pathName);
-                if (isWithinRoot(absolutePath, this.context.config.getTargetDir())) {
-                    const stats = await fs.stat(absolutePath);
-                    if (stats.isDirectory()) {
-                        currentPathSpec = pathName.endsWith('/')
-                            ? `${pathName}**`
-                            : `${pathName}/**`;
-                        this.debug(`Path ${pathName} resolved to directory, using glob: ${currentPathSpec}`);
+                let validationError = this.context.config.validatePathAccess(absolutePath, 'read');
+                // We ask the user for explicit permission to read them if outside sandboxed workspace boundaries (and not already authorized).
+                if (validationError &&
+                    !isWithinRoot(absolutePath, this.context.config.getTargetDir())) {
+                    try {
+                        const stats = await fs.stat(absolutePath);
+                        if (stats.isFile()) {
+                            const syntheticCallId = `resolve-prompt-${pathName}-${randomUUID()}`;
+                            const params = {
+                                sessionId: this.id,
+                                options: [
+                                    {
+                                        optionId: ToolConfirmationOutcome.ProceedOnce,
+                                        name: 'Allow once',
+                                        kind: 'allow_once',
+                                    },
+                                    {
+                                        optionId: ToolConfirmationOutcome.Cancel,
+                                        name: 'Deny',
+                                        kind: 'reject_once',
+                                    },
+                                ],
+                                toolCall: {
+                                    toolCallId: syntheticCallId,
+                                    status: 'pending',
+                                    title: `Allow access to absolute path: ${pathName}`,
+                                    content: [
+                                        {
+                                            type: 'content',
+                                            content: {
+                                                type: 'text',
+                                                text: `The Agent needs access to read an attached file outside your workspace: ${pathName}`,
+                                            },
+                                        },
+                                    ],
+                                    locations: [],
+                                    kind: 'read',
+                                },
+                            };
+                            const output = RequestPermissionResponseSchema.parse(await this.connection.requestPermission(params));
+                            const outcome = output.outcome.outcome === 'cancelled'
+                                ? ToolConfirmationOutcome.Cancel
+                                : z
+                                    .nativeEnum(ToolConfirmationOutcome)
+                                    .parse(output.outcome.optionId);
+                            if (outcome === ToolConfirmationOutcome.ProceedOnce) {
+                                this.context.config
+                                    .getWorkspaceContext()
+                                    .addReadOnlyPath(absolutePath);
+                                validationError = null;
+                            }
+                            else {
+                                this.debug(`Direct read authorization denied for absolute path ${pathName}`);
+                                directContents.push({
+                                    spec: pathName,
+                                    content: `[Warning: Access to absolute path \`${pathName}\` denied by user.]`,
+                                });
+                                continue;
+                            }
+                        }
                     }
-                    else {
-                        this.debug(`Path ${pathName} resolved to file: ${currentPathSpec}`);
+                    catch (error) {
+                        this.debug(`Failed to request permission for absolute attachment ${pathName}: ${getErrorMessage(error)}`);
+                        await this.sendUpdate({
+                            sessionUpdate: 'agent_thought_chunk',
+                            content: {
+                                type: 'text',
+                                text: `Warning: Failed to display permission dialog for \`${absolutePath}\`. Error: ${getErrorMessage(error)}`,
+                            },
+                        });
+                    }
+                }
+                if (!validationError) {
+                    // If it's an absolute path that is authorized (e.g. added via readOnlyPaths),
+                    // read it directly to avoid ReadManyFilesTool absolute path resolution issues.
+                    if ((path.isAbsolute(pathName) ||
+                        !isWithinRoot(absolutePath, this.context.config.getTargetDir())) &&
+                        !readDirectly) {
+                        try {
+                            const stats = await fs.stat(absolutePath);
+                            if (stats.isFile()) {
+                                const fileReadResult = await processSingleFileContent(absolutePath, this.context.config.getTargetDir(), this.context.config.getFileSystemService());
+                                if (!fileReadResult.error) {
+                                    if (typeof fileReadResult.llmContent === 'object' &&
+                                        'inlineData' in fileReadResult.llmContent) {
+                                        directContents.push({
+                                            spec: pathName,
+                                            part: fileReadResult.llmContent,
+                                        });
+                                    }
+                                    else if (typeof fileReadResult.llmContent === 'string') {
+                                        let contentToPush = fileReadResult.llmContent;
+                                        if (fileReadResult.isTruncated) {
+                                            contentToPush = `[WARNING: This file was truncated]\n\n${contentToPush}`;
+                                        }
+                                        directContents.push({
+                                            spec: pathName,
+                                            content: contentToPush,
+                                        });
+                                    }
+                                    readDirectly = true;
+                                    resolvedSuccessfully = true;
+                                }
+                                else {
+                                    this.debug(`Direct read failed for absolute path ${pathName}: ${fileReadResult.error}`);
+                                    await this.sendUpdate({
+                                        sessionUpdate: 'agent_thought_chunk',
+                                        content: {
+                                            type: 'text',
+                                            text: `Warning: file read failed for \`${pathName}\`. Reason: ${fileReadResult.error}`,
+                                        },
+                                    });
+                                    continue;
+                                }
+                            }
+                        }
+                        catch (error) {
+                            this.debug(`File stat/access error for absolute path ${pathName}: ${getErrorMessage(error)}`);
+                            await this.sendUpdate({
+                                sessionUpdate: 'agent_thought_chunk',
+                                content: {
+                                    type: 'text',
+                                    text: `Warning: file access failed for \`${pathName}\`. Reason: ${getErrorMessage(error)}`,
+                                },
+                            });
+                            continue;
+                        }
+                    }
+                    if (!readDirectly) {
+                        const stats = await fs.stat(absolutePath);
+                        if (stats.isDirectory()) {
+                            currentPathSpec = pathName.endsWith('/')
+                                ? `${pathName}**`
+                                : `${pathName}/**`;
+                            this.debug(`Path ${pathName} resolved to directory, using glob: ${currentPathSpec}`);
+                        }
+                        else {
+                            this.debug(`Path ${pathName} resolved to file: ${currentPathSpec}`);
+                        }
+                        resolvedSuccessfully = true;
                     }
-                    resolvedSuccessfully = true;
                 }
                 else {
-                    this.debug(`Path ${pathName} is outside the project directory. Skipping.`);
+                    this.debug(`Path ${pathName} access disallowed: ${validationError}. Skipping.`);
+                    await this.sendUpdate({
+                        sessionUpdate: 'agent_thought_chunk',
+                        content: {
+                            type: 'text',
+                            text: `Warning: skipping access to \`${pathName}\`. Reason: ${validationError}`,
+                        },
+                    });
                 }
             }
             catch (error) {
@@ -940,7 +1126,9 @@ export class Session {
                 }
             }
             if (resolvedSuccessfully) {
-                pathSpecsToRead.push(currentPathSpec);
+                if (!readDirectly) {
+                    pathSpecsToRead.push(currentPathSpec);
+                }
                 atPathToResolvedSpecMap.set(pathName, currentPathSpec);
                 contentLabelsForDisplay.push(pathName);
             }
@@ -991,7 +1179,9 @@ export class Session {
             this.debug(`Ignored ${ignoredPaths.length} files: ${ignoredPaths.join(', ')}`);
         }
         const processedQueryParts = [{ text: initialQueryText }];
-        if (pathSpecsToRead.length === 0 && embeddedContext.length === 0) {
+        if (pathSpecsToRead.length === 0 &&
+            embeddedContext.length === 0 &&
+            directContents.length === 0) {
             // Fallback for lone "@" or completely invalid @-commands resulting in empty initialQueryText
             debugLogger.warn('No valid file paths found in @ commands to read.');
             return [{ text: initialQueryText }];
@@ -1078,6 +1268,27 @@ export class Session {
                 throw error;
             }
         }
+        if (directContents.length > 0) {
+            const hasReferenceStart = processedQueryParts.some((p) => 'text' in p &&
+                typeof p.text === 'string' &&
+                p.text.includes(REFERENCE_CONTENT_START));
+            if (!hasReferenceStart) {
+                processedQueryParts.push({
+                    text: `\n${REFERENCE_CONTENT_START}`,
+                });
+            }
+            for (const item of directContents) {
+                processedQueryParts.push({
+                    text: `\nContent from @${item.spec}:\n`,
+                });
+                if (item.content) {
+                    processedQueryParts.push({ text: item.content });
+                }
+                else if (item.part) {
+                    processedQueryParts.push(item.part);
+                }
+            }
+        }
         if (embeddedContext.length > 0) {
             processedQueryParts.push({
                 text: '\n--- Content from referenced context ---',
@@ -1156,7 +1367,7 @@ const basicPermissionOptions = [
         kind: 'reject_once',
     },
 ];
-function toPermissionOptions(confirmation, config) {
+function toPermissionOptions(confirmation, config, enablePermanentToolApproval = false) {
     const disableAlwaysAllow = config.getDisableAlwaysAllow();
     const options = [];
     if (!disableAlwaysAllow) {
@@ -1164,34 +1375,62 @@ function toPermissionOptions(confirmation, config) {
             case 'edit':
                 options.push({
                     optionId: ToolConfirmationOutcome.ProceedAlways,
-                    name: 'Allow All Edits',
+                    name: 'Allow for this session',
                     kind: 'allow_always',
                 });
+                if (enablePermanentToolApproval) {
+                    options.push({
+                        optionId: ToolConfirmationOutcome.ProceedAlwaysAndSave,
+                        name: 'Allow for this file in all future sessions',
+                        kind: 'allow_always',
+                    });
+                }
                 break;
             case 'exec':
                 options.push({
                     optionId: ToolConfirmationOutcome.ProceedAlways,
-                    name: `Always Allow ${confirmation.rootCommand}`,
+                    name: 'Allow for this session',
                     kind: 'allow_always',
                 });
+                if (enablePermanentToolApproval) {
+                    options.push({
+                        optionId: ToolConfirmationOutcome.ProceedAlwaysAndSave,
+                        name: 'Allow this command for all future sessions',
+                        kind: 'allow_always',
+                    });
+                }
                 break;
             case 'mcp':
                 options.push({
                     optionId: ToolConfirmationOutcome.ProceedAlwaysServer,
-                    name: `Always Allow ${confirmation.serverName}`,
+                    name: 'Allow all server tools for this session',
                     kind: 'allow_always',
                 }, {
                     optionId: ToolConfirmationOutcome.ProceedAlwaysTool,
-                    name: `Always Allow ${confirmation.toolName}`,
+                    name: 'Allow tool for this session',
                     kind: 'allow_always',
                 });
+                if (enablePermanentToolApproval) {
+                    options.push({
+                        optionId: ToolConfirmationOutcome.ProceedAlwaysAndSave,
+                        name: 'Allow tool for all future sessions',
+                        kind: 'allow_always',
+                    });
+                }
                 break;
             case 'info':
                 options.push({
                     optionId: ToolConfirmationOutcome.ProceedAlways,
-                    name: `Always Allow`,
+                    name: 'Allow for this session',
                     kind: 'allow_always',
                 });
+                if (enablePermanentToolApproval) {
+                    options.push({
+                        optionId: ToolConfirmationOutcome.ProceedAlwaysAndSave,
+                        name: 'Allow for all future sessions',
+                        kind: 'allow_always',
+                    });
+                }
                 break;
             case 'ask_user':
             case 'exit_plan_mode':
@@ -1276,8 +1515,24 @@ function buildAvailableModels(config, settings) {
     const preferredModel = config.getModel() || DEFAULT_GEMINI_MODEL_AUTO;
     const shouldShowPreviewModels = config.getHasAccessToPreviewModel();
     const useGemini31 = config.getGemini31LaunchedSync?.() ?? false;
+    const useGemini31FlashLite = config.getGemini31FlashLiteLaunchedSync?.() ?? false;
     const selectedAuthType = settings.merged.security.auth.selectedType;
     const useCustomToolModel = useGemini31 && selectedAuthType === AuthType.USE_GEMINI;
+    // --- DYNAMIC PATH ---
+    if (config.getExperimentalDynamicModelConfiguration?.() === true &&
+        config.getModelConfigService) {
+        const options = config.getModelConfigService().getAvailableModelOptions({
+            useGemini3_1: useGemini31,
+            useGemini3_1FlashLite: useGemini31FlashLite,
+            useCustomTools: useCustomToolModel,
+            hasAccessToPreview: shouldShowPreviewModels,
+        });
+        return {
+            availableModels: options,
+            currentModelId: preferredModel,
+        };
+    }
+    // --- LEGACY PATH ---
     const mainOptions = [
         {
             value: DEFAULT_GEMINI_MODEL_AUTO,
@@ -1315,13 +1570,23 @@ function buildAvailableModels(config, settings) {
         const previewProValue = useCustomToolModel
             ? PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL
             : previewProModel;
-        manualOptions.unshift({
-            value: previewProValue,
-            title: getDisplayString(previewProModel),
-        }, {
-            value: PREVIEW_GEMINI_FLASH_MODEL,
-            title: getDisplayString(PREVIEW_GEMINI_FLASH_MODEL),
-        });
+        const previewOptions = [
+            {
+                value: previewProValue,
+                title: getDisplayString(previewProModel),
+            },
+            {
+                value: PREVIEW_GEMINI_FLASH_MODEL,
+                title: getDisplayString(PREVIEW_GEMINI_FLASH_MODEL),
+            },
+        ];
+        if (useGemini31FlashLite) {
+            previewOptions.push({
+                value: PREVIEW_GEMINI_3_1_FLASH_LITE_MODEL,
+                title: getDisplayString(PREVIEW_GEMINI_3_1_FLASH_LITE_MODEL),
+            });
+        }
+        manualOptions.unshift(...previewOptions);
     }
     const scaleOptions = (options) => options.map((o) => ({
         modelId: o.value,