claude-code-rust 0.3.0 → 0.4.0

package/README.md

@@ -8,12 +8,11 @@ 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 the [ACP (Agent Client Protocol)](https://github.com/nicolo-ribaudo/agent-client-protocol) Rust SDK, spawning Zed's `@zed-industries/claude-code-acp` adapter as a child process. 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 (`agent-sdk/dist/bridge.js`). Core Claude Code functionality - tool calls, file editing, terminal commands, and permissions - works unchanged.
 
 ## Requisites
 
-- Rust 1.88.0+ (install via [rustup](https://rustup.rs), required for source builds and Cargo installs)
-- Node.js 18+ with npx (for the ACP adapter)
+- Node.js 18+ (for the Agent SDK bridge)
 - Existing Claude Code authentication (`~/.claude/config.json`)
 
 ## Install
@@ -27,17 +26,6 @@ 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`.
 
-### Cargo (crates.io)
-
-```bash
-cargo install claude-code-rust
-```
-
-If `claude-rs` is not found after Cargo install, add your Cargo bin directory
-to `PATH` and restart the terminal:
-- Windows: `%USERPROFILE%\\.cargo\\bin` (or your custom `CARGO_HOME\\bin`)
-- macOS/Linux: `$HOME/.cargo/bin`
-
 ## Usage
 
 ```bash
@@ -60,16 +48,16 @@ Claude Code Rust fixes all of these by compiling to a single native binary with
 
 Three-layer design:
 
-**Presentation** (Rust/Ratatui) - Single binary with an async event loop (Tokio) handling keyboard input and ACP messages concurrently. Virtual-scrolled chat history with syntax-highlighted code blocks.
+**Presentation** (Rust/Ratatui) - Single binary with an async event loop (Tokio) handling keyboard input and bridge client events concurrently. Virtual-scrolled chat history with syntax-highlighted code blocks.
 
-**Protocol** (ACP over stdio) - Spawns the Zed ACP adapter as a child process and communicates via JSON-RPC over stdin/stdout. Bidirectional streaming for user messages and response chunks. ACP futures are `!Send`, so all protocol code runs in a `tokio::task::LocalSet` with `mpsc` channels to the UI.
+**Protocol Bridge** (stdio JSON envelopes) - Spawns `agent-sdk/dist/bridge.js` as a child process and communicates via line-delimited JSON envelopes over stdin/stdout. Bidirectional streaming for user messages, tool updates, and permission requests.
 
-**Agent** (Zed ACP Adapter) - TypeScript/npm package by Zed Industries. Manages Claude API authentication, reads `~/.claude/config.json`, and handles tool execution.
+**Agent Runtime** (Anthropic Agent SDK) - The TypeScript bridge drives `@anthropic-ai/claude-agent-sdk`, which manages authentication, session/query lifecycle, and tool execution.
 
 ## Known Limitations
 
-- Token usage and cost tracking are currently unavailable because the ACP adapter does not emit usage events yet.
-- Session resume via `--resume` is currently blocked on an upstream ACP adapter release containing the Windows path encoding fix.
+- Token usage and cost tracking can be partial when upstream runtime events do not include full usage data.
+- Session resume via `--resume` depends on runtime support and account/session availability.
 - `/login` and `/logout` are intentionally not offered in command discovery for this release.
 
 ## Status
@@ -79,7 +67,7 @@ This project is pre-1.0 and under active development. See [CONTRIBUTING.md](CONT
 ## License
 
 This project is licensed under the [GNU Affero General Public License v3.0 or later](LICENSE).
-This license was chosen because Claude Code is not publicly available, and this project is not intended as an alternative distribution of Anthropic's proprietary implementation.
+This license was chosen because Claude Code is not open-source and this license allows everyone to use it while stopping Antrophic from implementing it in their clsosed-source version.
 
 By using this software, you agree to the terms of the AGPL-3.0. If you modify this software and make it available over a network, you must offer the source code to users of that service.
 

package/agent-sdk/README.md

@@ -0,0 +1,13 @@
+# claude-rs agent-sdk bridge
+
+Initial scaffold for the NDJSON stdio bridge that will connect Rust (`claude-code-rust`) with `@anthropic-ai/claude-agent-sdk`.
+
+## Local build
+
+```bash
+npm install
+npm run build
+```
+
+Build output is written to `dist/bridge.mjs`.
+

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

@@ -0,0 +1,7 @@
+export function looksLikeAuthRequired(input) {
+    const normalized = input.toLowerCase();
+    return (normalized.includes("/login") ||
+        normalized.includes("auth required") ||
+        normalized.includes("authentication failed") ||
+        normalized.includes("please log in"));
+}

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

@@ -0,0 +1,163 @@
+const MODE_NAMES = {
+    default: "Default",
+    acceptEdits: "Accept Edits",
+    bypassPermissions: "Bypass Permissions",
+    plan: "Plan",
+    dontAsk: "Don't Ask",
+};
+const MODE_OPTIONS = [
+    { id: "default", name: "Default", description: "Standard permission flow" },
+    { id: "acceptEdits", name: "Accept Edits", description: "Auto-approve edit operations" },
+    { id: "plan", name: "Plan", description: "No tool execution" },
+    { id: "dontAsk", name: "Don't Ask", description: "Reject non-approved tools" },
+    { id: "bypassPermissions", name: "Bypass Permissions", description: "Auto-approve all tools" },
+];
+function asRecord(value, context) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${context} must be an object`);
+    }
+    return value;
+}
+function expectString(record, key, context) {
+    const value = record[key];
+    if (typeof value !== "string") {
+        throw new Error(`${context}.${key} must be a string`);
+    }
+    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) {
+        return undefined;
+    }
+    if (typeof value !== "string") {
+        throw new Error(`${context}.${key} must be a string when provided`);
+    }
+    return value;
+}
+function optionalMetadata(record, key) {
+    const value = record[key];
+    if (value === undefined || value === null) {
+        return {};
+    }
+    return asRecord(value, `${key} metadata`);
+}
+function parsePromptChunks(record, context) {
+    const rawChunks = record.chunks;
+    if (!Array.isArray(rawChunks)) {
+        throw new Error(`${context}.chunks must be an array`);
+    }
+    return rawChunks.map((chunk, index) => {
+        const parsed = asRecord(chunk, `${context}.chunks[${index}]`);
+        const kind = expectString(parsed, "kind", `${context}.chunks[${index}]`);
+        return { kind, value: (parsed.value ?? null) };
+    });
+}
+export function parseCommandEnvelope(line) {
+    const raw = asRecord(JSON.parse(line), "command envelope");
+    const requestId = typeof raw.request_id === "string" ? raw.request_id : undefined;
+    const commandName = expectString(raw, "command", "command envelope");
+    const command = (() => {
+        switch (commandName) {
+            case "initialize":
+                return {
+                    command: "initialize",
+                    cwd: expectString(raw, "cwd", "initialize"),
+                    metadata: optionalMetadata(raw, "metadata"),
+                };
+            case "create_session":
+                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"),
+                    metadata: optionalMetadata(raw, "metadata"),
+                };
+            case "load_session":
+                return {
+                    command: "load_session",
+                    session_id: expectString(raw, "session_id", "load_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"),
+                };
+            case "prompt":
+                return {
+                    command: "prompt",
+                    session_id: expectString(raw, "session_id", "prompt"),
+                    chunks: parsePromptChunks(raw, "prompt"),
+                };
+            case "cancel_turn":
+                return {
+                    command: "cancel_turn",
+                    session_id: expectString(raw, "session_id", "cancel_turn"),
+                };
+            case "set_model":
+                return {
+                    command: "set_model",
+                    session_id: expectString(raw, "session_id", "set_model"),
+                    model: expectString(raw, "model", "set_model"),
+                };
+            case "set_mode":
+                return {
+                    command: "set_mode",
+                    session_id: expectString(raw, "session_id", "set_mode"),
+                    mode: expectString(raw, "mode", "set_mode"),
+                };
+            case "permission_response": {
+                const outcome = asRecord(raw.outcome, "permission_response.outcome");
+                const outcomeType = expectString(outcome, "outcome", "permission_response.outcome");
+                if (outcomeType !== "selected" && outcomeType !== "cancelled") {
+                    throw new Error("permission_response.outcome.outcome must be 'selected' or 'cancelled'");
+                }
+                const parsedOutcome = outcomeType === "selected"
+                    ? {
+                        outcome: "selected",
+                        option_id: expectString(outcome, "option_id", "permission_response.outcome"),
+                    }
+                    : { outcome: "cancelled" };
+                return {
+                    command: "permission_response",
+                    session_id: expectString(raw, "session_id", "permission_response"),
+                    tool_call_id: expectString(raw, "tool_call_id", "permission_response"),
+                    outcome: parsedOutcome,
+                };
+            }
+            case "shutdown":
+                return { command: "shutdown" };
+            default:
+                throw new Error(`unsupported command: ${commandName}`);
+        }
+    })();
+    return { requestId, command };
+}
+export function toPermissionMode(mode) {
+    if (mode === "default" ||
+        mode === "acceptEdits" ||
+        mode === "bypassPermissions" ||
+        mode === "plan" ||
+        mode === "dontAsk") {
+        return mode;
+    }
+    return null;
+}
+export function buildModeState(mode) {
+    return {
+        current_mode_id: mode,
+        current_mode_name: MODE_NAMES[mode],
+        available_modes: MODE_OPTIONS,
+    };
+}

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

@@ -0,0 +1,344 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { TOOL_RESULT_TYPES, buildToolResultFields, createToolCall, isToolUseBlockType } from "./tooling.js";
+import { asRecordOrNull } from "./shared.js";
+import { buildUsageUpdateFromResult } from "./usage.js";
+function normalizeUserPromptText(raw) {
+    let text = raw.replace(/<context[\s\S]*/gi, " ");
+    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+    text = text.replace(/\s+/g, " ").trim();
+    return text;
+}
+function truncateTextByChars(text, maxChars) {
+    const chars = Array.from(text);
+    if (chars.length <= maxChars) {
+        return text;
+    }
+    return chars.slice(0, maxChars).join("");
+}
+function firstUserMessageTitleFromRecord(record) {
+    if (record.type !== "user") {
+        return undefined;
+    }
+    const message = asRecordOrNull(record.message);
+    if (!message || message.role !== "user" || !Array.isArray(message.content)) {
+        return undefined;
+    }
+    const parts = [];
+    for (const item of message.content) {
+        const block = asRecordOrNull(item);
+        if (!block || block.type !== "text" || typeof block.text !== "string") {
+            continue;
+        }
+        const cleaned = normalizeUserPromptText(block.text);
+        if (!cleaned) {
+            continue;
+        }
+        parts.push(cleaned);
+        const combined = parts.join(" ");
+        if (Array.from(combined).length >= 180) {
+            return truncateTextByChars(combined, 180);
+        }
+    }
+    if (parts.length === 0) {
+        return undefined;
+    }
+    return truncateTextByChars(parts.join(" "), 180);
+}
+function extractSessionPreviewFromJsonl(filePath) {
+    let text;
+    try {
+        text = fs.readFileSync(filePath, "utf8");
+    }
+    catch {
+        return {};
+    }
+    let cwd;
+    let title;
+    const lines = text.split(/\r?\n/);
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (line.length === 0) {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const record = asRecordOrNull(parsed);
+        if (!record) {
+            continue;
+        }
+        if (!cwd && typeof record.cwd === "string" && record.cwd.trim().length > 0) {
+            cwd = record.cwd;
+        }
+        if (!title) {
+            title = firstUserMessageTitleFromRecord(record);
+        }
+        if (cwd && title) {
+            break;
+        }
+    }
+    return {
+        ...(cwd ? { cwd } : {}),
+        ...(title ? { title } : {}),
+    };
+}
+export function listRecentPersistedSessions(limit = 8) {
+    const root = path.join(os.homedir(), ".claude", "projects");
+    if (!fs.existsSync(root)) {
+        return [];
+    }
+    const candidates = [];
+    let projectDirs;
+    try {
+        projectDirs = fs.readdirSync(root, { withFileTypes: true }).filter((dirent) => dirent.isDirectory());
+    }
+    catch {
+        return [];
+    }
+    for (const dirent of projectDirs) {
+        const projectDir = path.join(root, dirent.name);
+        let sessionFiles;
+        try {
+            sessionFiles = fs
+                .readdirSync(projectDir, { withFileTypes: true })
+                .filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl"));
+        }
+        catch {
+            sessionFiles = [];
+        }
+        for (const sessionFile of sessionFiles) {
+            const sessionId = sessionFile.name.slice(0, -".jsonl".length);
+            if (!sessionId) {
+                continue;
+            }
+            let mtimeMs = 0;
+            try {
+                mtimeMs = fs.statSync(path.join(projectDir, sessionFile.name)).mtimeMs;
+            }
+            catch {
+                continue;
+            }
+            if (!Number.isFinite(mtimeMs) || mtimeMs <= 0) {
+                continue;
+            }
+            candidates.push({
+                session_id: sessionId,
+                cwd: "",
+                file_path: path.join(projectDir, sessionFile.name),
+                updated_at: new Date(mtimeMs).toISOString(),
+                sort_ms: mtimeMs,
+            });
+        }
+    }
+    candidates.sort((a, b) => b.sort_ms - a.sort_ms);
+    const deduped = [];
+    const seen = new Set();
+    for (const candidate of candidates) {
+        if (seen.has(candidate.session_id)) {
+            continue;
+        }
+        seen.add(candidate.session_id);
+        const preview = extractSessionPreviewFromJsonl(candidate.file_path);
+        const cwd = preview.cwd?.trim();
+        if (!cwd) {
+            continue;
+        }
+        deduped.push({
+            session_id: candidate.session_id,
+            cwd,
+            file_path: candidate.file_path,
+            ...(preview.title ? { title: preview.title } : {}),
+            ...(candidate.updated_at ? { updated_at: candidate.updated_at } : {}),
+            sort_ms: candidate.sort_ms,
+        });
+        if (deduped.length >= limit) {
+            break;
+        }
+    }
+    return deduped;
+}
+export function resolvePersistedSessionEntry(sessionId) {
+    if (sessionId.trim().length === 0 ||
+        sessionId.includes("/") ||
+        sessionId.includes("\\") ||
+        sessionId.includes("..")) {
+        return null;
+    }
+    const root = path.join(os.homedir(), ".claude", "projects");
+    if (!fs.existsSync(root)) {
+        return null;
+    }
+    let projectDirs;
+    try {
+        projectDirs = fs.readdirSync(root, { withFileTypes: true }).filter((dirent) => dirent.isDirectory());
+    }
+    catch {
+        return null;
+    }
+    let best = null;
+    for (const dirent of projectDirs) {
+        const filePath = path.join(root, dirent.name, `${sessionId}.jsonl`);
+        if (!fs.existsSync(filePath)) {
+            continue;
+        }
+        const preview = extractSessionPreviewFromJsonl(filePath);
+        const cwd = preview.cwd?.trim();
+        if (!cwd) {
+            continue;
+        }
+        let mtimeMs = 0;
+        try {
+            mtimeMs = fs.statSync(filePath).mtimeMs;
+        }
+        catch {
+            mtimeMs = 0;
+        }
+        if (!best || mtimeMs >= best.sort_ms) {
+            best = {
+                session_id: sessionId,
+                cwd,
+                file_path: filePath,
+                sort_ms: mtimeMs,
+            };
+        }
+    }
+    return best;
+}
+function persistedMessageCandidates(record) {
+    const candidates = [];
+    const topLevel = asRecordOrNull(record.message);
+    if (topLevel) {
+        candidates.push(topLevel);
+    }
+    const nested = asRecordOrNull(asRecordOrNull(asRecordOrNull(record.data)?.message)?.message);
+    if (nested) {
+        candidates.push(nested);
+    }
+    return candidates;
+}
+function pushResumeTextChunk(updates, role, text) {
+    if (!text.trim()) {
+        return;
+    }
+    if (role === "assistant") {
+        updates.push({ type: "agent_message_chunk", content: { type: "text", text } });
+        return;
+    }
+    updates.push({ type: "user_message_chunk", content: { type: "text", text } });
+}
+function pushResumeToolUse(updates, toolCalls, block) {
+    const toolUseId = typeof block.id === "string" ? block.id : "";
+    if (!toolUseId) {
+        return;
+    }
+    const name = typeof block.name === "string" ? block.name : "Tool";
+    const input = asRecordOrNull(block.input) ?? {};
+    const toolCall = createToolCall(toolUseId, name, input);
+    toolCall.status = "in_progress";
+    toolCalls.set(toolUseId, toolCall);
+    updates.push({ type: "tool_call", tool_call: toolCall });
+}
+function pushResumeToolResult(updates, toolCalls, block) {
+    const toolUseId = typeof block.tool_use_id === "string" ? block.tool_use_id : "";
+    if (!toolUseId) {
+        return;
+    }
+    const isError = Boolean(block.is_error);
+    const base = toolCalls.get(toolUseId);
+    const fields = buildToolResultFields(isError, block.content, base);
+    updates.push({ type: "tool_call_update", tool_call_update: { tool_call_id: toolUseId, fields } });
+    if (!base) {
+        return;
+    }
+    base.status = fields.status ?? base.status;
+    if (fields.raw_output) {
+        base.raw_output = fields.raw_output;
+    }
+    if (fields.content) {
+        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);
+    }
+}
+export function extractSessionHistoryUpdatesFromJsonl(filePath) {
+    let text;
+    try {
+        text = fs.readFileSync(filePath, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const updates = [];
+    const toolCalls = new Map();
+    const emittedUsageMessageIds = new Set();
+    const lines = text.split(/\r?\n/);
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (line.length === 0) {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const record = asRecordOrNull(parsed);
+        if (!record) {
+            continue;
+        }
+        for (const message of persistedMessageCandidates(record)) {
+            const role = message.role;
+            if (role !== "user" && role !== "assistant") {
+                continue;
+            }
+            const content = Array.isArray(message.content) ? message.content : [];
+            for (const item of content) {
+                const block = asRecordOrNull(item);
+                if (!block) {
+                    continue;
+                }
+                const blockType = typeof block.type === "string" ? block.type : "";
+                if (blockType === "thinking") {
+                    continue;
+                }
+                if (blockType === "text" && typeof block.text === "string") {
+                    pushResumeTextChunk(updates, role, block.text);
+                    continue;
+                }
+                if (isToolUseBlockType(blockType) && role === "assistant") {
+                    pushResumeToolUse(updates, toolCalls, block);
+                    continue;
+                }
+                if (TOOL_RESULT_TYPES.has(blockType)) {
+                    pushResumeToolResult(updates, toolCalls, block);
+                    continue;
+                }
+                if (blockType === "image") {
+                    pushResumeTextChunk(updates, role, "[image]");
+                }
+            }
+            pushResumeUsageUpdate(updates, message, emittedUsageMessageIds);
+        }
+    }
+    return updates;
+}