shortcutxl 0.3.77 → 0.3.78

package/dist/embedded-agent/worker-bridge/host-client.js

@@ -320,6 +320,21 @@ export function createEmbeddedAgentPortClient(port, options) {
         }
         const message = event.data;
         switch (message.kind) {
+            case WorkerMessageKind.AgentCommandReceived:
+                // Awaited submits are steering. This receipt only diagnoses the initial handoff.
+                if (pendingRuntimeCommands.has(message.commandId))
+                    return;
+                try {
+                    options.onInitialSubmitReceived?.({
+                        commandId: message.commandId,
+                        receivedAt: message.receivedAt,
+                        userMessageId: message.userMessageId
+                    });
+                }
+                catch {
+                    // Observability callbacks must not change worker command behavior.
+                }
+                return;
             case WorkerMessageKind.AgentCommandAck: {
                 const pendingCommand = pendingRuntimeCommands.get(message.commandId);
                 if (!pendingCommand) {

package/dist/embedded-agent/worker-bridge/worker-port.js

@@ -4,7 +4,7 @@
  * Owns request/response correlation and the abort-side detachment rule for
  * results that arrive after the requesting tool has been cancelled.
  */
-import { AgentEventKind, AgentProtocolErrorKind, toStructuredCloneSafeAgentEvent } from '../../contracts/agent-api.js';
+import { AgentCommandKind, AgentEventKind, AgentProtocolErrorKind, toStructuredCloneSafeAgentEvent } from '../../contracts/agent-api.js';
 import { WorkerMessageKind, isWorkerMessage } from '../../contracts/wire.js';
 import { isOutOfCreditsError } from '../out-of-credits-error.js';
 function createWorkerPortProtocolError(message) {
@@ -125,6 +125,22 @@ export function attachEmbeddedAgentDispatchToWorkerPort(port, controller, regist
             return;
         }
         const message = event.data;
+        if (message.command.kind === AgentCommandKind.SubmitPrompt &&
+            message.command.submitOptions?.userMessageId) {
+            const receiptMessage = {
+                kind: WorkerMessageKind.AgentCommandReceived,
+                commandId: message.commandId,
+                receivedAt: Date.now(),
+                userMessageId: message.command.submitOptions.userMessageId
+            };
+            try {
+                // Observability is best-effort and must never block command handling.
+                port.postMessage(receiptMessage);
+            }
+            catch {
+                // The command can still run even if its diagnostic receipt cannot be posted.
+            }
+        }
         void controller
             .handleCommand(message.command)
             .then(() => {

package/dist/main.js

@@ -84,6 +84,7 @@ import { createSessionManager } from './startup/session-selection.js';
 import { applyRuntimeApiKeyAndRefreshShortcutLoggerContext, applyShortcutUserInfoToLogger, refreshShortcutUserInfoLoggerContext, resolveShortcutUserInfo } from './startup/shortcut-user-logger-context.js';
 import { runForegroundUpdate } from './startup/update-action.js';
 import { runStartupUpdateFlow } from './startup/update-flow.js';
+import { refreshUpdateStatus } from './startup/update-manager.js';
 import { runWindowsPythonRuntimeUpgradeIfNeeded } from './startup/windows-python-upgrade.js';
 import { createWorkbookPrePromptContext } from './startup/workbook-pre-prompt.js';
 let sessionRef = null;
@@ -691,6 +692,15 @@ export async function main(args) {
         offline: offlineMode,
         skipVersionCheck
     });
+    const startupUpdateStatus = updatePromptOutcome.kind === 'continue' ? updatePromptOutcome.updateStatus : undefined;
+    const toInteractiveUpdate = (status) => status?.kind === 'available'
+        ? {
+            currentVersion: status.currentVersion,
+            latestVersion: status.latestVersion
+        }
+        : undefined;
+    const interactiveUpdate = toInteractiveUpdate(startupUpdateStatus);
+    const updateChecksEnabled = isInteractive && !needsSetup && !offlineMode && !skipVersionCheck;
     if (updatePromptOutcome.kind === 'run-update') {
         console.log(chalk.green(`Installing ShortcutXL v${updatePromptOutcome.update.latestVersion}...`));
         const updateResult = await runForegroundUpdate({
@@ -823,7 +833,7 @@ export async function main(args) {
             cli_mode: cliMode
         }
     });
-    // Expose the sheet pool on the session so the collab layer can access workbooks.
+    // Expose the sheet pool on the session for interactive workbook flows.
     if (sheetPoolRef) {
         session.sheetPool = sheetPoolRef;
     }
@@ -976,6 +986,11 @@ export async function main(args) {
             initialImages,
             initialMessages: parsed.messages,
             verbose: parsed.verbose,
+            availableUpdate: interactiveUpdate,
+            updateLastCheckedAt: startupUpdateStatus?.lastCheckedAt,
+            checkForUpdate: updateChecksEnabled
+                ? async () => toInteractiveUpdate(await refreshUpdateStatus())
+                : undefined,
             fetchCreditBalance: async (apiKey) => {
                 const model = session.model;
                 if (!model || model.provider !== SHORTCUT_PROVIDER_ID)

package/dist/rpc/index.d.ts

@@ -8,5 +8,5 @@ export type { ImageContent } from '../ai/types.js';
 export type { FileUploadData } from '../app/file-uploads.js';
 export { prepareRpcAttachments, type RpcAttachment } from './rpc-attachments.js';
 export { RpcClient, type ModelInfo, type RpcClientOptions, type RpcEventListener, type RpcHostEventListener, type RpcTerminationListener } from './rpc-client.js';
-export { RPC_PROTOCOL_VERSION, isRpcClientMessage, isRpcServerMessage, type RpcAgentTask, type RpcAuthProvider, type RpcAuthState, type RpcClientMessage, type RpcCommand, type RpcCommandResult, type RpcContextUsage, type RpcFastModeState, type RpcHostEvent, type RpcInteractionRequest, type RpcInteractionResponse, type RpcModelInfo, type RpcPermissionState, type RpcResourceSkill, type RpcServerMessage, type RpcSessionSnapshot, type RpcSessionSummary, type RpcSettingsState, type RpcSlashCommand } from './rpc-types.js';
+export { RPC_PROTOCOL_VERSION, isRpcClientMessage, isRpcServerMessage, type RpcAgentTask, type RpcAuthProvider, type RpcAuthState, type RpcClientMessage, type RpcCommand, type RpcCommandResult, type RpcContextUsage, type RpcFastModeState, type RpcHostEvent, type RpcInteractionRequest, type RpcInteractionResponse, type RpcLocalFileOpenResult, type RpcModelInfo, type RpcPermissionState, type RpcResourceSkill, type RpcServerMessage, type RpcSessionSnapshot, type RpcSessionSummary, type RpcSettingsState, type RpcSlashCommand } from './rpc-types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/rpc/rpc-host.d.ts

@@ -4,6 +4,7 @@ import type { AuthStorage } from '../app/auth/auth-storage.js';
 import type { ExtensionUIContext } from '../app/extensions/index.js';
 import { listAllSessions } from '../app/session/session-catalog.js';
 import type { RemoteApprovalController } from '../remote-control/approval-controller.js';
+import { type LocalFileOpenResult } from '../shell/links/local-file-opener.js';
 import { type RpcClientMessage, type RpcServerMessage, type RpcSlashCommand } from './rpc-types.js';
 export interface RpcSessionHostOptions {
     listSessions?: typeof listAllSessions;
@@ -14,6 +15,7 @@ export interface RpcSessionHostOptions {
         logout(providerId?: string): Promise<void>;
     }) => Promise<boolean>;
     extraCommands?: RpcSlashCommand[];
+    openLocalFileHref?: (href: string) => Promise<LocalFileOpenResult>;
 }
 /** One ordered command/event surface, independent of JSONL or Node IPC. */
 export declare class RpcSessionHost {
@@ -27,11 +29,13 @@ export declare class RpcSessionHost {
     private readonly authStorage?;
     private readonly commandHandler?;
     private readonly extraCommands;
+    private readonly openLocalFileHref;
     private activeLogin?;
     private loginAbortController?;
     private pendingMode?;
     private sequence;
     private commandQueue;
+    private fileOpenQueue;
     private shutdownRequested;
     private started;
     private closed;

package/dist/rpc/rpc-host.js

@@ -12,6 +12,7 @@ import { getTaskScopeId, taskManager } from '../app/tools/task/manager.js';
 import { getAgentDir } from '../config.js';
 import { getCurrentMode, onModeChange } from '../mode-names.js';
 import { exportSessionToHtml } from '../shell/export-html/index.js';
+import { openLocalFileLink } from '../shell/links/local-file-opener.js';
 import { RPC_PROTOCOL_VERSION } from './rpc-types.js';
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
@@ -28,11 +29,13 @@ export class RpcSessionHost {
     authStorage;
     commandHandler;
     extraCommands;
+    openLocalFileHref;
     activeLogin;
     loginAbortController;
     pendingMode;
     sequence = 0;
     commandQueue = Promise.resolve();
+    fileOpenQueue = Promise.resolve();
     shutdownRequested = false;
     started = false;
     closed = false;
@@ -48,6 +51,7 @@ export class RpcSessionHost {
         this.authStorage = options.authStorage;
         this.commandHandler = options.commandHandler;
         this.extraCommands = options.extraCommands ?? [];
+        this.openLocalFileHref = options.openLocalFileHref ?? openLocalFileLink;
     }
     subscribe(listener) {
         this.listeners.add(listener);
@@ -134,6 +138,11 @@ export class RpcSessionHost {
             return Promise.reject(new Error('RPC session host is not started'));
         if (this.closed)
             return Promise.reject(new Error('RPC session host is closed'));
+        if (message.command.type === 'open_local_file') {
+            const operation = this.fileOpenQueue.then(() => this.processMessage(message));
+            this.fileOpenQueue = operation.catch(() => { });
+            return operation;
+        }
         const operation = this.commandQueue.then(() => this.processMessage(message));
         this.commandQueue = operation.catch(() => { });
         return operation;
@@ -640,22 +649,16 @@ export class RpcSessionHost {
                 this.publishSnapshot();
                 return this.success();
             }
-            case 'send_collab_message': {
-                const client = this.session.collabClient;
-                if (!client?.state.roomId)
-                    return this.failure('Not in a collaboration session');
-                const message = command.message.trim();
-                if (!message)
-                    return this.failure('Collaboration message cannot be empty');
-                client.sendChat(message);
-                return this.success();
-            }
             case 'get_session_stats':
                 return this.success(this.session.getSessionStats());
             case 'export_html':
                 return this.success({
                     path: await exportSessionToHtml(this.session, command.outputPath)
                 });
+            case 'open_local_file':
+                if (typeof command.href !== 'string')
+                    return this.failure('File link must be a string');
+                return this.success(await this.openLocalFileHref(command.href));
             case 'switch_session':
                 return this.success({
                     cancelled: !(await this.session.switchSession(command.sessionPath))
@@ -810,20 +813,6 @@ export class RpcSessionHost {
                     errorMessage: task.errorMessage
                 }));
             })(),
-            collaboration: (() => {
-                const state = this.session.collabClient?.state;
-                return {
-                    connected: state?.connected ?? false,
-                    roomId: state?.roomId ?? null,
-                    peers: state
-                        ? [...state.peers.values()].map((peer) => ({
-                            id: peer.peerId,
-                            displayName: peer.displayName,
-                            sheets: peer.sheets
-                        }))
-                        : []
-                };
-            })(),
             isStreaming: this.session.isStreaming,
             isCompacting: this.session.isCompacting,
             steeringMode: this.session.steeringMode,

package/dist/rpc/rpc-types.d.ts

@@ -97,19 +97,6 @@ export interface RpcAgentTask {
     resultText?: string;
     errorMessage?: string;
 }
-export interface RpcCollaborationState {
-    connected: boolean;
-    roomId: string | null;
-    peers: Array<{
-        id: string;
-        displayName: string;
-        sheets?: Array<{
-            name: string;
-            cellCount: number;
-            usedRange?: string | null;
-        }>;
-    }>;
-}
 export interface RpcSessionSummary {
     id: string;
     path?: string;
@@ -124,6 +111,9 @@ export interface RpcContextUsage {
     contextWindow: number;
     percent: number | null;
 }
+export interface RpcLocalFileOpenResult {
+    path: string;
+}
 export interface RpcSessionSnapshot {
     session: RpcSessionSummary;
     environment: {
@@ -143,7 +133,6 @@ export interface RpcSessionSnapshot {
     settings: RpcSettingsState;
     goal: ShortcutXLThreadGoal | null;
     agentTasks: RpcAgentTask[];
-    collaboration: RpcCollaborationState;
     isStreaming: boolean;
     isCompacting: boolean;
     steeringMode: 'all' | 'one-at-a-time';
@@ -287,14 +276,14 @@ export type RpcCommand = {
     type: 'message_agent_task';
     agentId: string;
     message: string;
-} | {
-    type: 'send_collab_message';
-    message: string;
 } | {
     type: 'get_session_stats';
 } | {
     type: 'export_html';
     outputPath?: string;
+} | {
+    type: 'open_local_file';
+    href: string;
 } | {
     type: 'switch_session';
     sessionPath: string;

package/dist/shared/platform/open.d.ts

@@ -1,8 +1,11 @@
 /**
  * Cross-platform "open" utility — launches files/directories in the OS default handler.
  */
+export interface OpenInEditorOptions {
+    directory?: boolean;
+}
 /** Convert any error thrown by openInEditor into a human-readable string. */
 export declare function formatOpenError(error: unknown): string;
 /** Open a file or directory in the OS default editor/handler. */
-export declare function openInEditor(path: string): Promise<void>;
+export declare function openInEditor(path: string, options?: OpenInEditorOptions): Promise<void>;
 //# sourceMappingURL=open.d.ts.map

package/dist/shared/platform/open.js

@@ -1,15 +1,27 @@
 /**
  * Cross-platform "open" utility — launches files/directories in the OS default handler.
  */
-import { execFile } from 'child_process';
+import { execFile, spawn } from 'child_process';
 /** Convert any error thrown by openInEditor into a human-readable string. */
 export function formatOpenError(error) {
     return error instanceof Error ? error.message : String(error);
 }
 /** Open a file or directory in the OS default editor/handler. */
-export function openInEditor(path) {
+export function openInEditor(path, options = {}) {
     if (process.platform === 'win32') {
         return new Promise((resolve, reject) => {
+            if (options.directory) {
+                const child = spawn('explorer.exe', ['/n,', path], {
+                    detached: true,
+                    stdio: 'ignore'
+                });
+                child.once('error', reject);
+                child.once('spawn', () => {
+                    child.unref();
+                    resolve();
+                });
+                return;
+            }
             execFile('rundll32.exe', ['url.dll,FileProtocolHandler', path], { windowsHide: true }, (error) => {
                 if (error) {
                     reject(error);

package/dist/shell/interactive/interactive-mode-options.d.ts

@@ -7,6 +7,8 @@ import type { SkillUploadApprovalRequest } from '../../app/sync/skills-upload.js
 import type { WorkbookScopeStateRef } from '../../app/workbook-scope.js';
 import type { SelectItem } from '../../tui/index.js';
 import type { Terminal } from '../../tui/terminal.js';
+import type { LocalFileOpenResult } from '../links/local-file-opener.js';
+import type { InteractiveAvailableUpdate } from '../status/update-reminder.js';
 import type { SlashCommandDefinition } from './slash-commands.js';
 import type { WorkbookScopeDeps } from './workbook-scope-controller.js';
 export type CompactionQueuedMessage = {
@@ -29,6 +31,8 @@ export interface CreditBalance {
 export interface InteractiveModeOptions {
     /** Custom terminal implementation for the interactive shell. */
     terminal?: Terminal;
+    /** Override local file opening for deterministic shell tests. */
+    openLocalFileHref?: (href: string) => Promise<LocalFileOpenResult>;
     skipShortcutAuth?: boolean;
     exitProcessOnShutdown?: boolean;
     workbookScopeRef?: WorkbookScopeStateRef;
@@ -46,6 +50,12 @@ export interface InteractiveModeOptions {
     initialMessages?: string[];
     /** Force verbose startup (overrides quietStartup setting) */
     verbose?: boolean;
+    /** Update retained after the user skips the startup prompt. */
+    availableUpdate?: InteractiveAvailableUpdate;
+    /** Timestamp used to schedule the next non-blocking registry check. */
+    updateLastCheckedAt?: string;
+    /** Refresh available update state for the running shell. */
+    checkForUpdate?: () => Promise<InteractiveAvailableUpdate | undefined>;
     /**
      * Fetch credit balance for the current API key. Injected by main.ts.
      * Returns CreditBalance when credits apply, 'not_applicable' when the model

package/dist/shell/interactive/interactive-mode.d.ts

@@ -10,6 +10,7 @@ export declare class InteractiveMode {
     private options;
     private session;
     private ui;
+    private readonly localFileLinkInput;
     private renderTracePath;
     private shellLayout;
     private mainContentContainer;
@@ -111,17 +112,15 @@ export declare class InteractiveMode {
     private widgetContainerBelow;
     private customFooter;
     private headerContainer;
+    private updateReminderController;
     private builtInHeader;
     private customHeader;
     private isBashMode;
-    private isChatMode;
     private creditPollInterval;
     private static readonly CREDIT_POLL_INTERVAL_MS;
     private readonly creditGate;
     private _commands;
     private _resourceDisplay;
-    private _collabManager;
-    private _superFight;
     private readonly manualMemoryCoordinator;
     private readonly manualSkillProposalBackground;
     /** AgentController for the current session. */
@@ -252,6 +251,7 @@ export declare class InteractiveMode {
     /** Wire interactive shell key handlers via registerInteractiveActions. */
     private setupKeyHandlers;
     private handleEditorSelectionInput;
+    private handleLocalFileLink;
     /**
      * Screen-row range (1-based, inclusive) occupied by the editor, derived from
      * geometry cached during the last frame render — no re-render per mouse event.
@@ -283,9 +283,7 @@ export declare class InteractiveMode {
     private tryAttachClipboardFilePath;
     /** Build a CommandContext for slash command handlers. */
     private _buildCommandContext;
-    /** Lazily build the collaboration command client backed by CollabManager. */
-    private getCollabCommandClient;
-    /** Wire the default editor submit handler covering bash, chat, slash, and prompt dispatch. */
+    /** Wire the default editor submit handler covering bash, slash, and prompt dispatch. */
     private setupEditorSubmitHandler;
     /** Wire the InteractiveSessionController to all agent lifecycle events. */
     private subscribeToAgent;
@@ -375,13 +373,9 @@ export declare class InteractiveMode {
     private handleFollowUp;
     /** Handle dequeue keybind: pull queued messages back into the editor for editing. */
     private handleDequeue;
-    /** Refresh the editor border color based on bash/chat/thinking state. */
+    /** Refresh the editor border color based on bash/thinking state. */
     private updateEditorBorderColor;
-    /** Subscribe to CollabClient events and surface peer activity in chat. */
-    private _attachCollabEvents;
-    /** Launch the SuperFight collab mini-game UI for the current room. */
-    private launchSuperFight;
-    /** Watch editor text and toggle bash/chat-mode borders based on `!`/`:` prefixes. */
+    /** Watch editor text and toggle bash-mode borders based on the `!` prefix. */
     private setupBashModeDetection;
     /** Execute a `!`-prefixed bash command, streaming output into the chat container. */
     private executeBashCommand;