@selesai/code 0.13.8 → 0.13.10

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

@@ -11,10 +11,26 @@
  * - Extension UI: Extension UI requests are emitted, client responds with extension_ui_response
  */
 import * as crypto from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { chmodSync, copyFileSync, existsSync, unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { generateHandoff } from "../../core/handoff.js";
+import { buildGitCommandPrompt } from "../../core/git-command.js";
+import { KeybindingsManager } from "../../core/keybindings.js";
+import { SessionManager } from "../../core/session-manager.js";
+import { resolveModelScope } from "../../core/model-resolver.js";
+import { refreshModelCatalogs } from "../interactive/model-catalog-refresh.js";
 import { flushRawStdout, takeOverStdout, waitForRawStdoutBackpressure, writeRawStdout, } from "../../core/output-guard.js";
+import { ProjectTrustStore, hasTrustRequiringProjectResources } from "../../core/trust-manager.js";
+import { BUILTIN_SLASH_COMMANDS } from "../../core/slash-commands.js";
+import { createSyntheticSourceInfo } from "../../core/source-info.js";
 import { killTrackedDetachedChildren } from "../../utils/shell.js";
+import { getChangelogPath, parseChangelog } from "../../utils/changelog.js";
+import { VERSION, getAgentDir, getBundledDefaultsDir, getShareViewerUrl } from "../../config.js";
+import { openBrowser } from "../../utils/open-browser.js";
 import { theme } from "../interactive/theme/theme.js";
+import { getAvailableThemesWithPaths, setRegisteredThemes } from "../interactive/theme/theme.js";
 import { attachJsonlLineReader, serializeJsonLine } from "./jsonl.js";
 /**
  * Run in RPC mode.
@@ -28,6 +44,43 @@ export async function runRpcMode(runtimeHost) {
     const output = (obj) => {
         writeRawStdout(serializeJsonLine(obj));
     };
+    /**
+     * Filter a session tree with the same semantics as the TUI tree selector
+     * (tree-selector.ts FilterMode). Hidden leaf pruning is preserved.
+     */
+    const filterTree = (nodes, mode) => {
+        const passes = (node) => {
+            const entry = node.entry;
+            const isSettingsEntry = entry.type === "label" ||
+                entry.type === "custom" ||
+                entry.type === "model_change" ||
+                entry.type === "thinking_level_change" ||
+                entry.type === "session_info";
+            switch (mode) {
+                case "user-only":
+                    return entry.type === "message" && entry.message.role === "user";
+                case "no-tools":
+                    return !isSettingsEntry && !(entry.type === "message" && entry.message.role === "toolResult");
+                case "labeled-only":
+                    return node.label !== undefined;
+                case "all":
+                    return true;
+                default:
+                    return !isSettingsEntry;
+            }
+        };
+        const visit = (nodes) => {
+            const result = [];
+            for (const node of nodes) {
+                if (!passes(node))
+                    continue;
+                const children = visit(node.children);
+                result.push({ ...node, children });
+            }
+            return result;
+        };
+        return visit(nodes);
+    };
     const success = (id, command, data) => {
         if (data === undefined) {
             return { id, type: "response", command, success: true };
@@ -39,6 +92,8 @@ export async function runRpcMode(runtimeHost) {
     };
     // Pending extension UI requests waiting for response
     const pendingExtensionRequests = new Map();
+    // Prompts buffered while compacting (queueWhileCompacting) — flushed after compaction_end.
+    const compactionPromptQueue = [];
     // Shutdown request flag
     let shutdownRequested = false;
     let shuttingDown = false;
@@ -268,6 +323,30 @@ export async function runRpcMode(runtimeHost) {
             if (event.type === "agent_settled") {
                 void checkShutdownRequested();
             }
+            if (event.type === "compaction_end" && compactionPromptQueue.length > 0) {
+                // TUI flushCompactionQueue parity: replay buffered prompts after compaction finishes.
+                // Completed compaction replays in-order (extension commands via prompt, rest by
+                // their original streaming behavior); aborted compaction discards the buffer.
+                if (event.aborted || event.errorMessage) {
+                    compactionPromptQueue.length = 0;
+                    return;
+                }
+                const queued = compactionPromptQueue.splice(0);
+                void (async () => {
+                    for (const item of queued) {
+                        try {
+                            await session.prompt(item.message, {
+                                images: item.images,
+                                streamingBehavior: item.streamingBehavior,
+                                source: "rpc",
+                            });
+                        }
+                        catch {
+                            // Replay failures surface through agent error handling; do not kill the stream.
+                        }
+                    }
+                })();
+            }
         });
         unsubscribeBackpressure = session.agent.subscribe(async () => {
             await waitForRawStdoutBackpressure();
@@ -300,6 +379,21 @@ export async function runRpcMode(runtimeHost) {
                 // Start prompt handling immediately, but emit the authoritative response only after
                 // prompt preflight succeeds. Queued and immediately handled prompts also count as success.
                 let preflightSucceeded = false;
+                // During compaction: either buffer and auto-send after compaction_end (TUI parity),
+                // or fail fast with a clear error when the caller did not opt in.
+                if (session.isCompacting) {
+                    if (!command.queueWhileCompacting) {
+                        return error(id, "prompt", "Agent is compacting; set queueWhileCompacting:true to buffer this prompt and send it after compaction, or wait for compaction_end.");
+                    }
+                    const queued = {
+                        message: command.message,
+                        images: command.images,
+                        streamingBehavior: command.streamingBehavior,
+                    };
+                    output(success(id, "prompt")); // accepted into the buffer
+                    compactionPromptQueue.push(queued);
+                    return undefined;
+                }
                 void session
                     .prompt(command.message, {
                     images: command.images,
@@ -328,6 +422,10 @@ export async function runRpcMode(runtimeHost) {
                 return success(id, "follow_up");
             }
             case "abort": {
+                // TUI Esc parity: cancel in-flight branch summarization and compaction as well,
+                // not just the active agent turn (session.abort() alone covers retry + agent).
+                session.abortBranchSummary();
+                session.abortCompaction();
                 await session.abort();
                 return success(id, "abort");
             }
@@ -418,13 +516,22 @@ export async function runRpcMode(runtimeHost) {
                 return success(id, "set_model", model);
             }
             case "cycle_model": {
-                const result = await session.cycleModel();
+                const result = await session.cycleModel(command.direction ?? "forward");
                 if (!result) {
                     return success(id, "cycle_model", null);
                 }
                 return success(id, "cycle_model", result);
             }
             case "get_available_models": {
+                if (command.refresh) {
+                    // TUI parity: refresh model catalogs before listing (shared coordinator).
+                    try {
+                        await refreshModelCatalogs(session.modelRuntime, AbortSignal.timeout(15_000));
+                    }
+                    catch {
+                        // Fall back to the current snapshot if the network refresh fails.
+                    }
+                }
                 const models = await session.modelRuntime.getAvailable();
                 return success(id, "get_available_models", { models });
             }
@@ -530,7 +637,7 @@ export async function runRpcMode(runtimeHost) {
                 return success(id, "get_session_stats", stats);
             }
             case "export_html": {
-                const path = await session.exportToHtml(command.outputPath);
+                const path = await session.exportToHtml(command.outputPath, { themeName: command.themeName });
                 return success(id, "export_html", { path });
             }
             case "switch_session": {
@@ -576,7 +683,10 @@ export async function runRpcMode(runtimeHost) {
             }
             case "get_tree": {
                 const sessionManager = session.sessionManager;
-                return success(id, "get_tree", { tree: sessionManager.getTree(), leafId: sessionManager.getLeafId() });
+                const tree = sessionManager.getTree();
+                const filter = command.filter ?? "default";
+                const filtered = filter === "all" ? tree : filterTree(tree, filter);
+                return success(id, "get_tree", { tree: filtered, leafId: sessionManager.getLeafId() });
             }
             case "get_last_assistant_text": {
                 const text = session.getLastAssistantText();
@@ -591,6 +701,145 @@ export async function runRpcMode(runtimeHost) {
                 return success(id, "set_session_name");
             }
             // =================================================================
+            // Tree navigation
+            // =================================================================
+            case "navigate_tree": {
+                if (session.isStreaming) {
+                    return error(id, "navigate_tree", "Wait for the current response to finish before navigating the session tree.");
+                }
+                try {
+                    const result = await session.navigateTree(command.targetId, {
+                        summarize: command.summarize,
+                        customInstructions: command.customInstructions,
+                        replaceInstructions: command.replaceInstructions,
+                        label: command.label,
+                    });
+                    return success(id, "navigate_tree", {
+                        editorText: result.editorText,
+                        cancelled: result.cancelled,
+                        aborted: result.aborted,
+                        summaryEntry: result.summaryEntry ?? null,
+                    });
+                }
+                catch (navigationError) {
+                    return error(id, "navigate_tree", navigationError instanceof Error ? navigationError.message : String(navigationError));
+                }
+            }
+            // =================================================================
+            // Session discovery / management
+            // =================================================================
+            case "list_sessions": {
+                try {
+                    const sessionManager = session.sessionManager;
+                    const isAll = command.scope === "all";
+                    const source = isAll
+                        ? sessionManager.usesDefaultSessionDir()
+                            ? await SessionManager.listAll()
+                            : await SessionManager.listAll(sessionManager.getSessionDir())
+                        : await SessionManager.list(sessionManager.getCwd(), sessionManager.getSessionDir());
+                    const sessions = source.map((info) => ({
+                        path: info.path,
+                        id: info.id,
+                        cwd: info.cwd,
+                        name: info.name,
+                        parentSessionPath: info.parentSessionPath,
+                        created: Number.isNaN(info.created.getTime()) ? new Date(0).toISOString() : info.created.toISOString(),
+                        modified: Number.isNaN(info.modified.getTime()) ? new Date(0).toISOString() : info.modified.toISOString(),
+                        messageCount: info.messageCount,
+                        firstMessage: info.firstMessage,
+                    }));
+                    return success(id, "list_sessions", { sessions });
+                }
+                catch (listError) {
+                    return error(id, "list_sessions", listError instanceof Error ? listError.message : String(listError));
+                }
+            }
+            case "rename_session": {
+                const name = command.name.trim();
+                if (!name) {
+                    return error(id, "rename_session", "Session name cannot be empty");
+                }
+                if (!existsSync(command.path)) {
+                    return error(id, "rename_session", `Session file not found: ${command.path}`);
+                }
+                try {
+                    const target = SessionManager.open(command.path);
+                    target.appendSessionInfo(name);
+                    return success(id, "rename_session", { path: command.path, name });
+                }
+                catch (renameError) {
+                    return error(id, "rename_session", renameError instanceof Error ? renameError.message : String(renameError));
+                }
+            }
+            case "delete_session": {
+                if (command.path === session.sessionFile) {
+                    return error(id, "delete_session", "Cannot delete the currently active session.");
+                }
+                if (!existsSync(command.path)) {
+                    return error(id, "delete_session", `Session file not found: ${command.path}`);
+                }
+                try {
+                    // trash-CLI-first with unlink fallback (identical to the TUI session selector).
+                    const trashArgs = command.path.startsWith("-") ? ["--", command.path] : [command.path];
+                    const trashResult = spawnSync("trash", trashArgs, { encoding: "utf-8" });
+                    if (trashResult.status === 0 || !existsSync(command.path)) {
+                        return success(id, "delete_session", { path: command.path, method: "trash" });
+                    }
+                    unlinkSync(command.path);
+                    return success(id, "delete_session", { path: command.path, method: "unlink" });
+                }
+                catch (deleteError) {
+                    return error(id, "delete_session", deleteError instanceof Error ? deleteError.message : String(deleteError));
+                }
+            }
+            // =================================================================
+            // Session-only scoped models (ephemeral, not persisted)
+            // =================================================================
+            case "set_session_models": {
+                try {
+                    if (command.reorder !== undefined && command.reorder.length > 0) {
+                        // Reorder-only path: rebuild scope from the reordered pattern list.
+                        const scoped = await resolveModelScope(command.reorder, session.modelRuntime);
+                        session.setScopedModels(scoped.map((sm) => ({ model: sm.model, thinkingLevel: sm.thinkingLevel })));
+                        return success(id, "set_session_models", {
+                            enabled: scoped.map((sm) => `${sm.model.provider}/${sm.model.id}`),
+                            models: scoped.map((sm) => sm.model),
+                        });
+                    }
+                    if (command.enabled === undefined) {
+                        return error(id, "set_session_models", "Provide either enabled or reorder.");
+                    }
+                    if (command.enabled.length === 0) {
+                        session.setScopedModels([]);
+                        return success(id, "set_session_models", { enabled: [], models: [] });
+                    }
+                    const patterns = command.enabled;
+                    const allModels = await session.modelRuntime.getAvailable();
+                    const allModelIds = new Set(allModels.map((model) => `${model.provider}/${model.id}`));
+                    const allEnabled = patterns.every((pattern) => allModelIds.has(pattern));
+                    if (allEnabled) {
+                        // Every enabled id resolves to a concrete model: build scope directly.
+                        const enabledSet = new Set(patterns);
+                        const scopedModels = allModels.filter((model) => enabledSet.has(`${model.provider}/${model.id}`));
+                        session.setScopedModels(scopedModels.map((model) => ({ model })));
+                        return success(id, "set_session_models", {
+                            enabled: scopedModels.map((model) => `${model.provider}/${model.id}`),
+                            models: scopedModels,
+                        });
+                    }
+                    // Patterns contain a scope/wildcard (e.g. "anthropic/*"): resolve against the registry.
+                    const scoped = await resolveModelScope(patterns, session.modelRuntime);
+                    session.setScopedModels(scoped.map((sm) => ({ model: sm.model, thinkingLevel: sm.thinkingLevel })));
+                    return success(id, "set_session_models", {
+                        enabled: scoped.map((sm) => `${sm.model.provider}/${sm.model.id}`),
+                        models: scoped.map((sm) => sm.model),
+                    });
+                }
+                catch (scopeError) {
+                    return error(id, "set_session_models", scopeError instanceof Error ? scopeError.message : String(scopeError));
+                }
+            }
+            // =================================================================
             // Messages
             // =================================================================
             case "get_messages": {
@@ -617,8 +866,438 @@ export async function runRpcMode(runtimeHost) {
                         sourceInfo: template.sourceInfo,
                     });
                 }
+                // Built-in TUI commands: display-only, cannot be invoked via prompt.
+                for (const builtin of BUILTIN_SLASH_COMMANDS) {
+                    commands.push({
+                        name: builtin.name,
+                        description: builtin.description
+                            + (builtin.argumentHint ? ` ${builtin.argumentHint}` : ""),
+                        source: "builtin",
+                        sourceInfo: createSyntheticSourceInfo(`builtin:${builtin.name}`, { source: "builtin" }),
+                        interactiveOnly: true,
+                    });
+                }
                 return success(id, "get_commands", { commands });
             }
+            // =================================================================
+            // Settings
+            // =================================================================
+            case "get_settings": {
+                const scope = command.scope ?? "effective";
+                const settings = scope === "global"
+                    ? session.settingsManager.getGlobalSettings()
+                    : scope === "project"
+                        ? session.settingsManager.getProjectSettings()
+                        : session.settingsManager.getEffectiveSettings();
+                return success(id, "get_settings", { scope, settings });
+            }
+            case "set_settings": {
+                const scope = command.scope ?? "global";
+                try {
+                    if (scope === "project") {
+                        session.settingsManager.setProjectSettings(command.values);
+                    }
+                    else {
+                        session.settingsManager.setGlobalSettings(command.values);
+                    }
+                    await session.settingsManager.flush();
+                    return success(id, "set_settings", { scope, values: structuredClone(command.values) });
+                }
+                catch (writeError) {
+                    return error(id, "set_settings", writeError instanceof Error ? writeError.message : String(writeError));
+                }
+            }
+            case "factory_reset_settings": {
+                if (session.isStreaming) {
+                    return error(id, "factory_reset_settings", "Wait for the current response to finish before resetting settings.");
+                }
+                if (session.isCompacting) {
+                    return error(id, "factory_reset_settings", "Wait for compaction to finish before resetting settings.");
+                }
+                try {
+                    const agentDir = getAgentDir();
+                    const settingsPath = join(agentDir, "settings.json");
+                    const bundledPath = join(getBundledDefaultsDir(), "settings.json");
+                    if (!existsSync(bundledPath)) {
+                        return error(id, "factory_reset_settings", `Bundled defaults not found at ${bundledPath}`);
+                    }
+                    if (existsSync(settingsPath)) {
+                        copyFileSync(settingsPath, `${settingsPath}.bak`);
+                    }
+                    copyFileSync(bundledPath, settingsPath);
+                    try {
+                        chmodSync(settingsPath, 0o600);
+                    }
+                    catch {
+                        // best-effort
+                    }
+                    await session.reload();
+                    return success(id, "factory_reset_settings");
+                }
+                catch (resetError) {
+                    return error(id, "factory_reset_settings", resetError instanceof Error ? resetError.message : String(resetError));
+                }
+            }
+            // =================================================================
+            // Auth
+            // =================================================================
+            case "get_auth_providers": {
+                const providers = session.modelRuntime
+                    .getProviders()
+                    .map((provider) => {
+                    const authTypes = [];
+                    if (provider.auth.oauth)
+                        authTypes.push("oauth");
+                    if (provider.auth.apiKey)
+                        authTypes.push("api_key");
+                    return { providerId: provider.id, name: provider.name, authTypes };
+                })
+                    .sort((a, b) => a.name.localeCompare(b.name));
+                return success(id, "get_auth_providers", { providers });
+            }
+            case "login": {
+                const provider = session.modelRuntime.getProvider(command.providerId);
+                if (!provider) {
+                    return error(id, "login", `Unknown provider: ${command.providerId}`);
+                }
+                if (command.authType === "oauth" && !provider.auth.oauth) {
+                    return error(id, "login", `Provider ${command.providerId} does not support OAuth login`);
+                }
+                if (command.authType === "api_key" && !provider.auth.apiKey) {
+                    return error(id, "login", `Provider ${command.providerId} does not support API key login`);
+                }
+                try {
+                    const abortController = new AbortController();
+                    await session.modelRuntime.login(command.providerId, command.authType, {
+                        signal: abortController.signal,
+                        prompt: async (prompt) => {
+                            if (prompt.signal?.aborted)
+                                throw new Error("Login cancelled");
+                            const id = crypto.randomUUID();
+                            const result = await new Promise((resolve, reject) => {
+                                const onAbort = () => {
+                                    cleanup();
+                                    resolve({ type: "extension_ui_response", id, cancelled: true });
+                                };
+                                const cleanup = () => {
+                                    prompt.signal?.removeEventListener("abort", onAbort);
+                                    pendingExtensionRequests.delete(id);
+                                };
+                                prompt.signal?.addEventListener("abort", onAbort, { once: true });
+                                pendingExtensionRequests.set(id, {
+                                    resolve: (response) => {
+                                        cleanup();
+                                        resolve(response);
+                                    },
+                                    reject: (err) => {
+                                        cleanup();
+                                        reject(err);
+                                    },
+                                });
+                                const request = {
+                                    type: "extension_ui_request",
+                                    id,
+                                    method: prompt.type === "select" ? "select" : "input",
+                                    title: prompt.message,
+                                };
+                                if (prompt.type === "select") {
+                                    request.options = prompt.options.map((option) => option.description ? `${option.label} (${option.description})` : option.label);
+                                }
+                                else {
+                                    if (prompt.placeholder)
+                                        request.placeholder = prompt.placeholder;
+                                    if (prompt.type === "secret")
+                                        request.inputKind = "secret";
+                                }
+                                output(request);
+                            });
+                            if (result.type === "extension_ui_response" && "cancelled" in result && result.cancelled) {
+                                throw new Error("Login cancelled");
+                            }
+                            if ("value" in result)
+                                return result.value;
+                            if ("values" in result)
+                                return (result.values ? result.values[0] : undefined);
+                            return undefined;
+                        },
+                        notify: (event) => {
+                            if (event.type === "auth_url") {
+                                openBrowser(event.url);
+                                output({
+                                    type: "extension_ui_request",
+                                    id: crypto.randomUUID(),
+                                    method: "notify",
+                                    message: event.instructions
+                                        ? `Open in your browser: ${event.url}\n${event.instructions}`
+                                        : `Open in your browser: ${event.url}`,
+                                    notifyType: "info",
+                                });
+                            }
+                            else if (event.type === "device_code") {
+                                openBrowser(event.verificationUri);
+                                output({
+                                    type: "extension_ui_request",
+                                    id: crypto.randomUUID(),
+                                    method: "notify",
+                                    message: `Open ${event.verificationUri} and enter code: ${event.userCode}`,
+                                    notifyType: "info",
+                                });
+                            }
+                            else if (event.type === "info") {
+                                output({
+                                    type: "extension_ui_request",
+                                    id: crypto.randomUUID(),
+                                    method: "notify",
+                                    message: event.message,
+                                    notifyType: "info",
+                                });
+                            }
+                            else if (event.type === "progress") {
+                                output({
+                                    type: "extension_ui_request",
+                                    id: crypto.randomUUID(),
+                                    method: "notify",
+                                    message: event.message,
+                                    notifyType: "info",
+                                });
+                            }
+                        },
+                    });
+                    const actionLabel = command.authType === "oauth" ? `Logged in to ${provider.name}` : `Saved API key for ${provider.name}`;
+                    const authType = command.authType;
+                    const isUnknownModel = session.model?.provider === "unknown" && session.model?.id === "unknown";
+                    if (isUnknownModel) {
+                        const available = await session.modelRuntime.getAvailable();
+                        const providerModels = available.filter((model) => model.provider === command.providerId);
+                        if (providerModels.length > 0) {
+                            await session.setModel(providerModels[0]);
+                        }
+                    }
+                    return success(id, "login", {
+                        providerId: command.providerId,
+                        authType,
+                        message: `${actionLabel}. Credentials saved.`,
+                    });
+                }
+                catch (loginError) {
+                    const message = loginError instanceof Error ? loginError.message : String(loginError);
+                    if (message === "Login cancelled") {
+                        return error(id, "login", "Login cancelled");
+                    }
+                    return error(id, "login", message);
+                }
+            }
+            case "logout": {
+                const provider = session.modelRuntime.getProvider(command.providerId);
+                if (!provider) {
+                    return error(id, "logout", `Unknown provider: ${command.providerId}`);
+                }
+                try {
+                    await session.modelRuntime.logout(command.providerId);
+                    return success(id, "logout", { providerId: command.providerId });
+                }
+                catch (logoutError) {
+                    return error(id, "logout", logoutError instanceof Error ? logoutError.message : String(logoutError));
+                }
+            }
+            case "get_auth_state": {
+                try {
+                    const credentials = await session.modelRuntime.listCredentials();
+                    const providers = credentials.map(({ providerId, type }) => ({
+                        providerId,
+                        authType: type,
+                        source: "stored",
+                    }));
+                    // Environment/configured auth not in the credential store.
+                    for (const provider of session.modelRuntime.getProviders()) {
+                        if (providers.some((entry) => entry.providerId === provider.id))
+                            continue;
+                        const status = session.modelRuntime.getProviderAuthStatus(provider.id);
+                        if (status.configured) {
+                            providers.push({
+                                providerId: provider.id,
+                                authType: session.modelRuntime.isUsingOAuth(provider.id) ? "oauth" : "api_key",
+                                source: status.label ?? status.source ?? "environment",
+                            });
+                        }
+                    }
+                    return success(id, "get_auth_state", { providers });
+                }
+                catch (authStateError) {
+                    return error(id, "get_auth_state", authStateError instanceof Error ? authStateError.message : String(authStateError));
+                }
+            }
+            // =================================================================
+            // Scoped Models
+            // =================================================================
+            case "get_scoped_models": {
+                const enabled = session.settingsManager.getEnabledModels() ?? [];
+                const scoped = session.scopedModels.map((entry) => entry.model);
+                const models = scoped.length > 0 ? scoped : await session.modelRuntime.getAvailable();
+                return success(id, "get_scoped_models", { enabled, models: [...models] });
+            }
+            case "set_scoped_models": {
+                if (command.enabled !== undefined) {
+                    session.settingsManager.setEnabledModels(command.enabled.length > 0 ? command.enabled : undefined);
+                }
+                const enabled = session.settingsManager.getEnabledModels() ?? [];
+                if (command.reorder !== undefined && command.reorder.length > 0) {
+                    const patternSet = new Set(command.reorder);
+                    const kept = enabled.filter((pattern) => patternSet.has(pattern));
+                    const added = command.reorder.filter((pattern) => !kept.includes(pattern));
+                    session.settingsManager.setEnabledModels([...kept, ...added]);
+                }
+                await session.settingsManager.flush();
+                return success(id, "set_scoped_models", { enabled: session.settingsManager.getEnabledModels() ?? [] });
+            }
+            // =================================================================
+            // Session Import
+            // =================================================================
+            case "import_jsonl": {
+                try {
+                    await runtimeHost.importFromJsonl(command.path);
+                    await rebindSession();
+                    const sessionFile = session.sessionFile;
+                    return success(id, "import_jsonl", { sessionPath: sessionFile ?? command.path });
+                }
+                catch (importError) {
+                    return error(id, "import_jsonl", importError instanceof Error ? importError.message : String(importError));
+                }
+            }
+            // =================================================================
+            // Git helper
+            // =================================================================
+            case "git": {
+                const prompt = buildGitCommandPrompt(command.command);
+                let gitPreflightSucceeded = false;
+                void session
+                    .prompt(prompt, {
+                    streamingBehavior: "steer",
+                    source: "rpc",
+                    preflightResult: (didSucceed) => {
+                        if (didSucceed) {
+                            gitPreflightSucceeded = true;
+                            output(success(id, "git"));
+                        }
+                    },
+                })
+                    .catch((e) => {
+                    if (!gitPreflightSucceeded) {
+                        output(error(id, "git", e.message));
+                    }
+                });
+                return undefined;
+            }
+            // =================================================================
+            // Reload
+            // =================================================================
+            case "reload": {
+                if (session.isStreaming) {
+                    return error(id, "reload", "Wait for the current response to finish before reloading.");
+                }
+                if (session.isCompacting) {
+                    return error(id, "reload", "Wait for compaction to finish before reloading.");
+                }
+                try {
+                    await session.reload();
+                    return success(id, "reload");
+                }
+                catch (reloadError) {
+                    return error(id, "reload", reloadError instanceof Error ? reloadError.message : String(reloadError));
+                }
+            }
+            // =================================================================
+            // Tree ops
+            // =================================================================
+            case "set_entry_label": {
+                try {
+                    const labelId = session.sessionManager.appendLabelChange(command.entryId, command.label);
+                    return success(id, "set_entry_label", { labelId });
+                }
+                catch (labelError) {
+                    return error(id, "set_entry_label", labelError instanceof Error ? labelError.message : String(labelError));
+                }
+            }
+            // =================================================================
+            // Trust
+            // =================================================================
+            case "get_trust": {
+                const cwd = session.sessionManager.getCwd();
+                const trustStore = new ProjectTrustStore(runtimeHost.services.agentDir);
+                const entry = trustStore.getEntry(cwd);
+                return success(id, "get_trust", {
+                    cwd,
+                    savedDecision: entry ? { path: entry.path, decision: entry.decision } : null,
+                    projectTrusted: session.settingsManager.isProjectTrusted(),
+                    trustRequired: hasTrustRequiringProjectResources(cwd),
+                });
+            }
+            case "set_trust": {
+                const cwd = session.sessionManager.getCwd();
+                const trustStore = new ProjectTrustStore(runtimeHost.services.agentDir);
+                try {
+                    if (command.decision === null) {
+                        trustStore.set(cwd, null);
+                    }
+                    else {
+                        trustStore.set(cwd, command.decision);
+                    }
+                    return success(id, "set_trust", { decision: command.decision, restartRequired: command.decision !== null });
+                }
+                catch (trustError) {
+                    return error(id, "set_trust", trustError instanceof Error ? trustError.message : String(trustError));
+                }
+            }
+            // =================================================================
+            // Hotkeys / version / share
+            // =================================================================
+            case "get_hotkeys": {
+                const keybindings = KeybindingsManager.create();
+                const hotkeys = keybindings.getEffectiveConfig();
+                return success(id, "get_hotkeys", { hotkeys });
+            }
+            case "get_available_themes": {
+                // Mirror TUI startup: register extension/package themes before listing.
+                setRegisteredThemes(session.resourceLoader.getThemes().themes);
+                const themes = getAvailableThemesWithPaths().map(({ name, path }) => ({ name, path }));
+                const currentSetting = session.settingsManager.getThemeSetting();
+                const current = currentSetting?.includes("/") ? undefined : currentSetting;
+                return success(id, "get_available_themes", { themes, current });
+            }
+            case "get_version_info": {
+                const changelog = parseChangelog(getChangelogPath());
+                return success(id, "get_version_info", { version: VERSION, changelog });
+            }
+            case "share_gist": {
+                try {
+                    const authResult = spawnSync("gh", ["auth", "status"], { encoding: "utf-8" });
+                    if (authResult.status !== 0) {
+                        return error(id, "share_gist", "GitHub CLI is not logged in. Run 'gh auth login' first.");
+                    }
+                    const tmpFile = join(tmpdir(), `selesai-session-${crypto.randomUUID()}.html`);
+                    await session.exportToHtml(tmpFile, { themeName: command.themeName });
+                    const result = spawnSync("gh", ["gist", "create", "--public=false", tmpFile], { encoding: "utf-8" });
+                    try {
+                        unlinkSync(tmpFile);
+                    }
+                    catch {
+                        // best-effort cleanup
+                    }
+                    if (result.status !== 0) {
+                        return error(id, "share_gist", (result.stderr ?? "Unknown error").trim() || "Failed to create gist");
+                    }
+                    const gistUrl = (result.stdout ?? "").trim();
+                    const gistId = gistUrl.split("/").pop();
+                    if (!gistId) {
+                        return error(id, "share_gist", "Failed to parse gist ID from gh output");
+                    }
+                    const previewUrl = getShareViewerUrl(gistId);
+                    return success(id, "share_gist", { url: previewUrl, gistUrl });
+                }
+                catch (shareError) {
+                    return error(id, "share_gist", shareError instanceof Error ? shareError.message : String(shareError));
+                }
+            }
             default: {
                 const unknownCommand = command;
                 return error(id, unknownCommand.type, `Unknown command: ${unknownCommand.type}`);