@greppleai/grip 0.1.6 → 0.1.7

package/dist/core/agent-session.js

@@ -15,12 +15,15 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { readFile as fsReadFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, dirname, posix, sep, win32 } from "node:path";
 import { clampThinkingLevel, cleanupSessionResources, getSupportedThinkingLevels, isContextOverflow, isRetryableAssistantError, modelsAreEqual, resetApiProviders, streamSimple, validateToolArguments, } from "@greppleai/grip-ai";
 import { Text } from "@greppleai/grip-tui";
 import { Type } from "typebox";
+import { keyText } from "../modes/interactive/components/keybinding-hints.js";
 import { theme } from "../modes/interactive/theme/theme.js";
+import { getSandboxDirectoryCompletions } from "../utils/directory-completions.js";
 import { stripFrontmatter } from "../utils/frontmatter.js";
 import { canonicalizePath, resolvePath } from "../utils/paths.js";
 import { sleep } from "../utils/sleep.js";
@@ -32,6 +35,7 @@ import { appendCompressionDetectionEvent, readCompressionDetectionLedger, } from
 import { CompressionDetector, } from "./compaction/compression-detector.js";
 import { COMPRESSION_ECONOMICS_ENTRY_TYPE, COMPRESSION_SAVINGS_SNAPSHOT_TYPE, createCompressionSavingsSnapshot, estimateCompressionEconomics, } from "./compaction/compression-economics.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
+import { execCommand } from "./exec.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
 import { ExtensionRunner, emitSessionShutdownEvent, } from "./extensions/runner.js";
@@ -55,6 +59,7 @@ import { buildSystemPrompt } from "./system-prompt.js";
 import { createLocalBashOperations } from "./tools/bash.js";
 import { createCompressContextToolDefinition, getCompressibleEntries, getSuggestedCompressionRangeError, isValidSuggestedCompressionRange, } from "./tools/compress-context.js";
 import { DeferredRemoteToolOperations, LocalToolOperations, } from "./tools/operations.js";
+import { getTextOutput } from "./tools/render-utils.js";
 import { createSessionEntryGetToolDefinition, createSessionSearchToolDefinition } from "./tools/session-history.js";
 import { createCreateSubagentToolDefinition, createSubagentRunsToolDefinition, createSubagentToolDefinition, formatSubagentModelCatalog, } from "./tools/subagent.js";
 import { createToolDefinitionFromAgentTool } from "./tools/tool-definition-wrapper.js";
@@ -63,7 +68,7 @@ import { WORKSPACE_TOOL_NAMES, WorkspaceToolHost } from "./tools/workspace-tool-
 // ============================================================================
 // Skill Block Parsing
 // ============================================================================
-const CORE_DEFAULT_TOOL_NAMES = ["read", "bash", "edit", "write", "websearch"];
+const CORE_DEFAULT_TOOL_NAMES = ["read", "bash", "edit", "write", "websearch", "load_skill"];
 const SESSION_HISTORY_TOOL_NAMES = ["session_search", "session_entry_get"];
 export const SUBAGENT_TOOL_NAMES = ["subagent", "subagent_runs", "create_subagent"];
 export const DEFAULT_ACTIVE_TOOL_NAMES = [...CORE_DEFAULT_TOOL_NAMES, ...SESSION_HISTORY_TOOL_NAMES];
@@ -388,6 +393,11 @@ function isWithinSandboxMount(directory, root, flavor) {
     const relativePath = paths.relative(root, directory);
     return relativePath !== ".." && !relativePath.startsWith(`..${paths.sep}`) && !paths.isAbsolute(relativePath);
 }
+function hasValidHostProcessApproval(options) {
+    return (typeof options?.question === "string" &&
+        !!options.question.trim() &&
+        (options.explanation === undefined || (typeof options.explanation === "string" && !!options.explanation.trim())));
+}
 export class AgentSession {
     constructor(config) {
         this._eventListeners = [];
@@ -422,6 +432,7 @@ export class AgentSession {
         this._activities = new Set();
         this._activityGeneration = 0;
         this._activeCycle = false;
+        this._hostCommandApprovalQueue = Promise.resolve();
         this._settlementScheduled = false;
         this._settlementRunning = false;
         this._idleWaiters = new Set();
@@ -598,6 +609,11 @@ export class AgentSession {
     getToolBackendInfo() {
         return this.getToolOperations().getBackendInfo?.() ?? { type: "local", cwd: this._cwd };
     }
+    /** Whether the current session is using a live, session-owned sandbox connection. */
+    isSandbox() {
+        const operations = this._sandboxToolOperations;
+        return !!operations && operations === this._toolOperations && !operations.isDisconnected();
+    }
     supportsDirectoryChange() {
         return this._toolOperations === undefined && this.getToolBackendInfo().type === "local";
     }
@@ -668,7 +684,19 @@ export class AgentSession {
         }));
     }
     async activateSandboxDaemon(options) {
-        return this._runActivity("sandbox daemon activation", () => this._enqueueSandboxTransition(() => this._activateSessionRemoteOperations(options.expectedCwd, (operations) => operations.configureRemote(options.url, { token: options.token, expectedCwd: options.expectedCwd }))));
+        return this._runActivity("sandbox daemon activation", () => this._enqueueSandboxTransition(() => this._activateSessionRemoteOperations(options.expectedCwd, (operations) => operations.configureRemote(options.url, {
+            token: options.token,
+            expectedCwd: options.expectedCwd,
+            hostWorkspaceRoot: options.hostWorkspaceRoot,
+        }))));
+    }
+    /** Complete only directories available inside the connected sandbox's mounted workspace. */
+    async getSandboxDirectoryCompletions(prefix) {
+        const operations = this._sandboxToolOperations;
+        const backend = operations?.getBackendInfo();
+        if (!operations || operations !== this._toolOperations || backend?.type !== "remote" || !backend.configured)
+            return [];
+        return getSandboxDirectoryCompletions(prefix, operations.cwd, backend.workspace.pathFlavor, operations);
     }
     /** Change only the connected sandbox's working directory, never the host session or mount. */
     async changeSandboxWorkingDirectory(target) {
@@ -4069,6 +4097,7 @@ export class AgentSession {
             getSystemPrompt: () => this.systemPrompt,
             getToolOperations,
             getToolBackendInfo: () => this.getToolBackendInfo(),
+            isSandbox: () => this.isSandbox(),
             getLspStatus: getBoundLspStatus,
             configureLsp: (configuration) => {
                 if (runner !== this._extensionRunner)
@@ -4081,6 +4110,20 @@ export class AgentSession {
                 const resolvedCommand = prefix ? `${prefix}\n${command}` : command;
                 return executeBashWithOperations(resolvedCommand, options?.cwd ?? operations.cwd, operations, options);
             }),
+            execHostCommand: (command, options) => {
+                const execute = () => this._runActivity("extension host command approval", () => this._executeApprovedHostCommand(runner, command, options));
+                const pending = this._hostCommandApprovalQueue.then(execute, execute);
+                this._hostCommandApprovalQueue = pending.then(() => undefined, () => undefined);
+                return pending;
+            },
+            execHostProcess: (executable, args, options) => {
+                const argv = Array.isArray(args) ? [...args] : args;
+                const request = { ...options };
+                const execute = () => this._runActivity("extension host process approval", () => this._executeApprovedHostProcess(runner, executable, argv, request));
+                const pending = this._hostCommandApprovalQueue.then(execute, execute);
+                this._hostCommandApprovalQueue = pending.then(() => undefined, () => undefined);
+                return pending;
+            },
         }, {
             registerProvider: (name, config) => {
                 this._modelRegistry.registerProvider(name, config);
@@ -4092,6 +4135,132 @@ export class AgentSession {
             },
         });
     }
+    async _executeApprovedHostCommand(runner, command, options) {
+        if (runner !== this._extensionRunner)
+            throw new Error(STALE_EXTENSION_CONTEXT_MESSAGE);
+        if (typeof command !== "string" ||
+            !command.trim() ||
+            typeof options?.question !== "string" ||
+            !options.question.trim()) {
+            throw new Error("Host command and approval question must be non-empty strings");
+        }
+        const operations = this._sandboxToolOperations;
+        if (!operations || operations !== this._toolOperations || operations.isDisconnected()) {
+            throw new Error("A connected sandbox is required for approved host commands");
+        }
+        if (!runner.hasUI())
+            throw new Error("Host command requires an interactive approval UI");
+        const signal = options.signal ?? this.agent.signal;
+        if (signal?.aborted)
+            throw new Error("Host command cancelled");
+        const hostCwd = await operations.mapWorkspaceDirectoryToHost(options.cwd ?? operations.cwd);
+        const choice = await runner
+            .getUIContext()
+            .select(`Run on host?\nReason: ${JSON.stringify(options.question)}\nCommand: ${JSON.stringify(command)}\nHost cwd: ${JSON.stringify(hostCwd)}`, ["No", "Yes"], { signal });
+        if (choice !== "Yes" || signal?.aborted)
+            throw new Error("Host command was not approved");
+        if (runner !== this._extensionRunner ||
+            operations !== this._sandboxToolOperations ||
+            operations.isDisconnected()) {
+            throw new Error("Sandbox changed before the host command could run");
+        }
+        return executeBashWithOperations(command, hostCwd, new LocalToolOperations(hostCwd), { ...options, signal });
+    }
+    async _executeApprovedHostProcess(runner, executable, args, options) {
+        if (runner !== this._extensionRunner)
+            throw new Error(STALE_EXTENSION_CONTEXT_MESSAGE);
+        if (typeof executable !== "string" ||
+            !executable.trim() ||
+            executable.includes("\0") ||
+            !Array.isArray(args) ||
+            args.some((arg) => typeof arg !== "string" || arg.includes("\0")) ||
+            !hasValidHostProcessApproval(options)) {
+            throw new Error("Host executable, argv and approval question must be valid strings");
+        }
+        const operations = this._sandboxToolOperations;
+        if (!operations || operations !== this._toolOperations || operations.isDisconnected()) {
+            throw new Error("A connected sandbox is required for approved host processes");
+        }
+        if (!runner.hasUI())
+            throw new Error("Host process requires an interactive approval UI");
+        const signal = options.signal ?? this.agent.signal;
+        if (signal?.aborted)
+            throw new Error("Host process cancelled");
+        const hostCwd = await operations.mapWorkspaceDirectoryToHost(options.cwd ?? operations.cwd);
+        const explanation = options.explanation === undefined ? "" : `\nExplanation (unverified): ${JSON.stringify(options.explanation)}`;
+        const choice = await runner
+            .getUIContext()
+            .select(`Run on host (no shell)?\nReason: ${JSON.stringify(options.question)}${explanation}\nExecutable: ${JSON.stringify(executable)}\nArguments: ${JSON.stringify(args)}\nHost cwd: ${JSON.stringify(hostCwd)}`, ["No", "Yes"], { signal });
+        if (choice !== "Yes" || signal?.aborted)
+            throw new Error("Host process was not approved");
+        if (runner !== this._extensionRunner ||
+            operations !== this._sandboxToolOperations ||
+            operations.isDisconnected()) {
+            throw new Error("Sandbox changed before the host process could run");
+        }
+        return execCommand(executable, args, hostCwd, { signal, timeout: options.timeout });
+    }
+    _createLoadSkillToolDefinition() {
+        const parameters = Type.Object({
+            name: Type.Union([Type.String(), Type.Array(Type.String())], {
+                description: "Name of a listed skill, or an array of skill names to load in one call",
+            }),
+        });
+        return {
+            name: "load_skill",
+            label: "Load skill",
+            description: "Load the full instructions for one or more available skills by name. Use the reported skill directory to resolve relative references. Hidden skills and unknown names are not available.",
+            promptSnippet: "Load instructions for available skills by name (or an array of names)",
+            parameters,
+            renderCall: (args, renderTheme, context) => {
+                const names = getToolNameArgs(args);
+                const expandKey = keyText("app.tools.expand");
+                const hint = !context.expanded && expandKey ? renderTheme.fg("dim", ` (${expandKey} to expand)`) : "";
+                return new Text(renderTheme.fg("customMessageLabel", `\x1b[1m[skill]\x1b[22m `) +
+                    renderTheme.fg("customMessageText", names.join(", ")) +
+                    hint, 0, 0);
+            },
+            renderResult: (result, options, renderTheme, context) => {
+                const output = options.expanded || context.isError ? getTextOutput(result, context.showImages) : "";
+                return new Text(output ? `\n${renderTheme.fg(context.isError ? "error" : "toolOutput", output)}` : "", 0, 0);
+            },
+            executionMode: "sequential",
+            execute: async (_toolCallId, params, signal) => {
+                if (signal?.aborted)
+                    throw new Error("Skill load cancelled");
+                const names = [...new Set(Array.isArray(params.name) ? params.name : [params.name])];
+                if (names.length === 0 || names.some((name) => !name))
+                    throw new Error("Specify at least one skill name");
+                const availableSkills = new Map(this.getRegisteredSkills()
+                    .filter((skill) => !skill.disableModelInvocation)
+                    .map((skill) => [skill.name, skill]));
+                const missing = names.filter((name) => !availableSkills.has(name));
+                if (missing.length > 0)
+                    throw new Error(`Skill not available: ${missing.join(", ")}`);
+                const skills = names.map((name) => availableSkills.get(name));
+                const content = await Promise.all(skills.map(async (skill) => {
+                    let text = skill.content;
+                    if (text === undefined && getSourceBackend(skill.sourceInfo) === "remote") {
+                        if (this.getToolBackendInfo().type !== "remote")
+                            throw new Error(`Remote skill not available: ${skill.name}`);
+                        text = (await this.getToolOperations().readFile(skill.filePath)).toString("utf-8");
+                    }
+                    else if (text === undefined) {
+                        text = await fsReadFile(resolvePath(skill.filePath, this._cwd), "utf-8");
+                    }
+                    return {
+                        type: "text",
+                        text: `Skill: ${JSON.stringify(skill.name)}\nSkill directory: ${JSON.stringify(skill.baseDir)}\nFile: ${JSON.stringify(skill.filePath)}\n\n${text}`,
+                    };
+                }));
+                if (signal?.aborted)
+                    throw new Error("Skill load cancelled");
+                for (const skill of skills)
+                    this._loadAssociatedInstructionTools(skill);
+                return { content, details: { names } };
+            },
+        };
+    }
     _createLoadToolDefinition() {
         const parameters = Type.Object({
             name: Type.Union([Type.String(), Type.Array(Type.String())], {
@@ -4442,6 +4611,7 @@ export class AgentSession {
             const baseToolDefinitions = this._createRuntimeBaseToolDefinitions(workspaceToolHost);
             this._baseToolDefinitions = new Map(Object.entries(baseToolDefinitions));
             this._initializeRuntimeLsp(operations);
+            this._baseToolDefinitions.set("load_skill", this._createLoadSkillToolDefinition());
             this._baseToolDefinitions.set("load_tool", this._createLoadToolDefinition());
             this._baseToolDefinitions.set("unload_tool", this._createUnloadToolDefinition());
             const extensionsResult = this._resourceLoader.getExtensions();