From 80f961a971ccae9c95711b756e9be719bf8aa7ae Mon Sep 17 00:00:00 2001 From: Raunak Raj <71929976+bajrangCoder@users.noreply.github.com> Date: Fri, 19 Jun 2026 18:18:01 +0530 Subject: [PATCH 1/3] feat: add custom session/replay for codex and opencode --- cli/src/agents/base.ts | 32 +++ cli/src/agents/codex-app-server.ts | 154 ++++++++++ cli/src/agents/codex.ts | 18 ++ cli/src/agents/events.ts | 10 + cli/src/agents/index.ts | 113 ++++++++ cli/src/agents/native-history.ts | 442 +++++++++++++++++++++++++++++ cli/src/agents/opencode.ts | 19 ++ cli/src/agents/types.ts | 11 + 8 files changed, 799 insertions(+) create mode 100644 cli/src/agents/codex-app-server.ts create mode 100644 cli/src/agents/native-history.ts diff --git a/cli/src/agents/base.ts b/cli/src/agents/base.ts index 7df04d5..544b215 100644 --- a/cli/src/agents/base.ts +++ b/cli/src/agents/base.ts @@ -29,6 +29,7 @@ import type { AgentDescriptor, AgentInfo, LoadSessionResult, + NativeSessionHistory, PromptCallbacks, PromptResult, StoredSession, @@ -621,6 +622,37 @@ export class ACP { return this.sessions.get(sessionId)?.session ?? null; } + /** Whether this adapter can read current history without ACP replay. */ + hasNativeSessionHistory(): boolean { + return false; + } + + /** + * Read the current transcript from the agent's own storage/API. + * Implementations must not return a Shellular-maintained cache. + */ + async readNativeSessionHistory( + _params: acp.LoadSessionRequest, + ): Promise { + throw new UnsupportedCapabilityError(this.id, "native session history"); + } + + seedSessionHistory( + sessionId: string, + cwd: string, + history: NativeSessionHistory, + ) { + const transcript = this.getTranscript(sessionId); + transcript.replaceMessages(history.messages); + const existing = this.sessions.get(sessionId); + this.sessions.set(sessionId, { + session: + existing?.session ?? + newAiSessionFromResponse({ sessionId }, path.resolve(cwd), sessionId), + messages: transcript.getMessages(), + }); + } + snapshotSession( params: acp.LoadSessionRequest, clientId?: string, diff --git a/cli/src/agents/codex-app-server.ts b/cli/src/agents/codex-app-server.ts new file mode 100644 index 0000000..c52684b --- /dev/null +++ b/cli/src/agents/codex-app-server.ts @@ -0,0 +1,154 @@ +import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process"; + +type JsonRpcId = number; + +interface PendingRequest { + resolve: (value: unknown) => void; + reject: (error: Error) => void; + timer: NodeJS.Timeout; +} + +interface JsonRpcResponse { + id?: JsonRpcId; + result?: unknown; + error?: { code?: number; message?: string }; + method?: string; +} + +/** Minimal persistent client for Codex's supported app-server JSONL transport. */ +export class CodexAppServer { + private process: ChildProcessWithoutNullStreams | null = null; + private pending = new Map(); + private nextId = 1; + private stdoutBuffer = ""; + private initializeTask: Promise | null = null; + + constructor(private readonly command: string) {} + + async readThread(threadId: string): Promise { + await this.initialize(); + return this.request("thread/read", { threadId, includeTurns: true }); + } + + destroy() { + this.failPending(new Error("Codex app-server stopped")); + this.process?.kill(); + this.process = null; + this.initializeTask = null; + this.stdoutBuffer = ""; + } + + private initialize() { + if (!this.initializeTask) { + this.initializeTask = this.start().catch((error) => { + this.destroy(); + throw error; + }); + } + return this.initializeTask; + } + + private async start() { + const child = spawn(this.command, ["app-server", "--stdio"], { + stdio: ["pipe", "pipe", "pipe"], + windowsHide: true, + }); + this.process = child; + child.stdout.setEncoding("utf8"); + child.stdout.on("data", (chunk: string) => this.consume(chunk)); + // Drain stderr so a verbose child can never block on a full pipe. + child.stderr.resume(); + child.on("error", (error) => this.failPending(error)); + child.on("exit", (code, signal) => { + this.process = null; + this.initializeTask = null; + this.failPending( + new Error( + `Codex app-server exited (${code ?? "no code"}, ${signal ?? "no signal"})`, + ), + ); + }); + + await this.request("initialize", { + clientInfo: { + name: "shellular", + title: "Shellular", + version: "1", + }, + capabilities: { + experimentalApi: true, + requestAttestation: false, + }, + }); + this.notify("initialized", {}); + } + + private request(method: string, params: unknown): Promise { + const id = this.nextId++; + return new Promise((resolve, reject) => { + const timer = setTimeout(() => { + this.pending.delete(id); + reject(new Error(`Codex app-server request timed out: ${method}`)); + }, 30_000); + this.pending.set(id, { resolve, reject, timer }); + try { + this.write({ id, method, params }); + } catch (error) { + clearTimeout(timer); + this.pending.delete(id); + reject(error instanceof Error ? error : new Error(String(error))); + } + }); + } + + private notify(method: string, params: unknown) { + this.write({ method, params }); + } + + private write(message: unknown) { + if (!this.process?.stdin.writable) { + throw new Error("Codex app-server is not running"); + } + this.process.stdin.write(`${JSON.stringify(message)}\n`); + } + + private consume(chunk: string) { + this.stdoutBuffer += chunk; + let newline = this.stdoutBuffer.indexOf("\n"); + while (newline >= 0) { + const line = this.stdoutBuffer.slice(0, newline).trim(); + this.stdoutBuffer = this.stdoutBuffer.slice(newline + 1); + if (line) this.handleLine(line); + newline = this.stdoutBuffer.indexOf("\n"); + } + } + + private handleLine(line: string) { + let message: JsonRpcResponse; + try { + message = JSON.parse(line) as JsonRpcResponse; + } catch { + return; + } + if (typeof message.id !== "number" || message.method) return; + const pending = this.pending.get(message.id); + if (!pending) return; + clearTimeout(pending.timer); + this.pending.delete(message.id); + if (message.error) { + pending.reject( + new Error(message.error.message ?? "Codex app-server request failed"), + ); + return; + } + pending.resolve(message.result); + } + + private failPending(error: Error) { + for (const request of this.pending.values()) { + clearTimeout(request.timer); + request.reject(error); + } + this.pending.clear(); + } +} diff --git a/cli/src/agents/codex.ts b/cli/src/agents/codex.ts index d6fb764..9be7bf7 100644 --- a/cli/src/agents/codex.ts +++ b/cli/src/agents/codex.ts @@ -1,9 +1,13 @@ import { BUILTIN_AGENT_DESCRIPTORS } from "./agents"; import { ACP } from "./base"; +import { CodexAppServer } from "./codex-app-server"; import type { AcpTranscriptOptions } from "./events"; +import { normalizeCodexHistory } from "./native-history"; import { normalizeCodexUserReplayMessage } from "./replay-normalization"; export class Codex extends ACP { + private readonly appServer = new CodexAppServer("codex"); + static create() { return new Codex(BUILTIN_AGENT_DESCRIPTORS.codex); } @@ -13,4 +17,18 @@ export class Codex extends ACP { normalizeUserReplayMessage: normalizeCodexUserReplayMessage, }; } + + override hasNativeSessionHistory(): boolean { + return true; + } + + override async readNativeSessionHistory(params: { sessionId: string }) { + const result = await this.appServer.readThread(params.sessionId); + return { messages: normalizeCodexHistory(result) }; + } + + override destroy() { + this.appServer.destroy(); + super.destroy(); + } } diff --git a/cli/src/agents/events.ts b/cli/src/agents/events.ts index 3abc3ec..0f93959 100644 --- a/cli/src/agents/events.ts +++ b/cli/src/agents/events.ts @@ -305,6 +305,16 @@ export class AcpTranscript { }); } + replaceMessages(messages: AcpMessage[]) { + this.messages = messages.map((message) => ({ + ...message, + parts: [...message.parts], + })); + this.currentUser = null; + this.currentAssistant = null; + this.toolParts.clear(); + } + beginTurn(prompt?: acp.PromptRequest["prompt"]) { this.currentUser = null; this.currentAssistant = null; diff --git a/cli/src/agents/index.ts b/cli/src/agents/index.ts index e3f74ba..b9f8dd7 100644 --- a/cli/src/agents/index.ts +++ b/cli/src/agents/index.ts @@ -20,6 +20,7 @@ import { AcpContentBlockSchema, MsgType } from "@shellular/protocol"; import { config } from "@/config"; import type { Connection } from "@/connection"; +import { logger } from "@/logger"; import { BUILTIN_AGENT_DESCRIPTORS, isAgentAvailable } from "./agents"; import { ACP } from "./base"; import { ClaudeCode } from "./claude-code"; @@ -500,6 +501,45 @@ export class AgentsManager { mcpServers: options.mcpServers ?? [], }; const key = this.sessionKey(agentId, sessionId); + if (agent.hasNativeSessionHistory()) { + try { + const runtimeWasLoaded = Boolean(agent.getSession(sessionId)); + const history = await agent.readNativeSessionHistory(loadParams); + agent.seedSessionHistory(sessionId, cwd, history); + const session = agent.getSession(sessionId) ?? { + id: sessionId, + createdAt: Date.now(), + updatedAt: Date.now(), + workspacePath: cwd, + }; + const snapshot = this.setSessionSnapshot(agentId, sessionId, { + backend: agentId, + session, + state: { configOptions: session.configOptions }, + runtimeState: this.rememberSessionRuntimeMetadata(agentId, session), + messages: history.messages, + updates: [], + revision: this.getSessionRevision(agentId, sessionId), + syncing: !runtimeWasLoaded, + }); + if (!runtimeWasLoaded) { + this.restoreNativeSessionRuntime( + clientId, + agentId, + sessionId, + cwd, + options, + history, + ); + } + return snapshot; + } catch (error) { + logger.warn( + `Native history read failed for ${agentId}; falling back to ACP replay`, + error, + ); + } + } const cached = this.sessionSnapshots.get(key); if (cached && !agent.hasActivePrompt()) { if (!agent.getSession(sessionId)) { @@ -639,6 +679,10 @@ export class AgentsManager { message: "Working", }, }); + const restoring = this.sessionLoadTasks.get( + this.sessionKey(agentId, sessionId), + ); + if (restoring) await restoring; if (!agent.getSession(sessionId)) { await this.ensureSessionRuntimeLoaded(clientId, agentId, sessionId); } @@ -1697,6 +1741,75 @@ export class AgentsManager { this.sessionLoadTasks.set(key, task); } + private restoreNativeSessionRuntime( + clientId: string, + agentId: AiBackend, + sessionId: string, + cwd: string, + options: Partial< + Omit[0], "sessionId" | "cwd"> + >, + history: { messages: AcpMessage[] }, + ) { + const key = this.sessionKey(agentId, sessionId); + const agent = this.sessionRuntimes.get(key); + if (!agent || this.sessionLoadTasks.has(key)) return; + const params = { + ...options, + sessionId, + cwd, + mcpServers: options.mcpServers ?? [], + }; + const restore = agent.capabilities?.sessionCapabilities?.resume + ? agent.resumeSession(params).then((result) => result.response) + : agent.loadSession(params, clientId).then((result) => result.response); + const task = restore + .then((response) => { + // ACP restore is the execution/control plane. Keep the transcript from + // the native authoritative read rather than its slower replay stream. + agent.seedSessionHistory(sessionId, cwd, history); + const session = agent.getSession(sessionId); + if (!session) return; + const snapshot = this.sessionSnapshots.get(key); + this.setSessionSnapshot(agentId, sessionId, { + backend: agentId, + session: { + ...session, + configOptions: response.configOptions ?? session.configOptions, + }, + state: { + ...(snapshot?.state ?? {}), + configOptions: response.configOptions ?? session.configOptions, + }, + runtimeState: this.getSessionRuntimeState(agentId, sessionId), + messages: history.messages, + updates: snapshot?.updates ?? [], + revision: this.getSessionRevision(agentId, sessionId), + syncing: false, + }); + }) + .catch((error) => { + logger.warn(`Unable to restore ${agentId} session ${sessionId}`, error); + this.emit(this.sessionClientIds.get(key) ?? clientId, agentId, { + type: "error", + properties: { + sessionId, + error: getErrorMessage(error), + }, + }); + }) + .finally(() => { + this.emit(this.sessionClientIds.get(key) ?? clientId, agentId, { + type: "session.status", + properties: { sessionId, syncing: false }, + }); + if (this.sessionLoadTasks.get(key) === task) { + this.sessionLoadTasks.delete(key); + } + }); + this.sessionLoadTasks.set(key, task); + } + private emitSessionSnapshot( agentId: AiBackend, sessionId: string, diff --git a/cli/src/agents/native-history.ts b/cli/src/agents/native-history.ts new file mode 100644 index 0000000..08d1bdd --- /dev/null +++ b/cli/src/agents/native-history.ts @@ -0,0 +1,442 @@ +import type { Message, Part } from "@opencode-ai/sdk/v2"; +import type { AcpMessage, AcpMessagePart } from "@shellular/protocol"; + +type OpenCodeEntry = { info: Message; parts: Part[] }; + +interface CodexThreadReadResult { + thread?: { + turns?: Array<{ + id: string; + startedAt?: number | null; + items?: Array & { id?: string; type?: string }>; + }>; + }; +} + +export function normalizeOpenCodeHistory( + entries: OpenCodeEntry[], +): AcpMessage[] { + const messages: AcpMessage[] = []; + for (const { info, parts } of entries) { + const normalizedParts = parts.flatMap(openCodePart); + const previous = messages[messages.length - 1]; + if (previous?.role === info.role) { + appendNormalizedParts(previous.parts, normalizedParts); + continue; + } + messages.push({ + id: info.id, + role: info.role, + timestamp: info.time.created, + parts: normalizedParts, + }); + } + return messages; +} + +export function normalizeCodexHistory(result: unknown): AcpMessage[] { + const thread = (result as CodexThreadReadResult | null)?.thread; + if (!thread?.turns) + throw new Error("Codex app-server returned no thread history"); + return thread.turns.flatMap((turn) => { + const messages: AcpMessage[] = []; + let assistant: AcpMessage | null = null; + for (const item of turn.items ?? []) { + if (item.type === "userMessage") { + assistant = null; + messages.push({ + id: item.id ?? `${turn.id}:user`, + role: "user", + timestamp: secondsToMs(turn.startedAt), + parts: codexUserParts(item.content), + }); + continue; + } + const parts = codexAssistantParts(item); + if (!parts.length) continue; + if (!assistant) { + assistant = { + id: `${turn.id}:assistant`, + role: "assistant", + timestamp: secondsToMs(turn.startedAt), + parts: [], + }; + messages.push(assistant); + } + appendNormalizedParts(assistant.parts, parts); + } + return messages; + }); +} + +function openCodePart(part: Part): AcpMessagePart[] { + switch (part.type) { + case "text": + return part.ignored ? [] : [{ type: "text", text: part.text }]; + case "reasoning": + return [{ type: "reasoning", content: part.text, summary: "Reasoning" }]; + case "file": { + if (part.mime.startsWith("image/")) { + return [ + { + id: part.id, + type: "image", + src: part.url, + alt: part.filename, + mime: part.mime, + }, + ]; + } + const path = + part.source?.type === "file" || part.source?.type === "symbol" + ? part.source.path + : part.url.replace(/^file:\/\//, ""); + return part.url.startsWith("http") + ? [ + { + id: part.id, + type: "web_reference", + url: part.url, + title: part.filename, + }, + ] + : [{ id: part.id, type: "file_reference", path }]; + } + case "tool": { + const output = + part.state.status === "completed" + ? part.state.output + : part.state.status === "error" + ? part.state.error + : undefined; + return [ + { + id: part.callID || part.id, + type: "tool_call", + name: inferOpenCodeToolKind(part.tool), + title: + ("title" in part.state ? part.state.title : undefined) ?? part.tool, + arguments: JSON.stringify(part.state.input, null, 2), + output, + status: normalizeToolStatus(part.state.status), + parts: + "attachments" in part.state + ? part.state.attachments?.flatMap(openCodePart) + : undefined, + }, + ]; + } + case "subtask": + return [ + { + id: part.id, + type: "tool_call", + name: "subtask", + title: part.description, + arguments: part.prompt, + status: "completed", + }, + ]; + default: + return []; + } +} + +function codexUserParts(value: unknown): AcpMessagePart[] { + if (!Array.isArray(value)) return []; + return value.flatMap((input): AcpMessagePart[] => { + if (!input || typeof input !== "object") return []; + const item = input as Record; + switch (item.type) { + case "text": + return typeof item.text === "string" + ? [{ type: "text", text: item.text }] + : []; + case "image": + return typeof item.url === "string" + ? [{ type: "image", src: item.url, alt: "Image" }] + : []; + case "localImage": + case "skill": + case "mention": + return typeof item.path === "string" + ? [{ type: "file_reference", path: item.path }] + : []; + default: + return []; + } + }); +} + +function codexAssistantParts( + item: Record & { id?: string; type?: string }, +): AcpMessagePart[] { + switch (item.type) { + case "agentMessage": + return typeof item.text === "string" + ? [{ type: "text", text: item.text }] + : []; + case "reasoning": { + const summary = stringArray(item.summary).join("\n"); + const content = stringArray(item.content).join("\n") || summary; + return content + ? [{ type: "reasoning", content, summary: summary || "Reasoning" }] + : []; + } + case "plan": + return typeof item.text === "string" + ? [{ type: "plan", content: item.text, summary: "Plan" }] + : []; + case "commandExecution": + return typeof item.command === "string" + ? [ + { + id: item.id, + type: "tool_call", + name: inferCommandKind(item.command), + title: formatCommandTitle(item.command), + arguments: json({ + command: item.command, + cwd: typeof item.cwd === "string" ? item.cwd : undefined, + }), + output: + typeof item.aggregatedOutput === "string" + ? item.aggregatedOutput + : undefined, + status: normalizeToolStatus(item.status), + }, + ] + : []; + case "fileChange": { + const changes = Array.isArray(item.changes) ? item.changes : []; + const paths = changes.flatMap((change) => + change && + typeof change === "object" && + typeof (change as Record).path === "string" + ? [(change as Record).path as string] + : [], + ); + return [ + { + id: item.id, + type: "tool_call", + name: "edit", + title: paths.length ? `Edit ${paths.join(", ")}` : "Edit", + arguments: json({ changes: paths }), + status: normalizeToolStatus(item.status), + parts: changes.flatMap(codexFileChange), + }, + ]; + } + case "mcpToolCall": + return [ + { + id: item.id, + type: "tool_call", + name: "other", + title: `Tool: ${String(item.server ?? "mcp")}/${String(item.tool ?? "tool")}`, + arguments: json(item.arguments ?? item.prompt), + output: json(item.result ?? item.contentItems ?? item.error), + status: normalizeToolStatus(item.status), + }, + ]; + case "dynamicToolCall": + case "collabAgentToolCall": + return [ + { + id: item.id, + type: "tool_call", + name: "other", + title: `Tool: ${String(item.tool ?? item.type)}`, + arguments: json(item.arguments ?? item.prompt), + output: json(item.result ?? item.contentItems ?? item.error), + status: normalizeToolStatus(item.status), + }, + ]; + case "webSearch": + return typeof item.query === "string" + ? [ + { + id: item.id, + type: "tool_call", + name: "search", + title: item.query, + arguments: item.query, + status: "completed", + }, + ] + : []; + case "imageView": + return typeof item.path === "string" + ? [ + { + id: item.id, + type: "tool_call", + name: "read", + title: `View ${item.path}`, + status: "completed", + parts: [{ type: "file_reference", path: item.path }], + }, + ] + : []; + case "imageGeneration": + return [ + { + id: item.id, + type: "tool_call", + name: "other", + title: "Image generation", + status: normalizeToolStatus(item.status), + parts: codexImageGenerationParts(item), + }, + ]; + default: + return []; + } +} + +function codexFileChange(change: unknown): AcpMessagePart[] { + if (!change || typeof change !== "object") return []; + const value = change as Record; + if (typeof value.path !== "string") return []; + const diffs = + typeof value.diff === "string" + ? unifiedDiffParts(value.path, value.diff) + : []; + return diffs.length + ? diffs + : [ + { + type: "file_change", + path: value.path, + kind: typeof value.kind === "string" ? value.kind : "update", + status: "completed", + }, + ]; +} + +function unifiedDiffParts(path: string, diff: string): AcpMessagePart[] { + const parts: AcpMessagePart[] = []; + let oldText = ""; + let newText = ""; + let inHunk = false; + const flush = () => { + if (!inHunk) return; + parts.push({ + type: "file_change", + path, + kind: "update", + diff: { old: oldText, new: newText }, + status: "completed", + }); + oldText = ""; + newText = ""; + }; + for (const line of diff.split(/(?<=\n)/)) { + if (line.startsWith("@@")) { + flush(); + inHunk = true; + continue; + } + if (!inHunk || line.startsWith("\\ No newline")) continue; + if (line.startsWith("-")) oldText += line.slice(1); + else if (line.startsWith("+")) newText += line.slice(1); + else if (line.startsWith(" ")) { + oldText += line.slice(1); + newText += line.slice(1); + } + } + flush(); + return parts; +} + +function codexImageGenerationParts( + item: Record, +): AcpMessagePart[] { + const parts: AcpMessagePart[] = []; + if (typeof item.revisedPrompt === "string" && item.revisedPrompt) { + parts.push({ type: "text", text: `Revised prompt: ${item.revisedPrompt}` }); + } + if (typeof item.result === "string" && item.result) { + parts.push({ + type: "image", + src: item.result.startsWith("data:") + ? item.result + : `data:image/png;base64,${item.result}`, + alt: "Generated image", + mime: "image/png", + }); + } + return parts; +} + +function appendNormalizedParts( + target: AcpMessagePart[], + parts: AcpMessagePart[], +) { + for (const part of parts) { + const previous = target[target.length - 1]; + if (part.type === "text" && previous?.type === "text") { + previous.text += part.text; + } else if (part.type === "reasoning" && previous?.type === "reasoning") { + previous.content += part.content; + } else { + target.push(part); + } + } +} + +function inferOpenCodeToolKind(tool: string) { + const normalized = tool.toLowerCase(); + if (/read|view/.test(normalized)) return "read"; + if (/write|edit|patch|apply/.test(normalized)) return "edit"; + if (/grep|glob|search|find|list/.test(normalized)) return "search"; + if (/bash|shell|exec|command/.test(normalized)) return "execute"; + return "other"; +} + +function inferCommandKind(command: string) { + const normalized = command.trim().toLowerCase(); + if (/^(cat|sed|head|tail|less|bat)\b/.test(normalized)) return "read"; + if (/^(rg|grep|find|fd|ls)\b/.test(normalized)) return "search"; + return "execute"; +} + +function formatCommandTitle(command: string) { + const normalized = command.trim().replace(/\s+/g, " "); + return normalized.length > 120 + ? `${normalized.slice(0, 117)}...` + : normalized; +} + +function normalizeToolStatus(value: unknown) { + switch (value) { + case "running": + case "inProgress": + case "in_progress": + return "in_progress"; + case "error": + case "failed": + case "declined": + return "failed"; + case "pending": + return "pending"; + default: + return "completed"; + } +} + +function stringArray(value: unknown) { + return Array.isArray(value) + ? value.filter((item): item is string => typeof item === "string") + : []; +} + +function secondsToMs(value: number | null | undefined) { + return typeof value === "number" ? value * 1000 : undefined; +} + +function json(value: unknown) { + if (value === undefined || value === null) return undefined; + return typeof value === "string" ? value : JSON.stringify(value, null, 2); +} diff --git a/cli/src/agents/opencode.ts b/cli/src/agents/opencode.ts index 9497790..d1bdb50 100644 --- a/cli/src/agents/opencode.ts +++ b/cli/src/agents/opencode.ts @@ -11,6 +11,7 @@ import { config } from "@/config"; import { BUILTIN_AGENT_DESCRIPTORS } from "./agents"; import { ACP } from "./base"; import { type AcpTranscriptOptions, acpSessionToAiSession } from "./events"; +import { normalizeOpenCodeHistory } from "./native-history"; import { normalizeUserFileAttachmentReplayMessage, shouldSkipOpenCodeReadReplayContent, @@ -113,6 +114,24 @@ export class OpenCode extends ACP { return this.#ocClient; } + override hasNativeSessionHistory(): boolean { + return true; + } + + override async readNativeSessionHistory(params: acp.LoadSessionRequest) { + await this.init(); + const response = await this.ocClient.session.messages({ + sessionID: params.sessionId, + directory: params.cwd, + }); + if (response.error) { + throw new Error( + `Unable to read OpenCode session history: ${JSON.stringify(response.error)}`, + ); + } + return { messages: normalizeOpenCodeHistory(response.data ?? []) }; + } + override async listSessionPage( params: acp.ListSessionsRequest = {}, ): Promise { diff --git a/cli/src/agents/types.ts b/cli/src/agents/types.ts index f215714..855c94d 100644 --- a/cli/src/agents/types.ts +++ b/cli/src/agents/types.ts @@ -90,6 +90,17 @@ export interface LoadSessionResult { messages: AcpMessage[]; } +/** + * An authoritative transcript read from an agent's native session API. + * + * Native history is deliberately not persisted by Shellular: another harness + * may update the same session at any time, so every attach must read from the + * agent that owns the session. + */ +export interface NativeSessionHistory { + messages: AcpMessage[]; +} + export interface PromptResult { response: acp.PromptResponse; messages: AcpMessage[]; From b6735cccc96cd03fe7c22eb4a2db6d36d91527e0 Mon Sep 17 00:00:00 2001 From: Raunak Raj <71929976+bajrangCoder@users.noreply.github.com> Date: Sat, 20 Jun 2026 00:00:31 +0530 Subject: [PATCH 2/3] pagination things --- cli/src/agents/base.ts | 3 +- cli/src/agents/codex-app-server.ts | 4 ++ cli/src/agents/codex.ts | 31 +++++++++-- cli/src/agents/index.ts | 53 +++++++++++++++--- cli/src/agents/native-history.ts | 88 ++++++++++++++++++++---------- cli/src/agents/opencode.ts | 7 ++- cli/src/agents/types.ts | 5 ++ protocol/src/ai-legacy.ts | 3 + 8 files changed, 151 insertions(+), 43 deletions(-) diff --git a/cli/src/agents/base.ts b/cli/src/agents/base.ts index 544b215..271c461 100644 --- a/cli/src/agents/base.ts +++ b/cli/src/agents/base.ts @@ -30,6 +30,7 @@ import type { AgentInfo, LoadSessionResult, NativeSessionHistory, + NativeSessionHistoryRequest, PromptCallbacks, PromptResult, StoredSession, @@ -632,7 +633,7 @@ export class ACP { * Implementations must not return a Shellular-maintained cache. */ async readNativeSessionHistory( - _params: acp.LoadSessionRequest, + _params: NativeSessionHistoryRequest, ): Promise { throw new UnsupportedCapabilityError(this.id, "native session history"); } diff --git a/cli/src/agents/codex-app-server.ts b/cli/src/agents/codex-app-server.ts index c52684b..cfb2020 100644 --- a/cli/src/agents/codex-app-server.ts +++ b/cli/src/agents/codex-app-server.ts @@ -30,6 +30,10 @@ export class CodexAppServer { return this.request("thread/read", { threadId, includeTurns: true }); } + async warmup(): Promise { + await this.initialize(); + } + destroy() { this.failPending(new Error("Codex app-server stopped")); this.process?.kill(); diff --git a/cli/src/agents/codex.ts b/cli/src/agents/codex.ts index 9be7bf7..9e91bdf 100644 --- a/cli/src/agents/codex.ts +++ b/cli/src/agents/codex.ts @@ -2,11 +2,23 @@ import { BUILTIN_AGENT_DESCRIPTORS } from "./agents"; import { ACP } from "./base"; import { CodexAppServer } from "./codex-app-server"; import type { AcpTranscriptOptions } from "./events"; -import { normalizeCodexHistory } from "./native-history"; +import { normalizeCodexHistoryPage } from "./native-history"; import { normalizeCodexUserReplayMessage } from "./replay-normalization"; +import type { NativeSessionHistoryRequest } from "./types"; + +const NATIVE_HISTORY_PAGE_SIZE = 30; export class Codex extends ACP { - private readonly appServer = new CodexAppServer("codex"); + private static readonly appServer = new CodexAppServer("codex"); + private readonly nativeHistory = new Map(); + + static destroyNativeHistoryRuntime() { + Codex.appServer.destroy(); + } + + static warmNativeHistoryRuntime() { + return Codex.appServer.warmup(); + } static create() { return new Codex(BUILTIN_AGENT_DESCRIPTORS.codex); @@ -22,13 +34,20 @@ export class Codex extends ACP { return true; } - override async readNativeSessionHistory(params: { sessionId: string }) { - const result = await this.appServer.readThread(params.sessionId); - return { messages: normalizeCodexHistory(result) }; + override async readNativeSessionHistory(params: NativeSessionHistoryRequest) { + let history = this.nativeHistory.get(params.sessionId); + if (!params.cursor || !history) { + history = await Codex.appServer.readThread(params.sessionId); + this.nativeHistory.set(params.sessionId, history); + } + const limit = params.limit ?? NATIVE_HISTORY_PAGE_SIZE; + return { + messages: normalizeCodexHistoryPage(history, params.cursor, limit), + }; } override destroy() { - this.appServer.destroy(); + this.nativeHistory.clear(); super.destroy(); } } diff --git a/cli/src/agents/index.ts b/cli/src/agents/index.ts index b9f8dd7..052e8f9 100644 --- a/cli/src/agents/index.ts +++ b/cli/src/agents/index.ts @@ -42,6 +42,7 @@ import type { AgentDescriptor, AgentInfo } from "./types"; const MAX_AGENT_ATTACHMENT_BYTES = 25 * 1024 * 1024; const RECENT_SESSION_ACTIVITY_MS = 10 * 60 * 1000; const SESSION_RUNTIME_IDLE_MS = 2 * 60 * 1000; +const NATIVE_HISTORY_PAGE_SIZE = 30; type RuntimePatch = Partial< Omit > & { @@ -351,6 +352,7 @@ export class AgentsManager { this.sessionRuntimes.delete(key); this.sessionRuntimeCleanupTimers.delete(key); } + if (agentId === "codex") Codex.destroyNativeHistoryRuntime(); } listActivities(agentId?: AiBackend) { @@ -407,6 +409,7 @@ export class AgentsManager { clientId: string, agentId: AiBackend, sessionId: string, + initialize = true, ) { const key = this.sessionKey(agentId, sessionId); if (!this.isAgentEnabled(agentId)) { @@ -423,7 +426,7 @@ export class AgentsManager { } this.cancelSessionRuntimeCleanup(agentId, sessionId); this.registerPermissionListener(agentId, clientId, agent); - await agent.init(); + if (initialize) await agent.init(); return agent; } @@ -433,6 +436,11 @@ export class AgentsManager { cwd?: string, cursor?: string, ): Promise<{ sessions: AiSession[]; nextCursor?: string }> { + if (agentId === "codex") { + void Codex.warmNativeHistoryRuntime().catch((error) => { + logger.debug("Unable to prewarm Codex native history", error); + }); + } const agent = await this.connectAgent(clientId, agentId); const result = await agent.listAiSessionsPage(cwd, cursor); for (const session of result.sessions) { @@ -491,7 +499,12 @@ export class AgentsManager { Omit[0], "sessionId" | "cwd"> > = {}, ) { - const agent = await this.connectSessionAgent(clientId, agentId, sessionId); + const agent = await this.connectSessionAgent( + clientId, + agentId, + sessionId, + false, + ); this.attachSessionClient(agentId, sessionId, clientId); this.rememberSessionClient(agentId, sessionId, clientId); const loadParams = { @@ -504,7 +517,10 @@ export class AgentsManager { if (agent.hasNativeSessionHistory()) { try { const runtimeWasLoaded = Boolean(agent.getSession(sessionId)); - const history = await agent.readNativeSessionHistory(loadParams); + const history = await agent.readNativeSessionHistory({ + ...loadParams, + limit: NATIVE_HISTORY_PAGE_SIZE, + }); agent.seedSessionHistory(sessionId, cwd, history); const session = agent.getSession(sessionId) ?? { id: sessionId, @@ -540,6 +556,7 @@ export class AgentsManager { ); } } + await agent.init(); const cached = this.sessionSnapshots.get(key); if (cached && !agent.hasActivePrompt()) { if (!agent.getSession(sessionId)) { @@ -819,6 +836,7 @@ export class AgentsManager { this.sessionRuntimes.clear(); this.sessionRuntimeCleanupTimers.clear(); this.sessionAgents.clear(); + Codex.destroyNativeHistoryRuntime(); } getAvailableAgents(): AiBackend[] { @@ -1341,14 +1359,29 @@ export class AgentsManager { msg.clientId, msg.data.backend, msg.data.sessionId, + false, ); + const messages = agent.hasNativeSessionHistory() + ? ( + await agent.readNativeSessionHistory({ + sessionId: msg.data.sessionId, + cwd: + msg.data.cwd ?? + agent.getSession(msg.data.sessionId)?.workspacePath ?? + ".", + mcpServers: [], + cursor: msg.data.cursor, + limit: msg.data.limit ?? NATIVE_HISTORY_PAGE_SIZE, + }) + ).messages + : agent.getMessages(msg.data.sessionId); conn.send({ type: MsgType.AI_MESSAGES_LIST_RESULT, clientId: msg.clientId, respTo: msg.id, data: { backend: msg.data.backend, - messages: agent.getMessages(msg.data.sessionId), + messages, }, }); } catch (err) { @@ -1760,9 +1793,15 @@ export class AgentsManager { cwd, mcpServers: options.mcpServers ?? [], }; - const restore = agent.capabilities?.sessionCapabilities?.resume - ? agent.resumeSession(params).then((result) => result.response) - : agent.loadSession(params, clientId).then((result) => result.response); + const restore = agent + .init() + .then(() => + agent.capabilities?.sessionCapabilities?.resume + ? agent.resumeSession(params).then((result) => result.response) + : agent + .loadSession(params, clientId) + .then((result) => result.response), + ); const task = restore .then((response) => { // ACP restore is the execution/control plane. Keep the transcript from diff --git a/cli/src/agents/native-history.ts b/cli/src/agents/native-history.ts index 08d1bdd..0301d2e 100644 --- a/cli/src/agents/native-history.ts +++ b/cli/src/agents/native-history.ts @@ -38,35 +38,67 @@ export function normalizeCodexHistory(result: unknown): AcpMessage[] { const thread = (result as CodexThreadReadResult | null)?.thread; if (!thread?.turns) throw new Error("Codex app-server returned no thread history"); - return thread.turns.flatMap((turn) => { - const messages: AcpMessage[] = []; - let assistant: AcpMessage | null = null; - for (const item of turn.items ?? []) { - if (item.type === "userMessage") { - assistant = null; - messages.push({ - id: item.id ?? `${turn.id}:user`, - role: "user", - timestamp: secondsToMs(turn.startedAt), - parts: codexUserParts(item.content), - }); - continue; - } - const parts = codexAssistantParts(item); - if (!parts.length) continue; - if (!assistant) { - assistant = { - id: `${turn.id}:assistant`, - role: "assistant", - timestamp: secondsToMs(turn.startedAt), - parts: [], - }; - messages.push(assistant); - } - appendNormalizedParts(assistant.parts, parts); + return thread.turns.flatMap(normalizeCodexTurn); +} + +export function normalizeCodexHistoryPage( + result: unknown, + before: string | undefined, + limit: number, +): AcpMessage[] { + const thread = (result as CodexThreadReadResult | null)?.thread; + if (!thread?.turns) + throw new Error("Codex app-server returned no thread history"); + const page: AcpMessage[] = []; + let foundCursor = before === undefined; + for (let index = thread.turns.length - 1; index >= 0; index -= 1) { + let turnMessages = normalizeCodexTurn(thread.turns[index]); + if (!foundCursor) { + const cursorIndex = turnMessages.findIndex( + (message) => message.id === before, + ); + if (cursorIndex < 0) continue; + foundCursor = true; + turnMessages = turnMessages.slice(0, cursorIndex); } - return messages; - }); + if (turnMessages.length > 0) page.unshift(...turnMessages); + if (page.length >= limit) return page.slice(-limit); + } + return foundCursor ? page : []; +} + +function normalizeCodexTurn( + turn: NonNullable< + NonNullable["turns"] + >[number], +): AcpMessage[] { + const messages: AcpMessage[] = []; + let assistant: AcpMessage | null = null; + for (const item of turn.items ?? []) { + if (item.type === "userMessage") { + assistant = null; + messages.push({ + id: item.id ?? `${turn.id}:user`, + role: "user", + timestamp: secondsToMs(turn.startedAt), + parts: codexUserParts(item.content), + }); + continue; + } + const parts = codexAssistantParts(item); + if (!parts.length) continue; + if (!assistant) { + assistant = { + id: `${turn.id}:assistant`, + role: "assistant", + timestamp: secondsToMs(turn.startedAt), + parts: [], + }; + messages.push(assistant); + } + appendNormalizedParts(assistant.parts, parts); + } + return messages; } function openCodePart(part: Part): AcpMessagePart[] { diff --git a/cli/src/agents/opencode.ts b/cli/src/agents/opencode.ts index d1bdb50..0eb4115 100644 --- a/cli/src/agents/opencode.ts +++ b/cli/src/agents/opencode.ts @@ -16,6 +16,9 @@ import { normalizeUserFileAttachmentReplayMessage, shouldSkipOpenCodeReadReplayContent, } from "./replay-normalization"; +import type { NativeSessionHistoryRequest } from "./types"; + +const NATIVE_HISTORY_PAGE_SIZE = 30; const OpenCodeSessionSchema = z.object({ id: z.string(), @@ -118,11 +121,13 @@ export class OpenCode extends ACP { return true; } - override async readNativeSessionHistory(params: acp.LoadSessionRequest) { + override async readNativeSessionHistory(params: NativeSessionHistoryRequest) { await this.init(); const response = await this.ocClient.session.messages({ sessionID: params.sessionId, directory: params.cwd, + limit: params.limit ?? NATIVE_HISTORY_PAGE_SIZE, + before: params.cursor, }); if (response.error) { throw new Error( diff --git a/cli/src/agents/types.ts b/cli/src/agents/types.ts index 855c94d..bb9d360 100644 --- a/cli/src/agents/types.ts +++ b/cli/src/agents/types.ts @@ -101,6 +101,11 @@ export interface NativeSessionHistory { messages: AcpMessage[]; } +export interface NativeSessionHistoryRequest extends acp.LoadSessionRequest { + cursor?: string; + limit?: number; +} + export interface PromptResult { response: acp.PromptResponse; messages: AcpMessage[]; diff --git a/protocol/src/ai-legacy.ts b/protocol/src/ai-legacy.ts index 52cc365..48e299e 100644 --- a/protocol/src/ai-legacy.ts +++ b/protocol/src/ai-legacy.ts @@ -276,6 +276,9 @@ export const AiMessagesListMsgSchema = z.object({ data: z.object({ backend: AiBackendSchema, sessionId: z.string(), + cwd: z.string().optional(), + cursor: z.string().optional(), + limit: z.number().int().positive().max(100).optional(), }), }); export type AiMessagesListMsg = z.infer; From 9468e2ace4cf2bc82b1dde442d129c55a56c62e8 Mon Sep 17 00:00:00 2001 From: Biraj Date: Tue, 23 Jun 2026 21:24:32 -0700 Subject: [PATCH 3/3] claude code agent sdk to load msgs faster --- cli/package.json | 1 + cli/src/agents/claude-code.ts | 27 ++ cli/src/agents/native-history.ts | 177 +++++++ pnpm-lock.yaml | 802 +++++++++++++++++++++++++++++++ 4 files changed, 1007 insertions(+) diff --git a/cli/package.json b/cli/package.json index 6468da7..e17640c 100644 --- a/cli/package.json +++ b/cli/package.json @@ -31,6 +31,7 @@ ], "dependencies": { "@agentclientprotocol/sdk": "0.26.0", + "@anthropic-ai/claude-agent-sdk": "^0.3.186", "@ff-labs/fff-node": "^0.6.4", "@inquirer/prompts": "^8.4.2", "@opencode-ai/sdk": "1.14.41", diff --git a/cli/src/agents/claude-code.ts b/cli/src/agents/claude-code.ts index dbf707a..a267191 100644 --- a/cli/src/agents/claude-code.ts +++ b/cli/src/agents/claude-code.ts @@ -1,8 +1,35 @@ +import { getSessionMessages } from "@anthropic-ai/claude-agent-sdk"; + import { BUILTIN_AGENT_DESCRIPTORS } from "./agents"; import { ACP } from "./base"; +import { normalizeClaudeCodeHistory } from "./native-history"; +import type { NativeSessionHistoryRequest } from "./types"; + +const NATIVE_HISTORY_PAGE_SIZE = 30; export class ClaudeCode extends ACP { static create() { return new ClaudeCode(BUILTIN_AGENT_DESCRIPTORS["claude-code"]); } + + override hasNativeSessionHistory(): boolean { + return true; + } + + override async readNativeSessionHistory(params: NativeSessionHistoryRequest) { + const all = await getSessionMessages(params.sessionId, { + ...(params.cwd ? { dir: params.cwd } : {}), + }); + const history = normalizeClaudeCodeHistory(all); + const limit = params.limit ?? NATIVE_HISTORY_PAGE_SIZE; + let page = history; + if (params.cursor) { + const cursorIndex = history.findIndex( + (message) => message.id === params.cursor, + ); + if (cursorIndex < 0) return { messages: [] }; + page = history.slice(0, cursorIndex); + } + return { messages: page.slice(-limit) }; + } } diff --git a/cli/src/agents/native-history.ts b/cli/src/agents/native-history.ts index 0301d2e..1dfe9ea 100644 --- a/cli/src/agents/native-history.ts +++ b/cli/src/agents/native-history.ts @@ -1,8 +1,185 @@ +import type { SessionMessage } from "@anthropic-ai/claude-agent-sdk"; import type { Message, Part } from "@opencode-ai/sdk/v2"; import type { AcpMessage, AcpMessagePart } from "@shellular/protocol"; type OpenCodeEntry = { info: Message; parts: Part[] }; +type ClaudeContentBlock = Record & { type?: string }; + +type ClaudeToolCallPart = { + id?: string; + type: "tool_call"; + name: string; + title?: string; + arguments?: string; + status?: string; + output?: string; + parts?: unknown[]; +}; + +/** + * Normalize Claude Code session messages (from `getSessionMessages`) into the + * ACP message shape. User entries whose content is purely `tool_result` blocks + * are folded back into the preceding assistant's `tool_call` parts rather than + * being rendered as standalone user turns. Subagent (`parent_tool_use_id != null`) + * entries are dropped from the main transcript to match the codex subtask + * treatment. + */ +export function normalizeClaudeCodeHistory( + entries: SessionMessage[], +): AcpMessage[] { + const messages: AcpMessage[] = []; + const pendingToolCalls = new Map(); + for (const entry of entries) { + if (entry.parent_tool_use_id) continue; + const content = (entry.message as { content?: unknown }).content; + const blocks = Array.isArray(content) + ? (content as ClaudeContentBlock[]) + : null; + if (!blocks) { + const text = typeof content === "string" ? content : undefined; + if (!text) continue; + maybeMerge(messages, "user", entry.uuid, [{ type: "text", text }]); + continue; + } + const parts: AcpMessagePart[] = []; + let onlyToolResults = true; + for (const block of blocks) { + const part = claudeBlockPart(block, pendingToolCalls); + if (part) { + parts.push(part); + if (block.type !== "tool_result") onlyToolResults = false; + } + } + if (entry.type === "user" && onlyToolResults) continue; + if (!parts.length) continue; + maybeMerge(messages, entry.type, entry.uuid, parts); + } + return messages; +} + +function maybeMerge( + target: AcpMessage[], + role: "user" | "assistant" | string, + id: string, + parts: AcpMessagePart[], +) { + const previous = target[target.length - 1]; + if (previous && previous.role === role) { + appendNormalizedParts(previous.parts, parts); + return; + } + target.push({ id, role: role as "user" | "assistant", parts }); +} + +function claudeBlockPart( + block: ClaudeContentBlock, + pending: Map, +): AcpMessagePart | null { + switch (block.type) { + case "text": + return typeof block.text === "string" + ? { type: "text", text: block.text } + : null; + case "thinking": + return typeof block.thinking === "string" + ? { type: "reasoning", content: block.thinking, summary: "Reasoning" } + : null; + case "tool_use": { + const id = typeof block.id === "string" ? block.id : undefined; + const name = typeof block.name === "string" ? block.name : "tool"; + const part: ClaudeToolCallPart = { + id, + type: "tool_call", + name: inferClaudeToolKind(name), + title: name, + arguments: json(block.input), + status: "in_progress", + }; + if (id) pending.set(id, part); + return part; + } + case "tool_result": { + const id = + typeof block.tool_use_id === "string" ? block.tool_use_id : undefined; + const existing = id ? pending.get(id) : undefined; + const output = claudeToolResultOutput(block.content); + const failed = typeof block.is_error === "boolean" && block.is_error; + if (existing) { + existing.output = output ?? existing.output; + if (failed) { + existing.status = "failed"; + } else if (existing.status === "in_progress") { + existing.status = "completed"; + } + if (id) pending.delete(id); + return null; + } + return { + id, + type: "tool_call", + name: "other", + title: "Tool result", + output, + status: failed ? "failed" : "completed", + }; + } + case "image": + return typeof block.source === "object" && block.source + ? { + type: "image", + src: claudeImageSrc(block.source as Record), + alt: "Image", + mime: + typeof (block.source as Record).media_type === + "string" + ? ((block.source as Record) + .media_type as string) + : "image/png", + } + : null; + default: + return null; + } +} + +function claudeToolResultOutput(content: unknown): string | undefined { + if (typeof content === "string") return content || undefined; + if (!Array.isArray(content)) return content ? json(content) : undefined; + return ( + content + .flatMap((block): string[] => { + if (!block || typeof block !== "object") return []; + const value = block as Record; + if (value.type === "text" && typeof value.text === "string") + return [value.text]; + if (value.type === "image") return ["[image]"]; + return []; + }) + .join("\n") || undefined + ); +} + +function claudeImageSrc(source: Record): string { + if (typeof source.data === "string") { + const media = + typeof source.media_type === "string" ? source.media_type : "image/png"; + return `data:${media};base64,${source.data}`; + } + if (typeof source.url === "string") return source.url; + return ""; +} + +function inferClaudeToolKind(name: string): string { + const normalized = name.toLowerCase(); + if (/read|notebookread|view|goto/.test(normalized)) return "read"; + if (/write|edit|update|patch|apply|notebookedit|multiedit/.test(normalized)) + return "edit"; + if (/grep|glob|search|find|list|nearest/.test(normalized)) return "search"; + if (/bash|shell|exec|command|run/.test(normalized)) return "execute"; + return "other"; +} + interface CodexThreadReadResult { thread?: { turns?: Array<{ diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 52074d8..f5fce0c 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -20,6 +20,9 @@ importers: '@agentclientprotocol/sdk': specifier: 0.26.0 version: 0.26.0(zod@4.3.6) + '@anthropic-ai/claude-agent-sdk': + specifier: ^0.3.186 + version: 0.3.186(@anthropic-ai/sdk@0.105.0(zod@4.3.6))(@modelcontextprotocol/sdk@1.29.0(zod@4.3.6))(zod@4.3.6) '@ff-labs/fff-node': specifier: ^0.6.4 version: 0.6.4 @@ -129,6 +132,67 @@ packages: peerDependencies: zod: ^3.25.0 || ^4.0.0 + '@anthropic-ai/claude-agent-sdk-darwin-arm64@0.3.186': + resolution: {integrity: sha512-xHlzB+61OJkLhrc5QJXVlpldwM9IXJAiQ7cCxWj9o0qu165eYtsGaAaWg9X9NAc9IWhtAdXXNpNSuiZNc+OzWw==} + cpu: [arm64] + os: [darwin] + + '@anthropic-ai/claude-agent-sdk-darwin-x64@0.3.186': + resolution: {integrity: sha512-+TJSWfoifLLW+7EEbvE4TIHbCj39PL8zEhL1gUudWQjLAgKxWeti+3h4FRDhPI1B/Uwz1eh/eY430od0iMXjfw==} + cpu: [x64] + os: [darwin] + + '@anthropic-ai/claude-agent-sdk-linux-arm64-musl@0.3.186': + resolution: {integrity: sha512-pLEaVXulWqHHEgfTwK/5EILSlxXMN5tRA54Ff0tRmEP/FGye8WhLMYrUqg8TSsM2e1bJSszRbyyJSK10xr9Qtg==} + cpu: [arm64] + os: [linux] + libc: [musl] + + '@anthropic-ai/claude-agent-sdk-linux-arm64@0.3.186': + resolution: {integrity: sha512-bkWmXR3PWcBTrAWAhmJn7+7/ONq/5sIEDe30D6a76qx6Xn8sZICmy9GrbUJec0Mb+XVifcS8LnLjP/Z5GzMc/g==} + cpu: [arm64] + os: [linux] + libc: [glibc] + + '@anthropic-ai/claude-agent-sdk-linux-x64-musl@0.3.186': + resolution: {integrity: sha512-Zg7htykMkMdQC/00UOPn/gnRJRyDaoY0AeJnyXLUByKEUd0ARshpQEadoJoAS6D//6CscffWaSTsX2ePSvl+aw==} + cpu: [x64] + os: [linux] + libc: [musl] + + '@anthropic-ai/claude-agent-sdk-linux-x64@0.3.186': + resolution: {integrity: sha512-ARPQwIliHwypU5FQcq4Epi5ahmbSJt89Use5BgzxyeDyrIM3NgK/0c1IKp8DAiKPNntVXNT5R01TwoHdNI3oBA==} + cpu: [x64] + os: [linux] + libc: [glibc] + + '@anthropic-ai/claude-agent-sdk-win32-arm64@0.3.186': + resolution: {integrity: sha512-P/OMuYtKYlgGYs0wMTGCSo8gQfCETfA+0+lGGMAcPMH1xxOn24gjtQ/fLQKdaVh+0DLaSxjYm9W3Ln5jN6ALlQ==} + cpu: [arm64] + os: [win32] + + '@anthropic-ai/claude-agent-sdk-win32-x64@0.3.186': + resolution: {integrity: sha512-aiBJu0rhlU/gvUsNtwxjIoj377Wj+g3HqoUe6eihcLGbvsR0SE5KpQaYT/B7wspRILegwIM+iUV9K7145SW6sA==} + cpu: [x64] + os: [win32] + + '@anthropic-ai/claude-agent-sdk@0.3.186': + resolution: {integrity: sha512-TbxhqYPDNluWL5C50pyHbUy2wWtwJs4iR8qQOxeVkRRTUWn3rdchzpSA8fLWiU+iyiyLDgxfPs6E79OWqrJ8Pw==} + engines: {node: '>=18.0.0'} + peerDependencies: + '@anthropic-ai/sdk': '>=0.93.0' + '@modelcontextprotocol/sdk': ^1.29.0 + zod: ^4.0.0 + + '@anthropic-ai/sdk@0.105.0': + resolution: {integrity: sha512-sDyu+aM9cE6uZE+HgRjjHRb+qqb87GHZOx+8bE0YlWetdL1YcVLxn8h9ltxGOflyChTe6PMEo50kMQV4cw0hfg==} + hasBin: true + peerDependencies: + zod: ^3.25.0 || ^4.0.0 + peerDependenciesMeta: + zod: + optional: true + '@babel/runtime@7.29.2': resolution: {integrity: sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g==} engines: {node: '>=6.9.0'} @@ -454,6 +518,12 @@ packages: cpu: [x64, arm64] os: [darwin, linux, win32] + '@hono/node-server@1.19.14': + resolution: {integrity: sha512-GwtvgtXxnWsucXvbQXkRgqksiH2Qed37H9xHZocE5sA3N8O8O8/8FA3uclQXxXVzc9XBZuEOMK7+r02FmSpHtw==} + engines: {node: '>=18.14.1'} + peerDependencies: + hono: ^4 + '@inquirer/ansi@2.0.5': resolution: {integrity: sha512-doc2sWgJpbFQ64UflSVd17ibMGDuxO1yKgOgLMwavzESnXjFWJqUeG8saYosqKpHp4kWiM5x1nXvEjbpx90gzw==} engines: {node: '>=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0'} @@ -616,6 +686,16 @@ packages: '@manypkg/get-packages@1.1.3': resolution: {integrity: sha512-fo+QhuU3qE/2TQMQmbVMqaQ6EWbMhi4ABWP+O4AM1NqPBuy0OrApV5LO6BrrgnhtAHS2NH6RrVk9OL181tTi8A==} + '@modelcontextprotocol/sdk@1.29.0': + resolution: {integrity: sha512-zo37mZA9hJWpULgkRpowewez1y6ML5GsXJPY8FI0tBBCd77HEvza4jDqRKOXgHNn867PVGCyTdzqpz0izu5ZjQ==} + engines: {node: '>=18'} + peerDependencies: + '@cfworker/json-schema': ^4.1.1 + zod: ^3.25 || ^4.0 + peerDependenciesMeta: + '@cfworker/json-schema': + optional: true + '@nodelib/fs.scandir@2.1.5': resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==} engines: {node: '>= 8'} @@ -781,6 +861,9 @@ packages: cpu: [x64] os: [win32] + '@stablelib/base64@1.0.1': + resolution: {integrity: sha512-1bnPQqSxSuc3Ii6MhBysoWCg58j97aUjuCSZrGSmDxNqtytIi0k8utUenAwTZN4V5mXXYGsVUI9zeBqy+jBOSQ==} + '@tootallnate/quickjs-emscripten@0.23.0': resolution: {integrity: sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==} @@ -884,6 +967,10 @@ packages: cpu: [x64] os: [win32] + accepts@2.0.0: + resolution: {integrity: sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==} + engines: {node: '>= 0.6'} + acorn@8.16.0: resolution: {integrity: sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==} engines: {node: '>=0.4.0'} @@ -893,6 +980,17 @@ packages: resolution: {integrity: sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==} engines: {node: '>= 14'} + ajv-formats@3.0.1: + resolution: {integrity: sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==} + peerDependencies: + ajv: ^8.0.0 + peerDependenciesMeta: + ajv: + optional: true + + ajv@8.20.0: + resolution: {integrity: sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==} + amp-message@0.1.2: resolution: {integrity: sha512-JqutcFwoU1+jhv7ArgW38bqrE+LQdcRv4NxNw0mp0JHQyB6tXesWRjtYKlDgHRY2o3JE5UTaBGUK8kSWUdxWUg==} @@ -970,6 +1068,10 @@ packages: bodec@0.1.0: resolution: {integrity: sha512-Ylo+MAo5BDUq1KA3f3R/MFhh+g8cnHmo8bz3YPGhI1znrMaf77ol1sfvYJzsw3nTE+Y2GryfDxBaR+AqpAkEHQ==} + body-parser@2.3.0: + resolution: {integrity: sha512-2cGmJupaNgg+QUwVLAucDuWuoMZ6EX9iHDRswZ5lsNYEmwPaRknMPCLZz07yTzVq/83p4o/wzbDZbBrTvGGTIw==} + engines: {node: '>=18'} + braces@3.0.3: resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==} engines: {node: '>=8'} @@ -983,10 +1085,22 @@ packages: peerDependencies: esbuild: '>=0.18' + bytes@3.1.2: + resolution: {integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==} + engines: {node: '>= 0.8'} + cac@6.7.14: resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==} engines: {node: '>=8'} + call-bind-apply-helpers@1.0.2: + resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==} + engines: {node: '>= 0.4'} + + call-bound@1.0.4: + resolution: {integrity: sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==} + engines: {node: '>= 0.4'} + chalk@3.0.0: resolution: {integrity: sha512-4D3B6Wf41KOYRFdszmDqMCGq5VV/uMAB273JILmO+3jAlh8X4qDtdtgCR3fxtbLEMzSx22QdhnDcJvu2u1fVwg==} engines: {node: '>=8'} @@ -1042,6 +1156,30 @@ packages: resolution: {integrity: sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA==} engines: {node: ^14.18.0 || >=16.10.0} + content-disposition@1.1.0: + resolution: {integrity: sha512-5jRCH9Z/+DRP7rkvY83B+yGIGX96OYdJmzngqnw2SBSxqCFPd0w2km3s5iawpGX8krnwSGmF0FW5Nhr0Hfai3g==} + engines: {node: '>=18'} + + content-type@1.0.5: + resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==} + engines: {node: '>= 0.6'} + + content-type@2.0.0: + resolution: {integrity: sha512-j/O/d7GcZCyNl7/hwZAb606rzqkyvaDctLmckbxLzHvFBzTJHuGEdodATcP3yIRoDrLHkIATJuvzbFlp/ki2cQ==} + engines: {node: '>=18'} + + cookie-signature@1.2.2: + resolution: {integrity: sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==} + engines: {node: '>=6.6.0'} + + cookie@0.7.2: + resolution: {integrity: sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==} + engines: {node: '>= 0.6'} + + cors@2.8.6: + resolution: {integrity: sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw==} + engines: {node: '>= 0.10'} + croner@4.1.97: resolution: {integrity: sha512-/f6gpQuxDaqXu+1kwQYSckUglPaOrHdbIlBAu0YuW8/Cdb45XwXYNUBXg3r/9Mo6n540Kn/smKcZWko5x99KrQ==} @@ -1094,6 +1232,10 @@ packages: resolution: {integrity: sha512-TllpMR/t0M5sqCXfj85i4XaAzxmS5tVA16dqvdkMwGmzI+dXLXnw3J+3Vdv7VKw+ThlTMboK6i9rnZ6Nntj5CQ==} engines: {node: '>= 14'} + depd@2.0.0: + resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==} + engines: {node: '>= 0.8'} + detect-indent@6.1.0: resolution: {integrity: sha512-reYkTUJAZb9gUuZ2RvVCNhVHdg62RHnJ7WJl8ftMi4diZ6NWlciOzQN88pUhSELEwflJht4oQDv0F0BMlwaYtA==} engines: {node: '>=8'} @@ -1106,6 +1248,17 @@ packages: resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==} engines: {node: '>=8'} + dunder-proto@1.0.1: + resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==} + engines: {node: '>= 0.4'} + + ee-first@1.1.1: + resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==} + + encodeurl@2.0.0: + resolution: {integrity: sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==} + engines: {node: '>= 0.8'} + end-of-stream@1.4.5: resolution: {integrity: sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==} @@ -1113,11 +1266,26 @@ packages: resolution: {integrity: sha512-rRqJg/6gd538VHvR3PSrdRBb/1Vy2YfzHqzvbhGIQpDRKIa4FgV/54b5Q1xYSxOOwKvjXweS26E0Q+nAMwp2pQ==} engines: {node: '>=8.6'} + es-define-property@1.0.1: + resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==} + engines: {node: '>= 0.4'} + + es-errors@1.3.0: + resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==} + engines: {node: '>= 0.4'} + + es-object-atoms@1.1.2: + resolution: {integrity: sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==} + engines: {node: '>= 0.4'} + esbuild@0.27.7: resolution: {integrity: sha512-IxpibTjyVnmrIQo5aqNpCgoACA/dTKLTlhMHihVHhdkxKyPO1uBBthumT0rdHmcsk9uMonIWS0m4FljWzILh3w==} engines: {node: '>=18'} hasBin: true + escape-html@1.0.3: + resolution: {integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==} + escodegen@2.1.0: resolution: {integrity: sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w==} engines: {node: '>=6.0'} @@ -1136,19 +1304,44 @@ packages: resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==} engines: {node: '>=0.10.0'} + etag@1.8.1: + resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==} + engines: {node: '>= 0.6'} + eventemitter2@6.4.9: resolution: {integrity: sha512-JEPTiaOt9f04oa6NOkc4aH+nVp5I3wEjpHbIPqfgCdD5v5bUzy7xQqwcVO2aDQgOWhI28da57HksMrzK9HlRxg==} + eventsource-parser@3.1.0: + resolution: {integrity: sha512-kJezFj9YFAMLeORyi7aCLxLbD5/qWMQnoMVlVPyHIll7lgRJCc3JVln9Vgl9nwQi0YkMnhdGTMNn7CkRRAptMg==} + engines: {node: '>=18.0.0'} + + eventsource@3.0.7: + resolution: {integrity: sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==} + engines: {node: '>=18.0.0'} + expand-template@2.0.3: resolution: {integrity: sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==} engines: {node: '>=6'} + express-rate-limit@8.5.2: + resolution: {integrity: sha512-5Kb34ipNX694DH48vN9irak1Qx30nb0PLYHXfJgw4YEjiC3ZEmZJhwOp+VfiCYwFzvFTdB9QkArYS5kXa2cx2A==} + engines: {node: '>= 16'} + peerDependencies: + express: '>= 4.11' + + express@5.2.1: + resolution: {integrity: sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==} + engines: {node: '>= 18'} + extendable-error@0.1.7: resolution: {integrity: sha512-UOiS2in6/Q0FK0R0q6UY9vYpQ21mr/Qn1KOnte7vsACuNJf514WvCCUHSRCPcgjPT2bAhNIJdlE6bVap1GKmeg==} extrareqp2@1.0.0: resolution: {integrity: sha512-Gum0g1QYb6wpPJCVypWP3bbIuaibcFiJcpuPM10YSXp/tzqi84x9PJageob+eN4xVRIOto4wjSGNLyMD54D2xA==} + fast-deep-equal@3.1.3: + resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==} + fast-glob@3.3.3: resolution: {integrity: sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==} engines: {node: '>=8.6.0'} @@ -1156,12 +1349,18 @@ packages: fast-json-patch@3.1.1: resolution: {integrity: sha512-vf6IHUX2SBcA+5/+4883dsIjpBTqmfBjmYiWK1savxQmFk4JfBMLa7ynTYOs1Rolp/T1betJxHiGD3g1Mn8lUQ==} + fast-sha256@1.3.0: + resolution: {integrity: sha512-n11RGP/lrWEFI/bWdygLxhI+pVeo1ZYIVwvvPkW7azl/rOy+F3HYRZ2K5zeE9mmkhQppyv9sQFx0JM9UabnpPQ==} + fast-string-truncated-width@3.0.3: resolution: {integrity: sha512-0jjjIEL6+0jag3l2XWWizO64/aZVtpiGE3t0Zgqxv0DPuxiMjvB3M24fCyhZUO4KomJQPj3LTSUnDP3GpdwC0g==} fast-string-width@3.0.2: resolution: {integrity: sha512-gX8LrtNEI5hq8DVUfRQMbr5lpaS4nMIWV+7XEbXk2b8kiQIizgnlr12B4dA3ZEx3308ze0O4Q1R+cHts8kyUJg==} + fast-uri@3.1.2: + resolution: {integrity: sha512-rVjf7ArG3LTk+FS6Yw81V1DLuZl1bRbNrev6Tmd/9RaroeeRRJhAt7jg/6YFxbvAQXUCavSoZhPPj6oOx+5KjQ==} + fast-wrap-ansi@0.2.0: resolution: {integrity: sha512-rLV8JHxTyhVmFYhBJuMujcrHqOT2cnO5Zxj37qROj23CP39GXubJRBUFF0z8KFK77Uc0SukZUf7JZhsVEQ6n8w==} @@ -1187,6 +1386,10 @@ packages: resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==} engines: {node: '>=8'} + finalhandler@2.1.1: + resolution: {integrity: sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA==} + engines: {node: '>= 18.0.0'} + find-up@4.1.0: resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==} engines: {node: '>=8'} @@ -1203,6 +1406,14 @@ packages: debug: optional: true + forwarded@0.2.0: + resolution: {integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==} + engines: {node: '>= 0.6'} + + fresh@2.0.0: + resolution: {integrity: sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==} + engines: {node: '>= 0.8'} + fs-constants@1.0.0: resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==} @@ -1219,6 +1430,17 @@ packages: engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} os: [darwin] + function-bind@1.1.2: + resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} + + get-intrinsic@1.3.0: + resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==} + engines: {node: '>= 0.4'} + + get-proto@1.0.1: + resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==} + engines: {node: '>= 0.4'} + get-tsconfig@4.14.0: resolution: {integrity: sha512-yTb+8DXzDREzgvYmh6s9vHsSVCHeC0G3PI5bEXNBHtmshPnO+S5O7qgLEOn0I5QvMy6kpZN8K1NKGyilLb93wA==} @@ -1248,6 +1470,10 @@ packages: resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==} engines: {node: '>=10'} + gopd@1.2.0: + resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==} + engines: {node: '>= 0.4'} + graceful-fs@4.2.11: resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==} @@ -1255,6 +1481,22 @@ packages: resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} engines: {node: '>=8'} + has-symbols@1.1.0: + resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==} + engines: {node: '>= 0.4'} + + hasown@2.0.4: + resolution: {integrity: sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==} + engines: {node: '>= 0.4'} + + hono@4.12.27: + resolution: {integrity: sha512-1yrb/+w6HWQJrUCLkJ2IF5jNIPvvFkblV5RNOYl6bV+OA6p9GLcMpHFFGTosSvHvcAUibuUukRqhlYI4z32C7Q==} + engines: {node: '>=16.9.0'} + + http-errors@2.0.1: + resolution: {integrity: sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==} + engines: {node: '>= 0.8'} + http-proxy-agent@7.0.2: resolution: {integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==} engines: {node: '>= 14'} @@ -1288,6 +1530,14 @@ packages: resolution: {integrity: sha512-XXADHxXmvT9+CRxhXg56LJovE+bmWnEWB78LB83VZTprKTmaC5QfruXocxzTZ2Kl0DNwKuBdlIhjL8LeY8Sf8Q==} engines: {node: '>= 12'} + ip-address@10.2.0: + resolution: {integrity: sha512-/+S6j4E9AHvW9SWMSEY9Xfy66O5PWvVEJ08O0y5JGyEKQpojb0K0GKpz/v5HJ/G0vi3D2sjGK78119oXZeE0qA==} + engines: {node: '>= 12'} + + ipaddr.js@1.9.1: + resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==} + engines: {node: '>= 0.10'} + is-binary-path@2.1.0: resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==} engines: {node: '>=8'} @@ -1304,6 +1554,9 @@ packages: resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==} engines: {node: '>=0.12.0'} + is-promise@4.0.0: + resolution: {integrity: sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==} + is-subdir@1.2.0: resolution: {integrity: sha512-2AT6j+gXe/1ueqbW6fLZJiIw3F8iXGJtt0yDrZaBhAZEG1raiTxKWU+IPqMCzQAXOUCKdA4UDMgacKH25XG2Cw==} engines: {node: '>=4'} @@ -1315,6 +1568,9 @@ packages: isexe@2.0.0: resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==} + jose@6.2.3: + resolution: {integrity: sha512-YYVDInQKFJfR/xa3ojUTl8c2KoTwiL1R5Wg9YCydwH0x0B9grbzlg5HC7mMjCtUJjbQ/YnGEZIhI5tCgfTb4Hw==} + joycon@3.1.1: resolution: {integrity: sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw==} engines: {node: '>=10'} @@ -1330,6 +1586,16 @@ packages: resolution: {integrity: sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==} hasBin: true + json-schema-to-ts@3.1.1: + resolution: {integrity: sha512-+DWg8jCJG2TEnpy7kOm/7/AxaYoaRbjVB4LFZLySZlWn8exGs3A4OLJR966cVvU26N7X9TWxl+Jsw7dzAqKT6g==} + engines: {node: '>=16'} + + json-schema-traverse@1.0.0: + resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==} + + json-schema-typed@8.0.2: + resolution: {integrity: sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA==} + json-stringify-safe@5.0.1: resolution: {integrity: sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==} @@ -1370,6 +1636,18 @@ packages: magic-string@0.30.21: resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==} + math-intrinsics@1.1.0: + resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==} + engines: {node: '>= 0.4'} + + media-typer@1.1.0: + resolution: {integrity: sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==} + engines: {node: '>= 0.8'} + + merge-descriptors@2.0.0: + resolution: {integrity: sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==} + engines: {node: '>=18'} + merge2@1.4.1: resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==} engines: {node: '>= 8'} @@ -1378,6 +1656,14 @@ packages: resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==} engines: {node: '>=8.6'} + mime-db@1.54.0: + resolution: {integrity: sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==} + engines: {node: '>= 0.6'} + + mime-types@3.0.2: + resolution: {integrity: sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==} + engines: {node: '>=18'} + mimic-response@3.1.0: resolution: {integrity: sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==} engines: {node: '>=10'} @@ -1413,6 +1699,10 @@ packages: napi-build-utils@2.0.0: resolution: {integrity: sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA==} + negotiator@1.0.0: + resolution: {integrity: sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==} + engines: {node: '>= 0.6'} + netmask@2.1.1: resolution: {integrity: sha512-eonl3sLUha+S1GzTPxychyhnUzKyeQkZ7jLjKrBagJgPla13F+uQ71HgpFefyHgqrjEbCPkDArxYsjY8/+gLKA==} engines: {node: '>= 0.4.0'} @@ -1438,6 +1728,14 @@ packages: resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==} engines: {node: '>=0.10.0'} + object-inspect@1.13.4: + resolution: {integrity: sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==} + engines: {node: '>= 0.4'} + + on-finished@2.4.1: + resolution: {integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==} + engines: {node: '>= 0.8'} + once@1.4.0: resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==} @@ -1478,6 +1776,10 @@ packages: pako@0.2.9: resolution: {integrity: sha512-NUcwaKxUxWrZLpDG+z/xZaCgQITkA/Dv4V/T6bw7VON6l1Xz/VnrBqrYjZQ12TamKHzITTfOEIYUj48y2KXImA==} + parseurl@1.3.3: + resolution: {integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==} + engines: {node: '>= 0.8'} + path-exists@4.0.0: resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==} engines: {node: '>=8'} @@ -1486,6 +1788,9 @@ packages: resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==} engines: {node: '>=8'} + path-to-regexp@8.4.2: + resolution: {integrity: sha512-qRcuIdP69NPm4qbACK+aDogI5CBDMi1jKe0ry5rSQJz8JVLsC7jV8XpiJjGRLLol3N+R5ihGYcrPLTno6pAdBA==} + path-type@4.0.0: resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==} engines: {node: '>=8'} @@ -1520,6 +1825,10 @@ packages: resolution: {integrity: sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==} engines: {node: '>= 6'} + pkce-challenge@5.0.1: + resolution: {integrity: sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ==} + engines: {node: '>=16.20.0'} + pkg-types@1.3.1: resolution: {integrity: sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==} @@ -1564,6 +1873,10 @@ packages: engines: {node: '>=10.13.0'} hasBin: true + proxy-addr@2.0.7: + resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==} + engines: {node: '>= 0.10'} + proxy-agent@6.5.0: resolution: {integrity: sha512-TmatMXdr2KlRiA2CyDu8GqR8EjahTG3aY3nXjdzFyoZbmB8hrBsTyMezhULIXKnC0jpfjlmiZ3+EaCzoInSu/A==} engines: {node: '>= 14'} @@ -1578,12 +1891,24 @@ packages: resolution: {integrity: sha512-EXtzRZmC+YGmGlDFbXKxQiMZNwCLEO6BANKXG4iCtSIM0yqc/pappSx3RIKr4r0uh5JsBckOXeKrB3Iz7mdQpQ==} hasBin: true + qs@6.15.2: + resolution: {integrity: sha512-Rzq0KEyX/w/tEybncDgdkZrJgVUsUMk3xjh3t5bv3S1HTAtg+uOYt72+ZfwiQwKdysThkTBdL/rTi6HDmX9Ddw==} + engines: {node: '>=0.6'} + quansync@0.2.11: resolution: {integrity: sha512-AifT7QEbW9Nri4tAwR5M/uzpBuqfZf+zwaEM/QkzEjj7NBuFD2rBuy0K3dE+8wltbezDV7JMA0WfnCPYRSYbXA==} queue-microtask@1.2.3: resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==} + range-parser@1.2.1: + resolution: {integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==} + engines: {node: '>= 0.6'} + + raw-body@3.0.2: + resolution: {integrity: sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==} + engines: {node: '>= 0.10'} + rc@1.2.8: resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==} hasBin: true @@ -1604,6 +1929,10 @@ packages: resolution: {integrity: sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==} engines: {node: '>= 14.18.0'} + require-from-string@2.0.2: + resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==} + engines: {node: '>=0.10.0'} + resolve-from@5.0.0: resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==} engines: {node: '>=8'} @@ -1620,6 +1949,10 @@ packages: engines: {node: '>=18.0.0', npm: '>=8.0.0'} hasBin: true + router@2.2.0: + resolution: {integrity: sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==} + engines: {node: '>= 18'} + run-parallel@1.2.0: resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==} @@ -1642,6 +1975,17 @@ packages: engines: {node: '>=10'} hasBin: true + send@1.2.1: + resolution: {integrity: sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ==} + engines: {node: '>= 18'} + + serve-static@2.2.1: + resolution: {integrity: sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw==} + engines: {node: '>= 18'} + + setprototypeof@1.2.0: + resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==} + shebang-command@2.0.0: resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==} engines: {node: '>=8'} @@ -1650,6 +1994,22 @@ packages: resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==} engines: {node: '>=8'} + side-channel-list@1.0.1: + resolution: {integrity: sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==} + engines: {node: '>= 0.4'} + + side-channel-map@1.0.1: + resolution: {integrity: sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==} + engines: {node: '>= 0.4'} + + side-channel-weakmap@1.0.2: + resolution: {integrity: sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==} + engines: {node: '>= 0.4'} + + side-channel@1.1.1: + resolution: {integrity: sha512-6x6dK6zJdpTzF4sQeNYxwtvBzf6Eg4GtlesS94HOvTudUeyK2WXAaIfmDgsyslYrRBeFIlsi54AYsFGUuhmvrQ==} + engines: {node: '>= 0.4'} + signal-exit@4.1.0: resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==} engines: {node: '>=14'} @@ -1690,6 +2050,13 @@ packages: sprintf-js@1.0.3: resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==} + standardwebhooks@1.0.0: + resolution: {integrity: sha512-BbHGOQK9olHPMvQNHWul6MYlrRTAOKn03rOe4A8O3CLWhNf4YHBqq2HJKKC+sfqpxiBY52pNeesD6jIiLDz8jg==} + + statuses@2.0.2: + resolution: {integrity: sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==} + engines: {node: '>= 0.8'} + string_decoder@1.3.0: resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==} @@ -1749,10 +2116,17 @@ packages: resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==} engines: {node: '>=8.0'} + toidentifier@1.0.1: + resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==} + engines: {node: '>=0.6'} + tree-kill@1.2.2: resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==} hasBin: true + ts-algebra@2.0.0: + resolution: {integrity: sha512-FPAhNPFMrkwz76P7cdjdmiShwMynZYN6SgOujD1urY4oNm80Ou9oMdmbR45LotcKOXoy7wSmHkRFE6Mxbrhefw==} + ts-interface-checker@0.1.13: resolution: {integrity: sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==} @@ -1793,6 +2167,10 @@ packages: tx2@1.0.5: resolution: {integrity: sha512-sJ24w0y03Md/bxzK4FU8J8JveYYUbSs2FViLJ2D/8bytSiyPRbuE3DyL/9UKYXTZlV3yXq0L8GLlhobTnekCVg==} + type-is@2.1.0: + resolution: {integrity: sha512-faYHw0anBbc/kWF3zFTEnxSFOAGUX9GFbOBthvDdLsIlEoWOFOtS0zgCiQYwIskL9iGXZL3kAXD8OoZ4GmMATA==} + engines: {node: '>= 18'} + typescript@6.0.3: resolution: {integrity: sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==} engines: {node: '>=14.17'} @@ -1808,9 +2186,17 @@ packages: resolution: {integrity: sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==} engines: {node: '>= 4.0.0'} + unpipe@1.0.0: + resolution: {integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==} + engines: {node: '>= 0.8'} + util-deprecate@1.0.2: resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==} + vary@1.1.2: + resolution: {integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==} + engines: {node: '>= 0.8'} + vizion@2.2.1: resolution: {integrity: sha512-sfAcO2yeSU0CSPFI/DmZp3FsFE9T+8913nv1xWBOyzODv13fwkn6Vl7HqxGpkr9F608M+8SuFId3s+BlZqfXww==} engines: {node: '>=4.0'} @@ -1847,6 +2233,11 @@ packages: utf-8-validate: optional: true + zod-to-json-schema@3.25.2: + resolution: {integrity: sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA==} + peerDependencies: + zod: ^3.25.28 || ^4 + zod@4.3.6: resolution: {integrity: sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==} @@ -1856,6 +2247,52 @@ snapshots: dependencies: zod: 4.3.6 + '@anthropic-ai/claude-agent-sdk-darwin-arm64@0.3.186': + optional: true + + '@anthropic-ai/claude-agent-sdk-darwin-x64@0.3.186': + optional: true + + '@anthropic-ai/claude-agent-sdk-linux-arm64-musl@0.3.186': + optional: true + + '@anthropic-ai/claude-agent-sdk-linux-arm64@0.3.186': + optional: true + + '@anthropic-ai/claude-agent-sdk-linux-x64-musl@0.3.186': + optional: true + + '@anthropic-ai/claude-agent-sdk-linux-x64@0.3.186': + optional: true + + '@anthropic-ai/claude-agent-sdk-win32-arm64@0.3.186': + optional: true + + '@anthropic-ai/claude-agent-sdk-win32-x64@0.3.186': + optional: true + + '@anthropic-ai/claude-agent-sdk@0.3.186(@anthropic-ai/sdk@0.105.0(zod@4.3.6))(@modelcontextprotocol/sdk@1.29.0(zod@4.3.6))(zod@4.3.6)': + dependencies: + '@anthropic-ai/sdk': 0.105.0(zod@4.3.6) + '@modelcontextprotocol/sdk': 1.29.0(zod@4.3.6) + zod: 4.3.6 + optionalDependencies: + '@anthropic-ai/claude-agent-sdk-darwin-arm64': 0.3.186 + '@anthropic-ai/claude-agent-sdk-darwin-x64': 0.3.186 + '@anthropic-ai/claude-agent-sdk-linux-arm64': 0.3.186 + '@anthropic-ai/claude-agent-sdk-linux-arm64-musl': 0.3.186 + '@anthropic-ai/claude-agent-sdk-linux-x64': 0.3.186 + '@anthropic-ai/claude-agent-sdk-linux-x64-musl': 0.3.186 + '@anthropic-ai/claude-agent-sdk-win32-arm64': 0.3.186 + '@anthropic-ai/claude-agent-sdk-win32-x64': 0.3.186 + + '@anthropic-ai/sdk@0.105.0(zod@4.3.6)': + dependencies: + json-schema-to-ts: 3.1.1 + standardwebhooks: 1.0.0 + optionalDependencies: + zod: 4.3.6 + '@babel/runtime@7.29.2': {} '@biomejs/biome@2.5.0': @@ -2153,6 +2590,10 @@ snapshots: '@ff-labs/fff-bin-win32-arm64': 0.6.4 '@ff-labs/fff-bin-win32-x64': 0.6.4 + '@hono/node-server@1.19.14(hono@4.12.27)': + dependencies: + hono: 4.12.27 + '@inquirer/ansi@2.0.5': {} '@inquirer/checkbox@5.1.4(@types/node@22.19.17)': @@ -2309,6 +2750,28 @@ snapshots: globby: 11.1.0 read-yaml-file: 1.1.0 + '@modelcontextprotocol/sdk@1.29.0(zod@4.3.6)': + dependencies: + '@hono/node-server': 1.19.14(hono@4.12.27) + ajv: 8.20.0 + ajv-formats: 3.0.1(ajv@8.20.0) + content-type: 1.0.5 + cors: 2.8.6 + cross-spawn: 7.0.6 + eventsource: 3.0.7 + eventsource-parser: 3.1.0 + express: 5.2.1 + express-rate-limit: 8.5.2(express@5.2.1) + hono: 4.12.27 + jose: 6.2.3 + json-schema-typed: 8.0.2 + pkce-challenge: 5.0.1 + raw-body: 3.0.2 + zod: 4.3.6 + zod-to-json-schema: 3.25.2(zod@4.3.6) + transitivePeerDependencies: + - supports-color + '@nodelib/fs.scandir@2.1.5': dependencies: '@nodelib/fs.stat': 2.0.5 @@ -2420,6 +2883,8 @@ snapshots: '@rollup/rollup-win32-x64-msvc@4.60.2': optional: true + '@stablelib/base64@1.0.1': {} + '@tootallnate/quickjs-emscripten@0.23.0': {} '@types/better-sqlite3@7.6.13': @@ -2481,10 +2946,26 @@ snapshots: '@yuuang/ffi-rs-win32-x64-msvc@1.3.2': optional: true + accepts@2.0.0: + dependencies: + mime-types: 3.0.2 + negotiator: 1.0.0 + acorn@8.16.0: {} agent-base@7.1.4: {} + ajv-formats@3.0.1(ajv@8.20.0): + optionalDependencies: + ajv: 8.20.0 + + ajv@8.20.0: + dependencies: + fast-deep-equal: 3.1.3 + fast-uri: 3.1.2 + json-schema-traverse: 1.0.0 + require-from-string: 2.0.2 + amp-message@0.1.2: dependencies: amp: 0.3.1 @@ -2553,6 +3034,20 @@ snapshots: bodec@0.1.0: {} + body-parser@2.3.0: + dependencies: + bytes: 3.1.2 + content-type: 2.0.0 + debug: 4.4.3 + http-errors: 2.0.1 + iconv-lite: 0.7.2 + on-finished: 2.4.1 + qs: 6.15.2 + raw-body: 3.0.2 + type-is: 2.1.0 + transitivePeerDependencies: + - supports-color + braces@3.0.3: dependencies: fill-range: 7.1.1 @@ -2567,8 +3062,20 @@ snapshots: esbuild: 0.27.7 load-tsconfig: 0.2.5 + bytes@3.1.2: {} + cac@6.7.14: {} + call-bind-apply-helpers@1.0.2: + dependencies: + es-errors: 1.3.0 + function-bind: 1.1.2 + + call-bound@1.0.4: + dependencies: + call-bind-apply-helpers: 1.0.2 + get-intrinsic: 1.3.0 + chalk@3.0.0: dependencies: ansi-styles: 4.3.0 @@ -2618,6 +3125,21 @@ snapshots: consola@3.4.2: {} + content-disposition@1.1.0: {} + + content-type@1.0.5: {} + + content-type@2.0.0: {} + + cookie-signature@1.2.2: {} + + cookie@0.7.2: {} + + cors@2.8.6: + dependencies: + object-assign: 4.1.1 + vary: 1.1.2 + croner@4.1.97: {} cross-env@10.1.0: @@ -2657,6 +3179,8 @@ snapshots: escodegen: 2.1.0 esprima: 4.0.1 + depd@2.0.0: {} + detect-indent@6.1.0: {} detect-libc@2.1.2: {} @@ -2665,6 +3189,16 @@ snapshots: dependencies: path-type: 4.0.0 + dunder-proto@1.0.1: + dependencies: + call-bind-apply-helpers: 1.0.2 + es-errors: 1.3.0 + gopd: 1.2.0 + + ee-first@1.1.1: {} + + encodeurl@2.0.0: {} + end-of-stream@1.4.5: dependencies: once: 1.4.0 @@ -2674,6 +3208,14 @@ snapshots: ansi-colors: 4.1.3 strip-ansi: 6.0.1 + es-define-property@1.0.1: {} + + es-errors@1.3.0: {} + + es-object-atoms@1.1.2: + dependencies: + es-errors: 1.3.0 + esbuild@0.27.7: optionalDependencies: '@esbuild/aix-ppc64': 0.27.7 @@ -2703,6 +3245,8 @@ snapshots: '@esbuild/win32-ia32': 0.27.7 '@esbuild/win32-x64': 0.27.7 + escape-html@1.0.3: {} + escodegen@2.1.0: dependencies: esprima: 4.0.1 @@ -2717,10 +3261,56 @@ snapshots: esutils@2.0.3: {} + etag@1.8.1: {} + eventemitter2@6.4.9: {} + eventsource-parser@3.1.0: {} + + eventsource@3.0.7: + dependencies: + eventsource-parser: 3.1.0 + expand-template@2.0.3: {} + express-rate-limit@8.5.2(express@5.2.1): + dependencies: + express: 5.2.1 + ip-address: 10.2.0 + + express@5.2.1: + dependencies: + accepts: 2.0.0 + body-parser: 2.3.0 + content-disposition: 1.1.0 + content-type: 1.0.5 + cookie: 0.7.2 + cookie-signature: 1.2.2 + debug: 4.4.3 + depd: 2.0.0 + encodeurl: 2.0.0 + escape-html: 1.0.3 + etag: 1.8.1 + finalhandler: 2.1.1 + fresh: 2.0.0 + http-errors: 2.0.1 + merge-descriptors: 2.0.0 + mime-types: 3.0.2 + on-finished: 2.4.1 + once: 1.4.0 + parseurl: 1.3.3 + proxy-addr: 2.0.7 + qs: 6.15.2 + range-parser: 1.2.1 + router: 2.2.0 + send: 1.2.1 + serve-static: 2.2.1 + statuses: 2.0.2 + type-is: 2.1.0 + vary: 1.1.2 + transitivePeerDependencies: + - supports-color + extendable-error@0.1.7: {} extrareqp2@1.0.0(debug@4.3.7): @@ -2729,6 +3319,8 @@ snapshots: transitivePeerDependencies: - debug + fast-deep-equal@3.1.3: {} + fast-glob@3.3.3: dependencies: '@nodelib/fs.stat': 2.0.5 @@ -2739,12 +3331,16 @@ snapshots: fast-json-patch@3.1.1: {} + fast-sha256@1.3.0: {} + fast-string-truncated-width@3.0.3: {} fast-string-width@3.0.2: dependencies: fast-string-truncated-width: 3.0.3 + fast-uri@3.1.2: {} + fast-wrap-ansi@0.2.0: dependencies: fast-string-width: 3.0.2 @@ -2777,6 +3373,17 @@ snapshots: dependencies: to-regex-range: 5.0.1 + finalhandler@2.1.1: + dependencies: + debug: 4.4.3 + encodeurl: 2.0.0 + escape-html: 1.0.3 + on-finished: 2.4.1 + parseurl: 1.3.3 + statuses: 2.0.2 + transitivePeerDependencies: + - supports-color + find-up@4.1.0: dependencies: locate-path: 5.0.0 @@ -2792,6 +3399,10 @@ snapshots: optionalDependencies: debug: 4.3.7 + forwarded@0.2.0: {} + + fresh@2.0.0: {} + fs-constants@1.0.0: {} fs-extra@7.0.1: @@ -2809,6 +3420,26 @@ snapshots: fsevents@2.3.3: optional: true + function-bind@1.1.2: {} + + get-intrinsic@1.3.0: + dependencies: + call-bind-apply-helpers: 1.0.2 + es-define-property: 1.0.1 + es-errors: 1.3.0 + es-object-atoms: 1.1.2 + function-bind: 1.1.2 + get-proto: 1.0.1 + gopd: 1.2.0 + has-symbols: 1.1.0 + hasown: 2.0.4 + math-intrinsics: 1.1.0 + + get-proto@1.0.1: + dependencies: + dunder-proto: 1.0.1 + es-object-atoms: 1.1.2 + get-tsconfig@4.14.0: dependencies: resolve-pkg-maps: 1.0.0 @@ -2842,10 +3473,28 @@ snapshots: merge2: 1.4.1 slash: 3.0.0 + gopd@1.2.0: {} + graceful-fs@4.2.11: {} has-flag@4.0.0: {} + has-symbols@1.1.0: {} + + hasown@2.0.4: + dependencies: + function-bind: 1.1.2 + + hono@4.12.27: {} + + http-errors@2.0.1: + dependencies: + depd: 2.0.0 + inherits: 2.0.4 + setprototypeof: 1.2.0 + statuses: 2.0.2 + toidentifier: 1.0.1 + http-proxy-agent@7.0.2: dependencies: agent-base: 7.1.4 @@ -2876,6 +3525,10 @@ snapshots: ip-address@10.1.0: {} + ip-address@10.2.0: {} + + ipaddr.js@1.9.1: {} + is-binary-path@2.1.0: dependencies: binary-extensions: 2.3.0 @@ -2888,6 +3541,8 @@ snapshots: is-number@7.0.0: {} + is-promise@4.0.0: {} + is-subdir@1.2.0: dependencies: better-path-resolve: 1.0.0 @@ -2896,6 +3551,8 @@ snapshots: isexe@2.0.0: {} + jose@6.2.3: {} + joycon@3.1.1: {} js-git@0.7.8: @@ -2914,6 +3571,15 @@ snapshots: dependencies: argparse: 2.0.1 + json-schema-to-ts@3.1.1: + dependencies: + '@babel/runtime': 7.29.2 + ts-algebra: 2.0.0 + + json-schema-traverse@1.0.0: {} + + json-schema-typed@8.0.2: {} + json-stringify-safe@5.0.1: optional: true @@ -2947,6 +3613,12 @@ snapshots: dependencies: '@jridgewell/sourcemap-codec': 1.5.5 + math-intrinsics@1.1.0: {} + + media-typer@1.1.0: {} + + merge-descriptors@2.0.0: {} + merge2@1.4.1: {} micromatch@4.0.8: @@ -2954,6 +3626,12 @@ snapshots: braces: 3.0.3 picomatch: 2.3.2 + mime-db@1.54.0: {} + + mime-types@3.0.2: + dependencies: + mime-db: 1.54.0 + mimic-response@3.1.0: {} minimist@1.2.8: {} @@ -2983,6 +3661,8 @@ snapshots: napi-build-utils@2.0.0: {} + negotiator@1.0.0: {} + netmask@2.1.1: {} node-abi@3.92.0: @@ -3001,6 +3681,12 @@ snapshots: object-assign@4.1.1: {} + object-inspect@1.13.4: {} + + on-finished@2.4.1: + dependencies: + ee-first: 1.1.1 + once@1.4.0: dependencies: wrappy: 1.0.2 @@ -3047,10 +3733,14 @@ snapshots: pako@0.2.9: {} + parseurl@1.3.3: {} + path-exists@4.0.0: {} path-key@3.1.1: {} + path-to-regexp@8.4.2: {} + path-type@4.0.0: {} pathe@2.0.3: {} @@ -3074,6 +3764,8 @@ snapshots: pirates@4.0.7: {} + pkce-challenge@5.0.1: {} + pkg-types@1.3.1: dependencies: confbox: 0.1.8 @@ -3150,6 +3842,11 @@ snapshots: prettier@2.8.8: {} + proxy-addr@2.0.7: + dependencies: + forwarded: 0.2.0 + ipaddr.js: 1.9.1 + proxy-agent@6.5.0: dependencies: agent-base: 7.1.4 @@ -3172,10 +3869,23 @@ snapshots: qrcode-terminal@0.12.0: {} + qs@6.15.2: + dependencies: + side-channel: 1.1.1 + quansync@0.2.11: {} queue-microtask@1.2.3: {} + range-parser@1.2.1: {} + + raw-body@3.0.2: + dependencies: + bytes: 3.1.2 + http-errors: 2.0.1 + iconv-lite: 0.7.2 + unpipe: 1.0.0 + rc@1.2.8: dependencies: deep-extend: 0.6.0 @@ -3202,6 +3912,8 @@ snapshots: readdirp@4.1.2: {} + require-from-string@2.0.2: {} + resolve-from@5.0.0: {} resolve-pkg-maps@1.0.0: {} @@ -3239,6 +3951,16 @@ snapshots: '@rollup/rollup-win32-x64-msvc': 4.60.2 fsevents: 2.3.3 + router@2.2.0: + dependencies: + debug: 4.4.3 + depd: 2.0.0 + is-promise: 4.0.0 + parseurl: 1.3.3 + path-to-regexp: 8.4.2 + transitivePeerDependencies: + - supports-color + run-parallel@1.2.0: dependencies: queue-microtask: 1.2.3 @@ -3253,12 +3975,67 @@ snapshots: semver@7.7.4: {} + send@1.2.1: + dependencies: + debug: 4.4.3 + encodeurl: 2.0.0 + escape-html: 1.0.3 + etag: 1.8.1 + fresh: 2.0.0 + http-errors: 2.0.1 + mime-types: 3.0.2 + ms: 2.1.3 + on-finished: 2.4.1 + range-parser: 1.2.1 + statuses: 2.0.2 + transitivePeerDependencies: + - supports-color + + serve-static@2.2.1: + dependencies: + encodeurl: 2.0.0 + escape-html: 1.0.3 + parseurl: 1.3.3 + send: 1.2.1 + transitivePeerDependencies: + - supports-color + + setprototypeof@1.2.0: {} + shebang-command@2.0.0: dependencies: shebang-regex: 3.0.0 shebang-regex@3.0.0: {} + side-channel-list@1.0.1: + dependencies: + es-errors: 1.3.0 + object-inspect: 1.13.4 + + side-channel-map@1.0.1: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + get-intrinsic: 1.3.0 + object-inspect: 1.13.4 + + side-channel-weakmap@1.0.2: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + get-intrinsic: 1.3.0 + object-inspect: 1.13.4 + side-channel-map: 1.0.1 + + side-channel@1.1.1: + dependencies: + es-errors: 1.3.0 + object-inspect: 1.13.4 + side-channel-list: 1.0.1 + side-channel-map: 1.0.1 + side-channel-weakmap: 1.0.2 + signal-exit@4.1.0: {} simple-concat@1.0.1: {} @@ -3298,6 +4075,13 @@ snapshots: sprintf-js@1.0.3: {} + standardwebhooks@1.0.0: + dependencies: + '@stablelib/base64': 1.0.1 + fast-sha256: 1.3.0 + + statuses@2.0.2: {} + string_decoder@1.3.0: dependencies: safe-buffer: 5.2.1 @@ -3363,8 +4147,12 @@ snapshots: dependencies: is-number: 7.0.0 + toidentifier@1.0.1: {} + tree-kill@1.2.2: {} + ts-algebra@2.0.0: {} + ts-interface-checker@0.1.13: {} tslib@2.8.1: {} @@ -3414,6 +4202,12 @@ snapshots: json-stringify-safe: 5.0.1 optional: true + type-is@2.1.0: + dependencies: + content-type: 2.0.0 + media-typer: 1.1.0 + mime-types: 3.0.2 + typescript@6.0.3: {} ufo@1.6.3: {} @@ -3422,8 +4216,12 @@ snapshots: universalify@0.1.2: {} + unpipe@1.0.0: {} + util-deprecate@1.0.2: {} + vary@1.1.2: {} + vizion@2.2.1: dependencies: async: 2.6.4 @@ -3441,4 +4239,8 @@ snapshots: ws@8.20.0: {} + zod-to-json-schema@3.25.2(zod@4.3.6): + dependencies: + zod: 4.3.6 + zod@4.3.6: {}