claude-code-rust 0.6.0 → 0.7.1

package/README.md

@@ -10,7 +10,7 @@ A native Rust terminal interface for Claude Code. Drop-in replacement for Anthro
 
 ## About
 
-Claude Code Rust replaces the stock Claude Code terminal interface with a native Rust binary built on [Ratatui](https://ratatui.rs/). It connects to the same Claude API through a local Agent SDK bridge (`agent-sdk/dist/bridge.js`). Core Claude Code functionality - tool calls, file editing, terminal commands, and permissions - works unchanged.
+Claude Code Rust replaces the stock Claude Code terminal interface with a native Rust binary built on [Ratatui](https://ratatui.rs/). It connects to the same Claude API through a local Agent SDK bridge. Core Claude Code functionality - tool calls, file editing, terminal commands, and permissions - works unchanged.
 
 ## Requisites
 
@@ -25,8 +25,11 @@ Claude Code Rust replaces the stock Claude Code terminal interface with a native
 npm install -g claude-code-rust
 ```
 
-The npm package installs a `claude-rs` command and downloads the matching
-prebuilt release binary for your platform during `postinstall`.
+The published package installs a `claude-rs` command and fetches the matching
+prebuilt release binary for your platform during install.
+
+If `claude-rs` resolves to an older global shim, ensure your npm global bin
+directory comes first on `PATH` or remove the stale shim before retrying.
 
 ## Usage
 
@@ -58,7 +61,7 @@ Three-layer design:
 
 ## Known Limitations
 
-- `/login` and `/logout` are intentionally not offered in command discovery for this release.
+- The config view includes the Settings tab but the Status, Usage, and MCP tabs are not yet implemented.
 
 ## Status
 

package/agent-sdk/README.md

@@ -10,4 +10,3 @@ npm run build
 ```
 
 Build output is written to `dist/bridge.mjs`.
-

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

@@ -0,0 +1,75 @@
+import { emitSessionUpdate } from "./events.js";
+function availableAgentsSignature(agents) {
+    return JSON.stringify(agents);
+}
+function normalizeAvailableAgentName(value) {
+    if (typeof value !== "string") {
+        return "";
+    }
+    return value.trim();
+}
+export function mapAvailableAgents(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const byName = new Map();
+    for (const entry of value) {
+        if (!entry || typeof entry !== "object") {
+            continue;
+        }
+        const record = entry;
+        const name = normalizeAvailableAgentName(record.name);
+        if (!name) {
+            continue;
+        }
+        const description = typeof record.description === "string" ? record.description : "";
+        const model = typeof record.model === "string" && record.model.trim().length > 0 ? record.model : undefined;
+        const existing = byName.get(name);
+        if (!existing) {
+            byName.set(name, { name, description, model });
+            continue;
+        }
+        if (existing.description.trim().length === 0 && description.trim().length > 0) {
+            existing.description = description;
+        }
+        if (!existing.model && model) {
+            existing.model = model;
+        }
+    }
+    return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+export function mapAvailableAgentsFromNames(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const byName = new Map();
+    for (const entry of value) {
+        const name = normalizeAvailableAgentName(entry);
+        if (!name || byName.has(name)) {
+            continue;
+        }
+        byName.set(name, { name, description: "" });
+    }
+    return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+export function emitAvailableAgentsIfChanged(session, agents) {
+    const signature = availableAgentsSignature(agents);
+    if (session.lastAvailableAgentsSignature === signature) {
+        return;
+    }
+    session.lastAvailableAgentsSignature = signature;
+    emitSessionUpdate(session.sessionId, { type: "available_agents_update", agents });
+}
+export function refreshAvailableAgents(session) {
+    if (typeof session.query.supportedAgents !== "function") {
+        return;
+    }
+    void session.query
+        .supportedAgents()
+        .then((agents) => {
+        emitAvailableAgentsIfChanged(session, mapAvailableAgents(agents));
+    })
+        .catch(() => {
+        // Best-effort only.
+    });
+}

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

@@ -25,13 +25,6 @@ function expectString(record, key, context) {
     }
     return value;
 }
-function expectBoolean(record, key, context) {
-    const value = record[key];
-    if (typeof value !== "boolean") {
-        throw new Error(`${context}.${key} must be a boolean`);
-    }
-    return value;
-}
 function optionalString(record, key, context) {
     const value = record[key];
     if (value === undefined || value === null) {
@@ -49,6 +42,45 @@ function optionalMetadata(record, key) {
     }
     return asRecord(value, `${key} metadata`);
 }
+function optionalLaunchSettings(record, key, context) {
+    const value = record[key];
+    if (value === undefined || value === null) {
+        return {};
+    }
+    const parsed = asRecord(value, `${context}.${key}`);
+    const model = optionalString(parsed, "model", `${context}.${key}`);
+    const language = optionalString(parsed, "language", `${context}.${key}`);
+    const permissionMode = optionalString(parsed, "permission_mode", `${context}.${key}`);
+    const thinkingMode = optionalThinkingMode(parsed, "thinking_mode", `${context}.${key}`);
+    const effortLevel = optionalEffortLevel(parsed, "effort_level", `${context}.${key}`);
+    return {
+        ...(model ? { model } : {}),
+        ...(language ? { language } : {}),
+        ...(permissionMode ? { permission_mode: permissionMode } : {}),
+        ...(thinkingMode ? { thinking_mode: thinkingMode } : {}),
+        ...(effortLevel ? { effort_level: effortLevel } : {}),
+    };
+}
+function optionalThinkingMode(record, key, context) {
+    const value = optionalString(record, key, context);
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "adaptive" || value === "disabled") {
+        return value;
+    }
+    throw new Error(`${context}.${key} must be "adaptive" or "disabled" when provided`);
+}
+function optionalEffortLevel(record, key, context) {
+    const value = optionalString(record, key, context);
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "low" || value === "medium" || value === "high") {
+        return value;
+    }
+    throw new Error(`${context}.${key} must be "low", "medium", or "high" when provided`);
+}
 function parsePromptChunks(record, context) {
     const rawChunks = record.chunks;
     if (!Array.isArray(rawChunks)) {
@@ -76,23 +108,22 @@ export function parseCommandEnvelope(line) {
                 return {
                     command: "create_session",
                     cwd: expectString(raw, "cwd", "create_session"),
-                    yolo: expectBoolean(raw, "yolo", "create_session"),
-                    model: optionalString(raw, "model", "create_session"),
                     resume: optionalString(raw, "resume", "create_session"),
+                    launch_settings: optionalLaunchSettings(raw, "launch_settings", "create_session"),
                     metadata: optionalMetadata(raw, "metadata"),
                 };
             case "resume_session":
                 return {
                     command: "resume_session",
                     session_id: expectString(raw, "session_id", "resume_session"),
+                    launch_settings: optionalLaunchSettings(raw, "launch_settings", "resume_session"),
                     metadata: optionalMetadata(raw, "metadata"),
                 };
             case "new_session":
                 return {
                     command: "new_session",
                     cwd: expectString(raw, "cwd", "new_session"),
-                    yolo: expectBoolean(raw, "yolo", "new_session"),
-                    model: optionalString(raw, "model", "new_session"),
+                    launch_settings: optionalLaunchSettings(raw, "launch_settings", "new_session"),
                 };
             case "prompt":
                 return {

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

@@ -0,0 +1,55 @@
+import { looksLikeAuthRequired } from "./auth.js";
+import { writeEvent } from "./events.js";
+import { emitSessionUpdate } from "./events.js";
+import { parseFastModeState } from "./state_parsing.js";
+export function emitAuthRequired(session, detail) {
+    if (session.authHintSent) {
+        return;
+    }
+    session.authHintSent = true;
+    writeEvent({
+        event: "auth_required",
+        method_name: "Claude Login",
+        method_description: detail && detail.trim().length > 0
+            ? detail
+            : "Type /login to authenticate.",
+    });
+}
+export function looksLikePlanLimitError(input) {
+    const normalized = input.toLowerCase();
+    return (normalized.includes("rate limit") ||
+        normalized.includes("rate-limit") ||
+        normalized.includes("max turns") ||
+        normalized.includes("max budget") ||
+        normalized.includes("quota") ||
+        normalized.includes("plan limit") ||
+        normalized.includes("too many requests") ||
+        normalized.includes("insufficient quota") ||
+        normalized.includes("429"));
+}
+export function classifyTurnErrorKind(subtype, errors, assistantError) {
+    const combined = errors.join("\n");
+    if (subtype === "error_max_turns" ||
+        subtype === "error_max_budget_usd" ||
+        assistantError === "billing_error" ||
+        assistantError === "rate_limit" ||
+        (combined.length > 0 && looksLikePlanLimitError(combined))) {
+        return "plan_limit";
+    }
+    if (assistantError === "authentication_failed" ||
+        errors.some((entry) => looksLikeAuthRequired(entry))) {
+        return "auth_required";
+    }
+    if (assistantError === "server_error") {
+        return "internal";
+    }
+    return "other";
+}
+export function emitFastModeUpdateIfChanged(session, value) {
+    const next = parseFastModeState(value);
+    if (!next || next === session.fastModeState) {
+        return;
+    }
+    session.fastModeState = next;
+    emitSessionUpdate(session.sessionId, { type: "fast_mode_update", fast_mode_state: next });
+}

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

@@ -0,0 +1,83 @@
+import { listSessions } from "@anthropic-ai/claude-agent-sdk";
+import { buildModeState } from "./commands.js";
+import { mapSdkSessions } from "./history.js";
+const SESSION_LIST_LIMIT = 50;
+export function writeEvent(event, requestId) {
+    const envelope = {
+        ...(requestId ? { request_id: requestId } : {}),
+        ...event,
+    };
+    process.stdout.write(`${JSON.stringify(envelope)}\n`);
+}
+export function failConnection(message, requestId) {
+    writeEvent({ event: "connection_failed", message }, requestId);
+}
+export function slashError(sessionId, message, requestId) {
+    writeEvent({ event: "slash_error", session_id: sessionId, message }, requestId);
+}
+export function emitSessionUpdate(sessionId, update) {
+    writeEvent({ event: "session_update", session_id: sessionId, update });
+}
+export function emitConnectEvent(session) {
+    const historyUpdates = session.resumeUpdates;
+    const connectEvent = session.connectEvent === "session_replaced"
+        ? {
+            event: "session_replaced",
+            session_id: session.sessionId,
+            cwd: session.cwd,
+            model_name: session.model,
+            available_models: session.availableModels,
+            mode: session.mode ? buildModeState(session.mode) : null,
+            ...(historyUpdates && historyUpdates.length > 0 ? { history_updates: historyUpdates } : {}),
+        }
+        : {
+            event: "connected",
+            session_id: session.sessionId,
+            cwd: session.cwd,
+            model_name: session.model,
+            available_models: session.availableModels,
+            mode: session.mode ? buildModeState(session.mode) : null,
+            ...(historyUpdates && historyUpdates.length > 0 ? { history_updates: historyUpdates } : {}),
+        };
+    writeEvent(connectEvent, session.connectRequestId);
+    session.connectRequestId = undefined;
+    session.connected = true;
+    session.authHintSent = false;
+    session.resumeUpdates = undefined;
+    const staleSessions = session.sessionsToCloseAfterConnect;
+    session.sessionsToCloseAfterConnect = undefined;
+    if (!staleSessions || staleSessions.length === 0) {
+        refreshSessionsList();
+        return;
+    }
+    void (async () => {
+        // Lazy import to break circular dependency at module-evaluation time.
+        const { sessions, closeSession } = await import("./session_lifecycle.js");
+        for (const stale of staleSessions) {
+            if (stale === session) {
+                continue;
+            }
+            if (sessions.get(stale.sessionId) === stale) {
+                sessions.delete(stale.sessionId);
+            }
+            await closeSession(stale);
+        }
+        refreshSessionsList();
+    })();
+}
+export async function emitSessionsList(requestId) {
+    try {
+        const sdkSessions = await listSessions({ limit: SESSION_LIST_LIMIT });
+        writeEvent({ event: "sessions_listed", sessions: mapSdkSessions(sdkSessions, SESSION_LIST_LIMIT) }, requestId);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`[sdk warn] listSessions failed: ${message}`);
+        writeEvent({ event: "sessions_listed", sessions: [] }, requestId);
+    }
+}
+export function refreshSessionsList() {
+    void emitSessionsList().catch(() => {
+        // Defensive no-op.
+    });
+}

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

@@ -1,6 +1,5 @@
 import { asRecordOrNull } from "./shared.js";
 import { TOOL_RESULT_TYPES, buildToolResultFields, createToolCall, isToolUseBlockType } from "./tooling.js";
-import { buildUsageUpdateFromResult } from "./usage.js";
 function nonEmptyTrimmed(value) {
     if (typeof value !== "string") {
         return undefined;
@@ -62,20 +61,6 @@ function pushResumeToolResult(updates, toolCalls, block) {
         base.content = fields.content;
     }
 }
-function pushResumeUsageUpdate(updates, message, emittedUsageMessageIds) {
-    const messageId = typeof message.id === "string" ? message.id : "";
-    if (messageId && emittedUsageMessageIds.has(messageId)) {
-        return;
-    }
-    const usageUpdate = buildUsageUpdateFromResult(message);
-    if (!usageUpdate) {
-        return;
-    }
-    updates.push(usageUpdate);
-    if (messageId) {
-        emittedUsageMessageIds.add(messageId);
-    }
-}
 function summaryFromSession(info) {
     return (nonEmptyTrimmed(info.summary) ??
         nonEmptyTrimmed(info.customTitle) ??
@@ -113,7 +98,6 @@ export function mapSdkSessions(infos, limit = 50) {
 export function mapSessionMessagesToUpdates(messages) {
     const updates = [];
     const toolCalls = new Map();
-    const emittedUsageMessageIds = new Set();
     for (const entry of messages) {
         const fallbackRole = entry.type === "assistant" ? "assistant" : "user";
         for (const message of messageCandidates(entry.message)) {
@@ -145,7 +129,6 @@ export function mapSessionMessagesToUpdates(messages) {
                     pushResumeTextChunk(updates, role, "[image]");
                 }
             }
-            pushResumeUsageUpdate(updates, message, emittedUsageMessageIds);
         }
     }
     return updates;