@greppleai/grip 0.0.1 → 0.1.4

package/dist/modes/interactive/interactive-mode.js

@@ -21,7 +21,7 @@ import { defaultModelPerProvider, findExactModelReferenceMatch, resolveModelScop
 import { DefaultPackageManager } from "../../core/package-manager.js";
 import { BUILT_IN_PROVIDER_DISPLAY_NAMES } from "../../core/provider-display-names.js";
 import { formatSandboxList, formatSandboxStartResult, formatSandboxStopResult, parseSandboxUserCommand, } from "../../core/sandbox/command.js";
-import { DockerSandboxService, redactSecrets, } from "../../core/sandbox/docker.js";
+import { redactSecrets, } from "../../core/sandbox/config.js";
 import { LimaSandboxService } from "../../core/sandbox/lima.js";
 import { LocalSessionManager } from "../../core/session/local-session-manager.js";
 import { formatMissingSessionCwdPrompt, MissingSessionCwdError } from "../../core/session-cwd.js";
@@ -253,10 +253,8 @@ export class InteractiveMode {
     // Tool output expansion state
     toolOutputExpanded = false;
     activeSandboxContainerId;
-    activeSandboxRuntime;
     activeSandboxBackendConnected = false;
     sessionSandboxStates = new Map();
-    managedSandboxContainers = new Map();
     managedLimaInstances = new Map();
     // Thinking block visibility state
     hideThinkingBlock = false;
@@ -273,6 +271,7 @@ export class InteractiveMode {
     hookExecutionSession;
     hookExecutionNotices = [];
     hookExecutionComponents = [];
+    pendingStopHookNotifications = [];
     activeToolHookExecutionGroups = new Map();
     hookExecutionTurnActive = false;
     signalCleanupHandlers = [];
@@ -522,7 +521,41 @@ export class InteractiveMode {
                 });
             }
         }
-        return new CombinedAutocompleteProvider([...slashCommands, ...templateCommands, ...extensionCommands, ...skillCommandList, ...ruleCommandList], this.activeSession.getCwd(), this.fdPath);
+        const base = new CombinedAutocompleteProvider([...slashCommands, ...templateCommands, ...extensionCommands, ...skillCommandList, ...ruleCommandList], this.activeSession.getCwd(), this.fdPath);
+        const provider = {
+            getSuggestions: async (lines, cursorLine, cursorCol, options) => {
+                const beforeCursor = (lines[cursorLine] ?? "").slice(0, cursorCol);
+                const nameMatch = beforeCursor.match(/^\/sandbox[ \t]+(start[ \t]+--name(?:[ \t]+([^\s]*))?)$/);
+                if (!options.force || !nameMatch)
+                    return base.getSuggestions(lines, cursorLine, cursorCol, options);
+                if (options.signal.aborted)
+                    return null;
+                try {
+                    const instances = await this.createLimaSandboxService().list({
+                        workspaceRoot: this.activeSession.getCwd(),
+                        allWorkspaces: true,
+                    });
+                    if (options.signal.aborted)
+                        return null;
+                    const prefix = nameMatch[2] ?? "";
+                    const items = instances
+                        .filter((instance) => /^[a-z0-9][a-z0-9-]*$/.test(instance.name) && instance.name.startsWith(prefix))
+                        .map((instance) => ({
+                        value: `start --name ${instance.name}`,
+                        label: instance.name,
+                        description: instance.status,
+                    }));
+                    return items.length > 0 ? { items, prefix: nameMatch[1] } : null;
+                }
+                catch {
+                    // A failed Lima lookup must not fall back to directory suggestions.
+                    return null;
+                }
+            },
+            applyCompletion: (lines, cursorLine, cursorCol, item, prefix) => base.applyCompletion(lines, cursorLine, cursorCol, item, prefix),
+            shouldTriggerFileCompletion: (lines, cursorLine, cursorCol) => base.shouldTriggerFileCompletion(lines, cursorLine, cursorCol),
+        };
+        return provider;
     }
     setupAutocompleteProvider() {
         let provider = this.createBaseAutocompleteProvider();
@@ -1921,7 +1954,7 @@ export class InteractiveMode {
             select: (title, options, opts) => this.showExtensionSelector(title, options, opts),
             confirm: (title, message, opts) => this.showExtensionConfirm(title, message, opts),
             input: (title, placeholder, opts) => this.showExtensionInput(title, placeholder, opts),
-            notify: (message, type) => this.showExtensionNotify(message, type),
+            notify: (message, type, options) => this.showExtensionNotify(message, type, options),
             onTerminalInput: (handler) => this.addExtensionTerminalInputListener(handler),
             setStatus: (key, text) => this.setExtensionStatus(key, text),
             setWorkingMessage: (message) => {
@@ -2151,7 +2184,11 @@ export class InteractiveMode {
     /**
      * Show a notification for extensions.
      */
-    showExtensionNotify(message, type) {
+    showExtensionNotify(message, type, options) {
+        if (options?.hookEvent === "Stop") {
+            this.pendingStopHookNotifications.push({ message, type });
+            return;
+        }
         if (type === "error") {
             this.showError(message);
         }
@@ -2640,6 +2677,8 @@ export class InteractiveMode {
         const submittedText = text.trim();
         if (!submittedText)
             return;
+        // Keep attempted commands as well as accepted prompts available through editor history.
+        this.editor.addToHistory?.(submittedText);
         if (await this.handleBuiltInEditorCommand(submittedText))
             return;
         if (await this.handleBashEditorSubmission(submittedText))
@@ -2684,6 +2723,11 @@ export class InteractiveMode {
         const group = [notice];
         this.hookExecutionNotices.push(group);
         const component = new HookExecutionComponent(notice, this.getMarkdownThemeWithSettings());
+        if (notice.event === "Stop") {
+            for (const notification of this.pendingStopHookNotifications)
+                component.appendAnnotation(notification.message);
+            this.pendingStopHookNotifications = [];
+        }
         component.setExpanded(this.toolOutputExpanded);
         this.hookExecutionComponents.push(component);
         this.chatContainer.addChild(component);
@@ -3069,6 +3113,10 @@ export class InteractiveMode {
                 this.handleAgentEnd();
                 break;
             case "agent_settled":
+                for (const notification of this.pendingStopHookNotifications) {
+                    this.showExtensionNotify(notification.message, notification.type);
+                }
+                this.pendingStopHookNotifications = [];
                 await this.checkShutdownRequested();
                 this.ui.requestRender();
                 break;
@@ -4952,6 +5000,7 @@ export class InteractiveMode {
             this.editorContainer.clear();
             this.editorContainer.addChild(editor);
             this.ui.setFocus(editor);
+            this.updateToolBackendStatus();
             this.ui.requestRender();
         };
         try {
@@ -5230,12 +5279,6 @@ export class InteractiveMode {
         this.setupAutocompleteProvider();
         this.showLoadedResources({ force: true, showDiagnosticsWhenQuiet: true });
     }
-    createDockerSandboxService() {
-        return new DockerSandboxService({
-            settingsManager: this.settingsManager,
-            managedContainers: this.managedSandboxContainers,
-        });
-    }
     createLimaSandboxService() {
         return new LimaSandboxService({
             settingsManager: this.settingsManager,
@@ -5243,7 +5286,6 @@ export class InteractiveMode {
         });
     }
     async disposeRuntimeResources() {
-        const dockerSandboxService = this.createDockerSandboxService();
         const limaSandboxService = this.createLimaSandboxService();
         const errors = [];
         try {
@@ -5253,7 +5295,7 @@ export class InteractiveMode {
             errors.push(error instanceof Error ? error : new Error(String(error)));
         }
         try {
-            await Promise.all([dockerSandboxService.stopManagedContainers(), limaSandboxService.stopManagedInstances()]);
+            await limaSandboxService.stopManagedInstances();
         }
         catch (error) {
             errors.push(error instanceof Error ? error : new Error(String(error)));
@@ -5262,13 +5304,11 @@ export class InteractiveMode {
     }
     async restoreCurrentSessionSandbox() {
         this.activeSandboxContainerId = undefined;
-        this.activeSandboxRuntime = undefined;
         this.activeSandboxBackendConnected = false;
         const state = this.sessionSandboxStates.get(getSessionSandboxKey(this.activeSession));
         if (!state)
             return;
         this.activeSandboxContainerId = state.containerId;
-        this.activeSandboxRuntime = state.runtime ?? "docker";
         try {
             await this.session.activateSandboxDaemon({
                 url: state.url,
@@ -5286,7 +5326,6 @@ export class InteractiveMode {
     hasSandboxActivationConflict(sessionKey) {
         return (this.activeSandboxBackendConnected ||
             this.activeSandboxContainerId !== undefined ||
-            [...this.managedSandboxContainers.values()].some((container) => container.ownerId === this.activeSession.getSessionId()) ||
             [...(this.managedLimaInstances?.values() ?? [])].some((instance) => instance.ownerId === this.activeSession.getSessionId()) ||
             this.sessionSandboxStates.has(sessionKey));
     }
@@ -5300,13 +5339,12 @@ export class InteractiveMode {
         if (!this.activeSandboxBackendConnected && this.sessionSandboxStates.has(sessionKey)) {
             this.sessionSandboxStates.delete(sessionKey);
             this.activeSandboxContainerId = undefined;
-            this.activeSandboxRuntime = undefined;
             this.showStatus("Stale sandbox state cleared");
             return;
         }
         await this.session.clearRemoteSandbox();
         this.sessionSandboxStates.delete(sessionKey);
-        this.activeSandboxRuntime = undefined;
+        this.activeSandboxContainerId = undefined;
         this.activeSandboxBackendConnected = false;
         this.refreshUiAfterBackendChange();
         this.updateToolBackendStatus();
@@ -5320,7 +5358,6 @@ export class InteractiveMode {
         const token = process.env.GRIP_REMOTE_TOKEN ?? "";
         const info = await this.session.activateSandboxDaemon({ url, token, expectedCwd });
         this.activeSandboxContainerId = undefined;
-        this.activeSandboxRuntime = undefined;
         this.activeSandboxBackendConnected = true;
         this.sessionSandboxStates.set(sessionKey, { type: "daemon", url, token, expectedCwd });
         this.refreshUiAfterBackendChange();
@@ -5368,10 +5405,15 @@ export class InteractiveMode {
         if (info)
             return info;
         const activationError = lastActivationError instanceof Error ? lastActivationError : new Error(String(lastActivationError));
+        if (result.daemonUrl.startsWith("grip+ws:")) {
+            // A shared-VM attach owns only its channel, never the VM or guest daemon.
+            this.activeSandboxContainerId = undefined;
+            this.activeSandboxBackendConnected = false;
+            throw activationError;
+        }
         try {
             await service.stop({ workspaceRoot, currentContainerId: result.containerId });
             this.activeSandboxContainerId = undefined;
-            this.activeSandboxRuntime = undefined;
             this.activeSandboxBackendConnected = false;
         }
         catch (cleanupError) {
@@ -5382,18 +5424,24 @@ export class InteractiveMode {
         }
         throw activationError;
     }
-    async startSandboxBackend(command, service, workspaceRoot, sessionKey, runtime) {
+    async startSandboxBackend(command, service, workspaceRoot, sessionKey, updatingAttached = false) {
         const loader = this.showSandboxStartupLoader();
         try {
             const result = await service.start({
                 workspaceRoot,
-                ...(command.image ? { image: command.image } : {}),
                 ...(command.name ? { name: command.name } : {}),
                 ...(command.template ? { limaTemplate: command.template } : {}),
+                ...(command.update ? { update: true } : {}),
                 sessionId: this.activeSession.getSessionId(),
             });
+            if (updatingAttached) {
+                await this.session.abort();
+                await this.session.clearRemoteSandbox();
+                this.sessionSandboxStates.delete(sessionKey);
+                this.activeSandboxContainerId = undefined;
+                this.activeSandboxBackendConnected = false;
+            }
             this.activeSandboxContainerId = result.containerId;
-            this.activeSandboxRuntime = runtime;
             const info = await this.activateStartedSandbox(service, workspaceRoot, result);
             this.activeSandboxBackendConnected = true;
             this.sessionSandboxStates.set(sessionKey, {
@@ -5402,11 +5450,15 @@ export class InteractiveMode {
                 token: result.token,
                 expectedCwd: result.workspaceMountPath,
                 containerId: result.containerId,
-                runtime,
             });
             this.refreshUiAfterBackendChange();
             this.updateToolBackendStatus();
-            this.showStatus([formatSandboxStartResult(result), this.formatToolBackendStatus(info)].join("\n"));
+            this.showStatus([
+                command.update
+                    ? formatSandboxStartResult(result).replace("Sandbox started:", "Sandbox updated:")
+                    : formatSandboxStartResult(result),
+                this.formatToolBackendStatus(info),
+            ].join("\n"));
         }
         finally {
             this.hideSandboxStartupLoader(loader);
@@ -5435,7 +5487,6 @@ export class InteractiveMode {
             }
             this.sessionSandboxStates.delete(sessionKey);
             this.activeSandboxContainerId = undefined;
-            this.activeSandboxRuntime = undefined;
             this.activeSandboxBackendConnected = false;
             return;
         }
@@ -5449,7 +5500,6 @@ export class InteractiveMode {
         }
         if (stoppedActiveSandbox) {
             this.activeSandboxContainerId = undefined;
-            this.activeSandboxRuntime = undefined;
             this.activeSandboxBackendConnected = false;
         }
     }
@@ -5463,6 +5513,20 @@ export class InteractiveMode {
             this.showStatus("Sandbox detached");
             return;
         }
+        const attached = this.sessionSandboxStates.get(sessionKey);
+        if (attached?.url?.startsWith("grip+ws:") &&
+            attached.containerId === this.activeSandboxContainerId &&
+            (!target || target === attached.containerId)) {
+            if (this.activeSandboxBackendConnected)
+                await this.session.clearRemoteSandbox();
+            this.sessionSandboxStates.delete(sessionKey);
+            this.activeSandboxContainerId = undefined;
+            this.activeSandboxBackendConnected = false;
+            this.refreshUiAfterBackendChange();
+            this.updateToolBackendStatus();
+            this.showStatus("Shared sandbox detached; VM and guest daemon remain running");
+            return;
+        }
         const result = await service.stop({
             workspaceRoot,
             target,
@@ -5471,7 +5535,7 @@ export class InteractiveMode {
         await this.reconcileStoppedSandbox(result, sessionKey);
         this.showStatus(formatSandboxStopResult(result));
     }
-    async executeSandboxCommand(command, dockerService, workspaceRoot, sessionKey) {
+    async executeSandboxCommand(command, service, workspaceRoot, sessionKey) {
         switch (command.subcommand) {
             case "status":
                 this.showStatus(this.formatToolBackendStatus(this.session.getToolBackendInfo()));
@@ -5482,29 +5546,24 @@ export class InteractiveMode {
             case "attach":
                 if (!this.ensureSandboxCanActivate(sessionKey))
                     return;
-                await this.attachSandboxBackend(command.url, dockerService, sessionKey);
+                await this.attachSandboxBackend(command.url, service, sessionKey);
                 return;
-            case "start":
-                if (!this.ensureSandboxCanActivate(sessionKey))
+            case "start": {
+                const attached = this.sessionSandboxStates.get(sessionKey);
+                const updatingAttached = command.update === true &&
+                    attached?.url.startsWith("grip+ws:") === true &&
+                    attached.containerId === command.name &&
+                    this.activeSandboxBackendConnected;
+                if (!updatingAttached && !this.ensureSandboxCanActivate(sessionKey))
                     return;
-                {
-                    const runtime = command.runtime ?? dockerService.resolveConfig().runtime;
-                    const service = runtime === "lima" ? this.createLimaSandboxService() : dockerService;
-                    await this.startSandboxBackend(command, service, workspaceRoot, sessionKey, runtime);
-                }
+                await this.startSandboxBackend(command, service, workspaceRoot, sessionKey, updatingAttached);
                 return;
+            }
             case "list":
-                {
-                    const runtime = command.runtime ?? dockerService.resolveConfig().runtime;
-                    const service = runtime === "lima" ? this.createLimaSandboxService() : dockerService;
-                    this.showStatus(formatSandboxList(await service.list({ workspaceRoot })));
-                }
+                this.showStatus(formatSandboxList(await service.list({ workspaceRoot })));
                 return;
-            case "stop": {
-                const runtime = this.activeSandboxRuntime ?? dockerService.resolveConfig().runtime;
-                const service = runtime === "lima" ? this.createLimaSandboxService() : dockerService;
+            case "stop":
                 await this.stopSandboxBackend(command.target, service, workspaceRoot, sessionKey);
-            }
         }
     }
     async handleSandboxCommand(text) {
@@ -5516,7 +5575,7 @@ export class InteractiveMode {
             this.showWarning(error instanceof Error ? error.message : String(error));
             return;
         }
-        const service = this.createDockerSandboxService();
+        const service = this.createLimaSandboxService();
         const workspaceRoot = this.activeSession.getCwd();
         const sessionKey = getSessionSandboxKey(this.activeSession);
         try {