@otto-code/server 0.5.0

package/dist/server/server/agent/providers/claude/partial-json.js

@@ -0,0 +1,306 @@
+function skipWhitespace(input, index) {
+    let currentIndex = index;
+    while (currentIndex < input.length && /\s/u.test(input[currentIndex] ?? "")) {
+        currentIndex += 1;
+    }
+    return currentIndex;
+}
+function parsePartialString(input, index) {
+    if (input[index] !== '"') {
+        return null;
+    }
+    let currentIndex = index + 1;
+    let value = "";
+    while (currentIndex < input.length) {
+        const character = input[currentIndex];
+        if (character === '"') {
+            return {
+                value,
+                nextIndex: currentIndex + 1,
+                complete: true,
+            };
+        }
+        if (character === "\\") {
+            const escapeCharacter = input[currentIndex + 1];
+            if (escapeCharacter === undefined) {
+                return {
+                    value,
+                    nextIndex: input.length,
+                    complete: false,
+                };
+            }
+            switch (escapeCharacter) {
+                case '"':
+                case "\\":
+                case "/":
+                    value += escapeCharacter;
+                    currentIndex += 2;
+                    continue;
+                case "b":
+                    value += "\b";
+                    currentIndex += 2;
+                    continue;
+                case "f":
+                    value += "\f";
+                    currentIndex += 2;
+                    continue;
+                case "n":
+                    value += "\n";
+                    currentIndex += 2;
+                    continue;
+                case "r":
+                    value += "\r";
+                    currentIndex += 2;
+                    continue;
+                case "t":
+                    value += "\t";
+                    currentIndex += 2;
+                    continue;
+                case "u": {
+                    const hex = input.slice(currentIndex + 2, currentIndex + 6);
+                    if (hex.length < 4 || !/^[0-9a-fA-F]{4}$/u.test(hex)) {
+                        return {
+                            value,
+                            nextIndex: input.length,
+                            complete: false,
+                        };
+                    }
+                    value += String.fromCodePoint(Number.parseInt(hex, 16));
+                    currentIndex += 6;
+                    continue;
+                }
+                default:
+                    return {
+                        value,
+                        nextIndex: input.length,
+                        complete: false,
+                    };
+            }
+        }
+        value += character;
+        currentIndex += 1;
+    }
+    return {
+        value,
+        nextIndex: input.length,
+        complete: false,
+    };
+}
+function parsePartialLiteral(input, index) {
+    const remaining = input.slice(index);
+    if (remaining.startsWith("true")) {
+        return { value: true, nextIndex: index + 4, complete: true };
+    }
+    if (remaining.startsWith("false")) {
+        return { value: false, nextIndex: index + 5, complete: true };
+    }
+    if (remaining.startsWith("null")) {
+        return { value: null, nextIndex: index + 4, complete: true };
+    }
+    return null;
+}
+function parsePartialNumber(input, index) {
+    const match = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/u.exec(input.slice(index));
+    if (!match?.[0]) {
+        return null;
+    }
+    return {
+        value: Number(match[0]),
+        nextIndex: index + match[0].length,
+        complete: true,
+    };
+}
+function parsePartialArray(input, index) {
+    if (input[index] !== "[") {
+        return null;
+    }
+    const values = [];
+    let currentIndex = index + 1;
+    while (currentIndex <= input.length) {
+        currentIndex = skipWhitespace(input, currentIndex);
+        const nextCharacter = input[currentIndex];
+        if (nextCharacter === "]") {
+            return {
+                value: values,
+                nextIndex: currentIndex + 1,
+                complete: true,
+            };
+        }
+        if (nextCharacter === undefined) {
+            return {
+                value: values,
+                nextIndex: input.length,
+                complete: false,
+            };
+        }
+        const parsedValue = parsePartialJsonValue(input, currentIndex);
+        if (!parsedValue) {
+            return {
+                value: values,
+                nextIndex: currentIndex,
+                complete: false,
+            };
+        }
+        values.push(parsedValue.value);
+        currentIndex = skipWhitespace(input, parsedValue.nextIndex);
+        if (!parsedValue.complete) {
+            return {
+                value: values,
+                nextIndex: currentIndex,
+                complete: false,
+            };
+        }
+        const delimiter = input[currentIndex];
+        if (delimiter === ",") {
+            currentIndex += 1;
+            continue;
+        }
+        if (delimiter === "]") {
+            return {
+                value: values,
+                nextIndex: currentIndex + 1,
+                complete: true,
+            };
+        }
+        if (delimiter === undefined) {
+            return {
+                value: values,
+                nextIndex: input.length,
+                complete: false,
+            };
+        }
+        return {
+            value: values,
+            nextIndex: currentIndex,
+            complete: false,
+        };
+    }
+    return {
+        value: values,
+        nextIndex: input.length,
+        complete: false,
+    };
+}
+function parsePartialObject(input, index) {
+    if (input[index] !== "{") {
+        return null;
+    }
+    const value = {};
+    let currentIndex = index + 1;
+    while (currentIndex <= input.length) {
+        currentIndex = skipWhitespace(input, currentIndex);
+        const nextCharacter = input[currentIndex];
+        if (nextCharacter === "}") {
+            return {
+                value,
+                nextIndex: currentIndex + 1,
+                complete: true,
+            };
+        }
+        if (nextCharacter === undefined) {
+            return {
+                value,
+                nextIndex: input.length,
+                complete: false,
+            };
+        }
+        const parsedKey = parsePartialString(input, currentIndex);
+        if (!parsedKey?.complete) {
+            return {
+                value,
+                nextIndex: parsedKey?.nextIndex ?? currentIndex,
+                complete: false,
+            };
+        }
+        currentIndex = skipWhitespace(input, parsedKey.nextIndex);
+        if (input[currentIndex] !== ":") {
+            return {
+                value,
+                nextIndex: currentIndex,
+                complete: false,
+            };
+        }
+        currentIndex = skipWhitespace(input, currentIndex + 1);
+        const parsedMemberValue = parsePartialJsonValue(input, currentIndex);
+        if (!parsedMemberValue) {
+            return {
+                value,
+                nextIndex: currentIndex,
+                complete: false,
+            };
+        }
+        if (!parsedMemberValue.complete) {
+            return {
+                value,
+                nextIndex: skipWhitespace(input, parsedMemberValue.nextIndex),
+                complete: false,
+            };
+        }
+        value[parsedKey.value] = parsedMemberValue.value;
+        currentIndex = skipWhitespace(input, parsedMemberValue.nextIndex);
+        const delimiter = input[currentIndex];
+        if (delimiter === ",") {
+            currentIndex += 1;
+            continue;
+        }
+        if (delimiter === "}") {
+            return {
+                value,
+                nextIndex: currentIndex + 1,
+                complete: true,
+            };
+        }
+        if (delimiter === undefined) {
+            return {
+                value,
+                nextIndex: input.length,
+                complete: false,
+            };
+        }
+        return {
+            value,
+            nextIndex: currentIndex,
+            complete: false,
+        };
+    }
+    return {
+        value,
+        nextIndex: input.length,
+        complete: false,
+    };
+}
+function parsePartialJsonValue(input, index) {
+    const currentIndex = skipWhitespace(input, index);
+    const character = input[currentIndex];
+    if (character === undefined) {
+        return null;
+    }
+    if (character === '"') {
+        return parsePartialString(input, currentIndex);
+    }
+    if (character === "{") {
+        return parsePartialObject(input, currentIndex);
+    }
+    if (character === "[") {
+        return parsePartialArray(input, currentIndex);
+    }
+    if (character === "t" || character === "f" || character === "n") {
+        return parsePartialLiteral(input, currentIndex);
+    }
+    if (character === "-" || /\d/u.test(character)) {
+        return parsePartialNumber(input, currentIndex);
+    }
+    return null;
+}
+export function parsePartialJsonObject(input) {
+    const currentIndex = skipWhitespace(input, 0);
+    const parsed = parsePartialObject(input, currentIndex);
+    if (!parsed) {
+        return null;
+    }
+    return {
+        value: parsed.value,
+        complete: parsed.complete && skipWhitespace(input, parsed.nextIndex) === input.length,
+    };
+}
+//# sourceMappingURL=partial-json.js.map

package/dist/server/server/agent/providers/claude/project-dir.d.ts

@@ -0,0 +1,6 @@
+export interface ClaudeProjectDirOptions {
+    configDir?: string;
+}
+export declare function claudeProjectDir(cwd: string, options?: ClaudeProjectDirOptions): Promise<string>;
+export declare function claudeProjectDirSync(cwd: string, options?: ClaudeProjectDirOptions): string;
+//# sourceMappingURL=project-dir.d.ts.map

package/dist/server/server/agent/providers/claude/project-dir.js

@@ -0,0 +1,57 @@
+import { realpathSync } from "node:fs";
+import { realpath } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// Verbatim port of the Claude Agent SDK's project-directory encoding so
+// otto computes the same `~/.claude/projects/<dir>` path the SDK does.
+// The SDK ships only as a precompiled bundle; grep the JS source at
+// node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs for `function Ar`,
+// `function So`, `async function wn`, `function Dy`, `Ni=200`.
+const PROJECT_DIR_LENGTH_CAP = 200;
+export async function claudeProjectDir(cwd, options) {
+    const canonical = await canonicalize(cwd);
+    const projectsRoot = join(resolveConfigDir(options), "projects");
+    return join(projectsRoot, encode(canonical));
+}
+export function claudeProjectDirSync(cwd, options) {
+    const canonical = canonicalizeSync(cwd);
+    const projectsRoot = join(resolveConfigDir(options), "projects");
+    return join(projectsRoot, encode(canonical));
+}
+async function canonicalize(input) {
+    try {
+        return normalizeProjectPath(await realpath(input));
+    }
+    catch {
+        return normalizeProjectPath(input);
+    }
+}
+function canonicalizeSync(input) {
+    try {
+        return normalizeProjectPath(realpathSync.native(input));
+    }
+    catch {
+        return normalizeProjectPath(input);
+    }
+}
+function normalizeProjectPath(input) {
+    return process.platform === "darwin" ? input.normalize("NFC") : input;
+}
+function encode(input) {
+    const replaced = input.replace(/[^a-zA-Z0-9]/g, "-");
+    if (replaced.length <= PROJECT_DIR_LENGTH_CAP) {
+        return replaced;
+    }
+    return `${replaced.slice(0, PROJECT_DIR_LENGTH_CAP)}-${hashSuffix(input)}`;
+}
+function hashSuffix(input) {
+    let hash = 0;
+    for (let i = 0; i < input.length; i++) {
+        hash = ((hash << 5) - hash + input.charCodeAt(i)) | 0;
+    }
+    return Math.abs(hash).toString(36);
+}
+function resolveConfigDir(options) {
+    return options?.configDir ?? process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
+}
+//# sourceMappingURL=project-dir.js.map

package/dist/server/server/agent/providers/claude/query.d.ts

@@ -0,0 +1,17 @@
+import { type ChildProcess } from "node:child_process";
+import { query, type Options, type Query } from "@anthropic-ai/claude-agent-sdk";
+import { type ProviderRuntimeSettings } from "../../provider-launch-config.js";
+export type ClaudeOptions = Options;
+export type ClaudeQueryInput = Parameters<typeof query>[0] & {
+    options: ClaudeOptions;
+};
+export type ClaudeQueryFactory = (input: ClaudeQueryInput) => Query;
+export interface ClaudeQueryContext {
+    runtimeSettings?: ProviderRuntimeSettings;
+    launchEnv?: Record<string, string>;
+    queryFactory?: ClaudeQueryFactory;
+    /** Called with the spawned child process so the caller can tree-kill it on close. */
+    onChildProcess?: (child: ChildProcess) => void;
+}
+export declare function claudeQuery(input: ClaudeQueryInput, context?: ClaudeQueryContext): Query;
+//# sourceMappingURL=query.d.ts.map

package/dist/server/server/agent/providers/claude/query.js

@@ -0,0 +1,86 @@
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { createProviderEnv, createProviderEnvSpec, } from "../../provider-launch-config.js";
+import { buildSelfNodeCommand } from "../../../otto-env.js";
+import { spawnProcess } from "../../../../utils/spawn.js";
+function isChildProcessWithStreams(child) {
+    return child.stdin !== null && child.stdout !== null && child.stderr !== null;
+}
+function resolveClaudeSpawnCommand(spawnOptions, runtimeSettings) {
+    const commandConfig = runtimeSettings?.command;
+    if (!commandConfig || commandConfig.mode === "default") {
+        return {
+            command: spawnOptions.command,
+            args: [...spawnOptions.args],
+        };
+    }
+    if (commandConfig.mode === "append") {
+        return {
+            command: spawnOptions.command,
+            args: [...spawnOptions.args, ...(commandConfig.args ?? [])],
+        };
+    }
+    return {
+        command: commandConfig.argv[0],
+        args: [...commandConfig.argv.slice(1), ...spawnOptions.args],
+    };
+}
+function applyRuntimeSettingsToClaudeOptions(options, context) {
+    const { runtimeSettings, launchEnv, onChildProcess } = context;
+    return {
+        ...options,
+        spawnClaudeCodeProcess: (spawnOptions) => {
+            const resolved = resolveClaudeSpawnCommand(spawnOptions, runtimeSettings);
+            // When the SDK passes a default JS runtime ("node"/"bun"), replace it with
+            // process.execPath — the actual node binary running the daemon. This avoids
+            // PATH lookup failures in the managed runtime bundle.
+            // When the SDK passes a native binary path (from pathToClaudeCodeExecutable)
+            // or the user overrides the command via runtime settings, use that directly.
+            const isDefaultRuntime = resolved.command === "node" || resolved.command === "bun";
+            const providerEnvSpec = createProviderEnvSpec({
+                baseEnv: spawnOptions.env,
+                runtimeSettings,
+                overlays: [launchEnv],
+            });
+            const providerEnv = createProviderEnv({
+                baseEnv: spawnOptions.env,
+                runtimeSettings,
+                overlays: [launchEnv],
+            });
+            const selfNodeCommand = isDefaultRuntime
+                ? buildSelfNodeCommand(resolved.args, providerEnv)
+                : null;
+            const command = selfNodeCommand?.command ?? resolved.command;
+            const args = selfNodeCommand?.args ?? resolved.args;
+            const child = spawnProcess(command, args, {
+                cwd: spawnOptions.cwd,
+                ...(selfNodeCommand
+                    ? { env: selfNodeCommand.env, envMode: "internal" }
+                    : providerEnvSpec),
+                signal: spawnOptions.signal,
+                stdio: ["pipe", "pipe", "pipe"],
+                // Bypass cmd.exe on Windows: the SDK passes --mcp-config with inline JSON
+                // containing double quotes, which cmd.exe mangles (strips quotes, breaks parsing).
+                // The command is always a resolved binary path, so shell routing is unnecessary.
+                shell: false,
+            });
+            onChildProcess?.(child);
+            if (typeof options.stderr === "function") {
+                child.stderr?.on("data", (chunk) => {
+                    options.stderr?.(chunk.toString());
+                });
+            }
+            if (!isChildProcessWithStreams(child)) {
+                throw new Error("Claude process was spawned without stdio streams");
+            }
+            return child;
+        },
+    };
+}
+export function claudeQuery(input, context = {}) {
+    const launchQuery = context.queryFactory ?? query;
+    return launchQuery({
+        ...input,
+        options: applyRuntimeSettingsToClaudeOptions(input.options, context),
+    });
+}
+//# sourceMappingURL=query.js.map

package/dist/server/server/agent/providers/claude/rewind.d.ts

@@ -0,0 +1,30 @@
+import { type Query } from "@anthropic-ai/claude-agent-sdk";
+export interface ClaudeRewindSdk {
+    forkSession(sessionId: string, options: {
+        upToMessageId: string;
+    }): Promise<{
+        sessionId: string;
+    }>;
+}
+export declare const realClaudeRewindSdk: ClaudeRewindSdk;
+export declare function revertClaudeConversation(input: {
+    sdk: ClaudeRewindSdk;
+    sessionId: string | null;
+    messageId: string;
+    resolveMessageId?: (messageId: string) => string | Promise<string>;
+    setSessionId: (sessionId: string) => void;
+}): Promise<void>;
+export declare function revertClaudeFiles(input: {
+    query: Query;
+    messageId: string;
+    resolveMessageId?: (messageId: string) => string | Promise<string>;
+}): Promise<void>;
+export declare function revertClaudeConversationAndFiles(input: {
+    sdk: ClaudeRewindSdk;
+    query: Query;
+    sessionId: string | null;
+    messageId: string;
+    resolveMessageId?: (messageId: string) => string | Promise<string>;
+    setSessionId: (sessionId: string) => void;
+}): Promise<void>;
+//# sourceMappingURL=rewind.d.ts.map

package/dist/server/server/agent/providers/claude/rewind.js

@@ -0,0 +1,30 @@
+import { forkSession as claudeForkSession } from "@anthropic-ai/claude-agent-sdk";
+export const realClaudeRewindSdk = {
+    forkSession: claudeForkSession,
+};
+export async function revertClaudeConversation(input) {
+    if (!input.sessionId) {
+        throw new Error("Claude session is not ready for rewind");
+    }
+    const messageId = (await input.resolveMessageId?.(input.messageId)) ?? input.messageId;
+    const fork = await input.sdk.forkSession(input.sessionId, {
+        upToMessageId: messageId,
+    });
+    input.setSessionId(fork.sessionId);
+}
+export async function revertClaudeFiles(input) {
+    const messageId = (await input.resolveMessageId?.(input.messageId)) ?? input.messageId;
+    const result = await input.query.rewindFiles(messageId, { dryRun: false });
+    if (!result.canRewind) {
+        throw new Error(result.error ?? `No file checkpoint found for message ${messageId}`);
+    }
+}
+export async function revertClaudeConversationAndFiles(input) {
+    await revertClaudeFiles({
+        query: input.query,
+        messageId: input.messageId,
+        resolveMessageId: input.resolveMessageId,
+    });
+    await revertClaudeConversation(input);
+}
+//# sourceMappingURL=rewind.js.map

package/dist/server/server/agent/providers/claude/sidechain-tracker.d.ts

@@ -0,0 +1,22 @@
+import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
+import type { AgentMetadata, AgentStreamEvent } from "../../agent-sdk-types.js";
+export declare class ClaudeSidechainTracker {
+    private readonly activeSidechains;
+    private readonly getToolInput;
+    constructor(input: {
+        getToolInput: (toolUseId: string) => AgentMetadata | null | undefined;
+    });
+    handleMessage(message: SDKMessage, parentToolUseId: string): AgentStreamEvent[];
+    delete(toolUseId: string): void;
+    clear(): void;
+    private updateSubAgentContextFromTaskInput;
+    private normalizeSubAgentText;
+    private extractAssistantMessageActions;
+    private extractStreamEventActions;
+    private extractSubAgentActionCandidates;
+    private appendSubAgentAction;
+    private trimSubAgentTail;
+    private rebuildSubAgentActionIndex;
+    private deriveSubAgentActionSummary;
+}
+//# sourceMappingURL=sidechain-tracker.d.ts.map