claude-code-rust 0.14.0 → 0.14.2

package/README.md

@@ -18,14 +18,12 @@ Claude Code Rust replaces the stock Claude Code terminal interface with a native
 
 ## Prerequisite
 
-- Install the Claude Code CLI. You do not need to authenticate before installing or starting `claude-rs`; sign in later with `/login` or `claude auth login` when needed.
+- The Claude Code CLI must be installed as fallback for some SDK-unsupported features.
 
 ## Install
 
 ### Install script (recommended, v0.14.0+)
 
-The install script downloads a complete GitHub Release archive. It does not require Rust, Node.js, npm, or Bun on the user's machine.
-
 **macOS/Linux:**
 
 ```bash
@@ -40,15 +38,11 @@ powershell -NoProfile -ExecutionPolicy Bypass -Command "irm 'https://raw.githubu
 
 ### npm (global)
 
-npm remains supported for users who prefer package-manager ownership of the global command:
-
 ```bash
 npm install -g claude-code-rust
 ```
 
-This option requires Node.js 24 and npm. The npm package installs a small launcher plus a platform-specific optional dependency containing the prebuilt Rust binary, Agent SDK bridge, and bundled private Bun runtime for your OS and architecture. A separate Rust toolchain or Bun installation is not required.
-
-See the [installation guide](https://srothgan.github.io/claude-code-rust/installation.html) for release pinning, custom locations, switching install methods, and troubleshooting.
+See the [installation guide](https://srothgan.github.io/claude-code-rust/installation.html) for release pinning, custom install locations, switching install methods, uninstall, and troubleshooting.
 
 ## Usage
 
@@ -77,13 +71,15 @@ Claude Code Rust addresses these with a native terminal UI that uses diffed, dir
 
 ## Documentation
 
-The manual covers installation with scripts, npm, and source builds, plus help, slash commands, keyboard shortcuts, settings, diagnostics, architecture, and the changelog:
+The manual covers installation with scripts and npm, plus help, slash commands, keyboard shortcuts, settings, diagnostics, troubleshooting, building from source, architecture, and the changelog:
 
 - [Installation](https://srothgan.github.io/claude-code-rust/installation.html)
 - [Usage](https://srothgan.github.io/claude-code-rust/usage.html)
 - [Help](https://srothgan.github.io/claude-code-rust/help.html)
 - [Slash commands](https://srothgan.github.io/claude-code-rust/commands.html)
 - [Settings](https://srothgan.github.io/claude-code-rust/settings.html)
+- [Troubleshooting](https://srothgan.github.io/claude-code-rust/troubleshooting.html)
+- [Development](https://srothgan.github.io/claude-code-rust/development.html)
 
 ## Status
 

package/agent-sdk/dist/bridge/account_metadata.js

@@ -4,6 +4,7 @@ const KNOWN_API_PROVIDERS = new Set([
     "vertex",
     "foundry",
     "anthropicAws",
+    "anthropicGoogleCloud",
     "mantle",
     "gateway",
 ]);

package/agent-sdk/dist/bridge/available_commands.js

@@ -48,7 +48,7 @@ function shouldAcceptAvailableCommandsSnapshot(session, source, commands) {
     if (source === "supportedCommands" && current.commands.length > 0) {
         return {
             accept: false,
-            reason: "supportedCommands is an initialize-time fallback and current snapshot already exists",
+            reason: "supportedCommands bootstrap cannot replace an existing snapshot",
         };
     }
     if (commands.length === 0) {

package/agent-sdk/dist/bridge/command_interactions.js

@@ -0,0 +1,16 @@
+import { handleElicitationResponse, handlePermissionResponse, handleQuestionResponse, handleUserDialogResponse, } from "./session_lifecycle.js";
+export function handleInteractionCommand(command) {
+    switch (command.command) {
+        case "permission_response":
+            handlePermissionResponse(command);
+            return;
+        case "question_response":
+            handleQuestionResponse(command);
+            return;
+        case "user_dialog_response":
+            handleUserDialogResponse(command);
+            return;
+        case "elicitation_response":
+            handleElicitationResponse(command);
+    }
+}

package/agent-sdk/dist/bridge/command_lifecycle.js

@@ -0,0 +1,184 @@
+import { getSessionMessages, listSessions, } from "@anthropic-ai/claude-agent-sdk";
+import { currentSessionListOptions, emitSessionsList, failConnection, setSessionListingDir, slashError, writeEvent, } from "./events.js";
+import { mapSessionMessagesToUpdates } from "./history.js";
+import { bridgeLogger, LOG_TARGETS } from "./logger.js";
+import { closeAllSessions, createSession, sessions, } from "./session_lifecycle.js";
+export async function handleLifecycleCommand(command, requestId, sdkVersionError) {
+    switch (command.command) {
+        case "initialize":
+            await initialize(command, requestId, sdkVersionError);
+            return;
+        case "create_session":
+            await create(command, requestId);
+            return;
+        case "resume_session":
+            await resume(command, requestId);
+            return;
+        case "new_session":
+            await replace(command, requestId);
+            return;
+        case "shutdown":
+            await shutdown(requestId);
+    }
+}
+async function initialize(command, requestId, sdkVersionError) {
+    if (sdkVersionError) {
+        bridgeLogger.error({
+            target: LOG_TARGETS.BRIDGE_LIFECYCLE,
+            eventName: "bridge_initialize_failed",
+            message: "bridge initialization failed due to unsupported SDK version",
+            outcome: "failure",
+            ...(requestId ? { requestId } : {}),
+            fields: { error_message: sdkVersionError },
+        });
+        failConnection(sdkVersionError, requestId);
+        return;
+    }
+    setSessionListingDir(command.cwd);
+    writeEvent({
+        event: "initialized",
+        result: {
+            agent_name: "claude-rs-agent-bridge",
+            agent_version: "0.1.0",
+            auth_methods: [
+                {
+                    id: "claude-login",
+                    name: "Log in with Claude",
+                    description: "Run `claude /login` in a terminal",
+                },
+            ],
+            capabilities: {
+                prompt_image: true,
+                prompt_embedded_context: true,
+                supports_session_listing: true,
+                supports_resume_session: true,
+            },
+        },
+    }, requestId);
+    await emitSessionsList(requestId);
+}
+async function create(command, requestId) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "session_create_requested",
+        message: "session creation requested",
+        outcome: "start",
+        ...(requestId ? { requestId } : {}),
+        fields: {
+            cwd: command.cwd,
+            resume_requested: command.resume !== undefined,
+        },
+    });
+    setSessionListingDir(command.cwd);
+    await createSession({
+        cwd: command.cwd,
+        resume: command.resume,
+        launchSettings: command.launch_settings,
+        connectEvent: "connected",
+        requestId,
+    });
+}
+async function resume(command, requestId) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "session_resume_requested",
+        message: "session resume requested",
+        outcome: "start",
+        ...(requestId ? { requestId } : {}),
+        sessionId: command.session_id,
+    });
+    try {
+        const sdkSessions = await listSessions(currentSessionListOptions());
+        const matched = sdkSessions.find((entry) => entry.sessionId === command.session_id);
+        if (!matched) {
+            bridgeLogger.warn({
+                target: LOG_TARGETS.APP_SESSION,
+                eventName: "session_resume_lookup_failed",
+                message: "session resume requested for an unknown session",
+                outcome: "failure",
+                ...(requestId ? { requestId } : {}),
+                sessionId: command.session_id,
+                fields: { reason: "unknown_session" },
+            });
+            slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+            return;
+        }
+        setSessionListingDir(matched.cwd ?? process.cwd());
+        const historyMessages = await getSessionMessages(command.session_id, matched.cwd
+            ? { dir: matched.cwd, includeSystemMessages: true }
+            : { includeSystemMessages: true });
+        const resumeUpdates = mapSessionMessagesToUpdates(historyMessages);
+        const staleSessions = Array.from(sessions.values());
+        const hadActiveSession = staleSessions.length > 0;
+        bridgeLogger.info({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "session_resume_history_loaded",
+            message: "session resume history loaded",
+            outcome: "success",
+            ...(requestId ? { requestId } : {}),
+            sessionId: command.session_id,
+            fields: {
+                history_update_count: resumeUpdates.length,
+                stale_session_count: staleSessions.length,
+            },
+        });
+        await createSession({
+            cwd: matched.cwd ?? process.cwd(),
+            resume: command.session_id,
+            launchSettings: command.launch_settings,
+            ...(resumeUpdates.length > 0 ? { resumeUpdates } : {}),
+            connectEvent: hadActiveSession ? "session_replaced" : "connected",
+            requestId,
+            ...(hadActiveSession ? { sessionsToCloseAfterConnect: staleSessions } : {}),
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        bridgeLogger.error({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "session_resume_failed",
+            message: "session resume failed",
+            outcome: "failure",
+            ...(requestId ? { requestId } : {}),
+            sessionId: command.session_id,
+            fields: { error_message: message },
+        });
+        slashError(command.session_id, `failed to resume session: ${message}`, requestId);
+    }
+}
+async function replace(command, requestId) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "session_new_requested",
+        message: "replacement session requested",
+        outcome: "start",
+        ...(requestId ? { requestId } : {}),
+        fields: { cwd: command.cwd },
+    });
+    await closeAllSessions({ reason: "new_session_requested", requestId });
+    setSessionListingDir(command.cwd);
+    await createSession({
+        cwd: command.cwd,
+        launchSettings: command.launch_settings,
+        connectEvent: "session_replaced",
+        requestId,
+    });
+}
+async function shutdown(requestId) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_LIFECYCLE,
+        eventName: "bridge_shutdown_requested",
+        message: "bridge shutdown requested",
+        outcome: "start",
+        ...(requestId ? { requestId } : {}),
+    });
+    await closeAllSessions({ reason: "bridge_shutdown_requested", requestId });
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_LIFECYCLE,
+        eventName: "bridge_shutdown_completed",
+        message: "bridge shutdown completed",
+        outcome: "success",
+        ...(requestId ? { requestId } : {}),
+    });
+    process.exit(0);
+}

package/agent-sdk/dist/bridge/command_mcp.js

@@ -0,0 +1,32 @@
+import { slashError } from "./events.js";
+import { handleMcpAuthenticateCommand, handleMcpClearAuthCommand, handleMcpOauthCallbackUrlCommand, handleMcpReconnectCommand, handleMcpSetServersCommand, handleMcpStatusCommand, handleMcpToggleCommand, } from "./mcp.js";
+import { sessionById } from "./session_lifecycle.js";
+export async function handleMcpCommand(command, requestId) {
+    const session = sessionById(command.session_id);
+    if (!session) {
+        slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+        return;
+    }
+    switch (command.command) {
+        case "mcp_status":
+            await handleMcpStatusCommand(session, requestId);
+            return;
+        case "mcp_reconnect":
+            await handleMcpReconnectCommand(session, command, requestId);
+            return;
+        case "mcp_toggle":
+            await handleMcpToggleCommand(session, command, requestId);
+            return;
+        case "mcp_set_servers":
+            await handleMcpSetServersCommand(session, command, requestId);
+            return;
+        case "mcp_authenticate":
+            await handleMcpAuthenticateCommand(session, command, requestId);
+            return;
+        case "mcp_clear_auth":
+            await handleMcpClearAuthCommand(session, command, requestId);
+            return;
+        case "mcp_oauth_callback_url":
+            await handleMcpOauthCallbackUrlCommand(session, command, requestId);
+    }
+}

package/agent-sdk/dist/bridge/command_scheduler.js

@@ -0,0 +1,136 @@
+const LIFECYCLE_COMMANDS = new Set([
+    "initialize",
+    "create_session",
+    "resume_session",
+    "new_session",
+    "rewind",
+    "shutdown",
+]);
+const UNBLOCKING_COMMANDS = new Set([
+    "cancel_turn",
+    "permission_response",
+    "question_response",
+    "user_dialog_response",
+    "elicitation_response",
+    "mcp_oauth_callback_url",
+]);
+function commandLane(command) {
+    if (UNBLOCKING_COMMANDS.has(command.command)) {
+        return { kind: "unblocking" };
+    }
+    if (LIFECYCLE_COMMANDS.has(command.command)) {
+        return { kind: "lifecycle" };
+    }
+    if ("session_id" in command) {
+        return { kind: "session", sessionId: command.session_id };
+    }
+    return { kind: "lifecycle" };
+}
+function settle(task) {
+    return task.then(() => undefined, () => undefined);
+}
+export class BridgeCommandScheduler {
+    lifecycleTail;
+    sessionTails = new Map();
+    activeTasks = new Set();
+    shutdownState = "accepting";
+    schedule(command, task) {
+        const lane = commandLane(command);
+        if (!this.accepts(command, lane)) {
+            return undefined;
+        }
+        let scheduledTask = task;
+        if (command.command === "shutdown") {
+            this.shutdownState = "queued";
+            scheduledTask = async () => {
+                this.shutdownState = "running";
+                try {
+                    await task();
+                }
+                finally {
+                    this.shutdownState = "complete";
+                }
+            };
+        }
+        const operation = this.scheduleInLane(lane, scheduledTask);
+        this.track(operation);
+        return operation;
+    }
+    stopAccepting() {
+        if (this.shutdownState === "accepting") {
+            this.shutdownState = "complete";
+        }
+    }
+    async whenIdle() {
+        while (this.activeTasks.size > 0) {
+            await Promise.all(this.activeTasks);
+        }
+    }
+    accepts(command, lane) {
+        if (this.shutdownState === "accepting") {
+            return true;
+        }
+        return (this.shutdownState === "queued" &&
+            command.command !== "shutdown" &&
+            lane.kind === "unblocking");
+    }
+    scheduleInLane(lane, task) {
+        switch (lane.kind) {
+            case "unblocking":
+                return this.start(task);
+            case "lifecycle":
+                return this.scheduleLifecycle(task);
+            case "session":
+                return this.scheduleSession(lane.sessionId, task);
+        }
+    }
+    scheduleLifecycle(task) {
+        const dependencies = new Set(this.sessionTails.values());
+        if (this.lifecycleTail) {
+            dependencies.add(this.lifecycleTail);
+        }
+        const operation = dependencies.size === 0 ? this.start(task) : Promise.all(dependencies).then(task);
+        const tail = settle(operation);
+        this.lifecycleTail = tail;
+        void tail.then(() => {
+            if (this.lifecycleTail === tail) {
+                this.lifecycleTail = undefined;
+            }
+        });
+        return operation;
+    }
+    scheduleSession(sessionId, task) {
+        const dependencies = [];
+        if (this.lifecycleTail) {
+            dependencies.push(this.lifecycleTail);
+        }
+        const previousSessionTask = this.sessionTails.get(sessionId);
+        if (previousSessionTask) {
+            dependencies.push(previousSessionTask);
+        }
+        const operation = dependencies.length === 0 ? this.start(task) : Promise.all(dependencies).then(task);
+        const tail = settle(operation);
+        this.sessionTails.set(sessionId, tail);
+        void tail.then(() => {
+            if (this.sessionTails.get(sessionId) === tail) {
+                this.sessionTails.delete(sessionId);
+            }
+        });
+        return operation;
+    }
+    track(operation) {
+        const tracked = settle(operation);
+        this.activeTasks.add(tracked);
+        void tracked.then(() => {
+            this.activeTasks.delete(tracked);
+        });
+    }
+    start(task) {
+        try {
+            return task();
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+}