@otto-code/server 0.5.0

package/dist/server/server/speech/speech-types.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+export declare const SpeechProviderIdSchema: z.ZodEnum<{
+    local: "local";
+    openai: "openai";
+}>;
+export type SpeechProviderId = z.infer<typeof SpeechProviderIdSchema>;
+export declare const RequestedSpeechProviderSchema: z.ZodObject<{
+    provider: z.ZodEnum<{
+        local: "local";
+        openai: "openai";
+    }>;
+    explicit: z.ZodBoolean;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type RequestedSpeechProvider = z.infer<typeof RequestedSpeechProviderSchema>;
+export interface RequestedSpeechProviders {
+    dictationStt: RequestedSpeechProvider;
+    voiceTurnDetection: RequestedSpeechProvider;
+    voiceStt: RequestedSpeechProvider;
+    voiceTts: RequestedSpeechProvider;
+}
+//# sourceMappingURL=speech-types.d.ts.map

package/dist/server/server/speech/speech-types.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export const SpeechProviderIdSchema = z.enum(["openai", "local"]);
+export const RequestedSpeechProviderSchema = z.object({
+    provider: SpeechProviderIdSchema,
+    explicit: z.boolean(),
+    enabled: z.boolean().optional(),
+});
+//# sourceMappingURL=speech-types.js.map

package/dist/server/server/speech/turn-detection-provider.d.ts

@@ -0,0 +1,23 @@
+import type pino from "pino";
+export interface TurnDetectionSession {
+    /**
+     * Required PCM16LE sample rate for `appendPcm16()`.
+     * Callers are responsible for resampling before appending.
+     */
+    requiredSampleRate: number;
+    connect(): Promise<void>;
+    appendPcm16(pcm16le: Buffer): void;
+    flush(): void;
+    reset(): void;
+    close(): void;
+    on(event: "speech_started", handler: () => void): unknown;
+    on(event: "speech_stopped", handler: () => void): unknown;
+    on(event: "error", handler: (err: unknown) => void): unknown;
+}
+export interface TurnDetectionProvider {
+    id: "openai" | "local" | (string & {});
+    createSession(params: {
+        logger: pino.Logger;
+    }): TurnDetectionSession;
+}
+//# sourceMappingURL=turn-detection-provider.d.ts.map

package/dist/server/server/speech/turn-detection-provider.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=turn-detection-provider.js.map

package/dist/server/server/utils/diff-highlighter.d.ts

@@ -0,0 +1,57 @@
+import { type HighlightToken } from "@otto-code/highlight";
+export interface DiffLine {
+    type: "add" | "remove" | "context" | "header";
+    content: string;
+    tokens?: HighlightToken[];
+}
+export interface DiffHunk {
+    oldStart: number;
+    oldCount: number;
+    newStart: number;
+    newCount: number;
+    lines: DiffLine[];
+}
+export interface ParsedDiffFile {
+    path: string;
+    isNew: boolean;
+    isDeleted: boolean;
+    additions: number;
+    deletions: number;
+    hunks: DiffHunk[];
+    status?: "ok" | "too_large" | "binary";
+}
+interface HighlightDiffWithFileContentOptions {
+    oldFileContent?: string | null;
+    newFileContent?: string | null;
+}
+interface ParseAndHighlightDiffOptions {
+    getOldFileContent?: (file: ParsedDiffFile) => Promise<string | null>;
+    getNewFileContent?: (file: ParsedDiffFile) => Promise<string | null>;
+}
+export declare function parseDiff(diffText: string): ParsedDiffFile[];
+/**
+ * Reconstruct the "new" version of a file from diff hunks.
+ * Returns a map of new line numbers to their content.
+ */
+export declare function reconstructNewFile(hunks: DiffHunk[]): Map<number, string>;
+/**
+ * Reconstruct the "old" version of a file from diff hunks.
+ * Returns a map of old line numbers to their content.
+ */
+export declare function reconstructOldFile(hunks: DiffHunk[]): Map<number, string>;
+/**
+ * Apply syntax highlighting to diff hunks using reconstructed file content.
+ * This is the fallback when actual file content is not available.
+ */
+export declare function highlightDiffFromHunks(file: ParsedDiffFile): ParsedDiffFile;
+/**
+ * Apply syntax highlighting to diff hunks using actual file content.
+ * This provides better context for the parser.
+ */
+export declare function highlightDiffWithFileContent(file: ParsedDiffFile, cwd: string, options?: HighlightDiffWithFileContentOptions): Promise<ParsedDiffFile>;
+/**
+ * Parse and highlight a complete diff, using actual file content when available.
+ */
+export declare function parseAndHighlightDiff(diffText: string, cwd: string, options?: ParseAndHighlightDiffOptions): Promise<ParsedDiffFile[]>;
+export type { HighlightToken };
+//# sourceMappingURL=diff-highlighter.d.ts.map

package/dist/server/server/utils/diff-highlighter.js

@@ -0,0 +1,279 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { highlightCode, isLanguageSupported } from "@otto-code/highlight";
+/**
+ * Parse a unified diff into structured data
+ */
+// Git's default patch headers use paired a/path and b/path prefixes, while
+// diff.noprefix emits plain paths that may legitimately start with a/ or b/.
+function usesDiffPathPrefixes(oldPath, newPath) {
+    return oldPath.startsWith("a/") && newPath.startsWith("b/");
+}
+function extractPathFromMetadata(lines, prefix) {
+    const line = lines.find((candidate) => candidate.startsWith(prefix));
+    if (!line) {
+        return null;
+    }
+    const path = line.slice(prefix.length).replace(/\t.*$/, "").trimEnd();
+    return path === "/dev/null" ? null : path;
+}
+function extractPathFromDiffHeader(lines) {
+    const firstLine = lines[0] ?? "";
+    const prefixedPathMatch = firstLine.match(/^a\/(.+) b\/(.+)$/);
+    if (prefixedPathMatch) {
+        return prefixedPathMatch[2];
+    }
+    const metadataPath = extractPathFromMetadata(lines, "+++ ") ?? extractPathFromMetadata(lines, "--- ");
+    if (metadataPath) {
+        return metadataPath;
+    }
+    const pathMatch = firstLine.match(/^(\S+)\s+(\S+)$/);
+    if (pathMatch) {
+        const [, oldPath, newPath] = pathMatch;
+        const path = newPath === "/dev/null" ? oldPath : newPath;
+        return usesDiffPathPrefixes(oldPath, newPath) ? path.slice(2) : path;
+    }
+    return "unknown";
+}
+function isMetadataLine(line) {
+    return (line.startsWith("index ") ||
+        line.startsWith("--- ") ||
+        line.startsWith("+++ ") ||
+        line.startsWith("new file mode") ||
+        line.startsWith("deleted file mode"));
+}
+function parseHunkHeader(line) {
+    const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+    if (!hunkMatch)
+        return null;
+    return {
+        oldStart: parseInt(hunkMatch[1], 10),
+        oldCount: parseInt(hunkMatch[2] ?? "1", 10),
+        newStart: parseInt(hunkMatch[3], 10),
+        newCount: parseInt(hunkMatch[4] ?? "1", 10),
+        lines: [{ type: "header", content: line.match(/^(@@ .+? @@)/)?.[1] ?? line }],
+    };
+}
+function parseSectionBody(lines) {
+    const hunks = [];
+    let currentHunk = null;
+    let additions = 0;
+    let deletions = 0;
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (isMetadataLine(line))
+            continue;
+        const newHunk = parseHunkHeader(line);
+        if (newHunk) {
+            if (currentHunk)
+                hunks.push(currentHunk);
+            currentHunk = newHunk;
+            continue;
+        }
+        if (!currentHunk)
+            continue;
+        if (line.startsWith("+")) {
+            currentHunk.lines.push({ type: "add", content: line.slice(1) });
+            additions++;
+        }
+        else if (line.startsWith("-")) {
+            currentHunk.lines.push({ type: "remove", content: line.slice(1) });
+            deletions++;
+        }
+        else if (line.startsWith(" ")) {
+            currentHunk.lines.push({ type: "context", content: line.slice(1) });
+        }
+        else if (line.length > 0 && !line.startsWith("\\")) {
+            currentHunk.lines.push({ type: "context", content: line });
+        }
+    }
+    if (currentHunk)
+        hunks.push(currentHunk);
+    return { hunks, additions, deletions };
+}
+export function parseDiff(diffText) {
+    if (!diffText || diffText.trim().length === 0) {
+        return [];
+    }
+    const files = [];
+    const fileSections = diffText.split(/^diff --git /m).filter(Boolean);
+    for (const section of fileSections) {
+        const lines = section.split("\n");
+        const isNew = section.includes("new file mode") || section.includes("--- /dev/null");
+        const isDeleted = section.includes("deleted file mode") || section.includes("+++ /dev/null");
+        const path = extractPathFromDiffHeader(lines);
+        const { hunks, additions, deletions } = parseSectionBody(lines);
+        files.push({ path, isNew, isDeleted, additions, deletions, hunks });
+    }
+    return files;
+}
+/**
+ * Reconstruct the "new" version of a file from diff hunks.
+ * Returns a map of new line numbers to their content.
+ */
+export function reconstructNewFile(hunks) {
+    const lines = new Map();
+    for (const hunk of hunks) {
+        let newLineNum = hunk.newStart;
+        for (const line of hunk.lines) {
+            if (line.type === "header")
+                continue;
+            if (line.type === "add" || line.type === "context") {
+                lines.set(newLineNum, line.content);
+                newLineNum++;
+            }
+        }
+    }
+    return lines;
+}
+/**
+ * Reconstruct the "old" version of a file from diff hunks.
+ * Returns a map of old line numbers to their content.
+ */
+export function reconstructOldFile(hunks) {
+    const lines = new Map();
+    for (const hunk of hunks) {
+        let oldLineNum = hunk.oldStart;
+        for (const line of hunk.lines) {
+            if (line.type === "header")
+                continue;
+            if (line.type === "remove" || line.type === "context") {
+                lines.set(oldLineNum, line.content);
+                oldLineNum++;
+            }
+        }
+    }
+    return lines;
+}
+function buildFileContent(lineMap) {
+    if (lineMap.size === 0)
+        return "";
+    const lineNumbers = Array.from(lineMap.keys()).sort((a, b) => a - b);
+    const minLine = lineNumbers[0];
+    const maxLine = lineNumbers[lineNumbers.length - 1];
+    const lines = [];
+    for (let i = minLine; i <= maxLine; i++) {
+        lines.push(lineMap.get(i) ?? "");
+    }
+    return lines.join("\n");
+}
+function buildTokenLookup(lineMap, highlighted) {
+    const lookup = new Map();
+    if (lineMap.size === 0)
+        return lookup;
+    const lineNumbers = Array.from(lineMap.keys()).sort((a, b) => a - b);
+    const minLine = lineNumbers[0];
+    for (let i = 0; i < highlighted.length; i++) {
+        const lineNum = minLine + i;
+        if (lineMap.has(lineNum)) {
+            lookup.set(lineNum, highlighted[i]);
+        }
+    }
+    return lookup;
+}
+function buildFullFileTokenLookup(fileContent, path) {
+    const lookup = new Map();
+    const highlighted = highlightCode(fileContent, path);
+    for (let i = 0; i < highlighted.length; i++) {
+        lookup.set(i + 1, highlighted[i]);
+    }
+    return lookup;
+}
+function buildReconstructedTokenLookups(file) {
+    const newFileLines = reconstructNewFile(file.hunks);
+    const oldFileLines = reconstructOldFile(file.hunks);
+    const newFileContent = buildFileContent(newFileLines);
+    const oldFileContent = buildFileContent(oldFileLines);
+    const newHighlighted = highlightCode(newFileContent, file.path);
+    const oldHighlighted = highlightCode(oldFileContent, file.path);
+    return {
+        newTokensByLine: buildTokenLookup(newFileLines, newHighlighted),
+        oldTokensByLine: buildTokenLookup(oldFileLines, oldHighlighted),
+    };
+}
+/**
+ * Apply syntax highlighting to diff hunks using reconstructed file content.
+ * This is the fallback when actual file content is not available.
+ */
+export function highlightDiffFromHunks(file) {
+    if (!isLanguageSupported(file.path)) {
+        return file;
+    }
+    const { newTokensByLine, oldTokensByLine } = buildReconstructedTokenLookups(file);
+    return applyTokensToHunks(file, newTokensByLine, oldTokensByLine);
+}
+/**
+ * Apply syntax highlighting to diff hunks using actual file content.
+ * This provides better context for the parser.
+ */
+export async function highlightDiffWithFileContent(file, cwd, options = {}) {
+    if (!isLanguageSupported(file.path)) {
+        return file;
+    }
+    const reconstructedTokens = buildReconstructedTokenLookups(file);
+    let newTokensByLine = reconstructedTokens.newTokensByLine;
+    let oldTokensByLine = reconstructedTokens.oldTokensByLine;
+    if (typeof options.oldFileContent === "string") {
+        oldTokensByLine = buildFullFileTokenLookup(options.oldFileContent, file.path);
+    }
+    if (typeof options.newFileContent === "string") {
+        newTokensByLine = buildFullFileTokenLookup(options.newFileContent, file.path);
+        return applyTokensToHunks(file, newTokensByLine, oldTokensByLine);
+    }
+    const filePath = resolve(cwd, file.path);
+    try {
+        const fileContent = await readFile(filePath, "utf-8");
+        newTokensByLine = buildFullFileTokenLookup(fileContent, file.path);
+    }
+    catch {
+        // If file read fails (deleted file, etc.), fall back to reconstructed new-side tokens.
+    }
+    return applyTokensToHunks(file, newTokensByLine, oldTokensByLine);
+}
+function applyTokensToHunks(file, newTokensByLine, oldTokensByLine) {
+    const highlightedHunks = file.hunks.map((hunk) => {
+        let oldLineNum = hunk.oldStart;
+        let newLineNum = hunk.newStart;
+        const highlightedLines = hunk.lines.map((line) => {
+            if (line.type === "header") {
+                return line;
+            }
+            let tokens;
+            if (line.type === "add") {
+                tokens = newTokensByLine.get(newLineNum);
+                newLineNum++;
+            }
+            else if (line.type === "remove") {
+                tokens = oldTokensByLine.get(oldLineNum);
+                oldLineNum++;
+            }
+            else if (line.type === "context") {
+                // Context lines exist in both - use new file version
+                tokens = newTokensByLine.get(newLineNum);
+                oldLineNum++;
+                newLineNum++;
+            }
+            return tokens ? { ...line, tokens } : line;
+        });
+        return { ...hunk, lines: highlightedLines };
+    });
+    return { ...file, hunks: highlightedHunks };
+}
+/**
+ * Parse and highlight a complete diff, using actual file content when available.
+ */
+export async function parseAndHighlightDiff(diffText, cwd, options = {}) {
+    const files = parseDiff(diffText);
+    const highlightedFiles = await Promise.all(files.map(async (file) => {
+        const [oldFileContent, newFileContent] = await Promise.all([
+            options.getOldFileContent?.(file),
+            options.getNewFileContent?.(file),
+        ]);
+        return highlightDiffWithFileContent(file, cwd, {
+            oldFileContent: oldFileContent ?? undefined,
+            newFileContent: newFileContent ?? undefined,
+        });
+    }));
+    return highlightedFiles;
+}
+//# sourceMappingURL=diff-highlighter.js.map

package/dist/server/server/voice-config.d.ts

@@ -0,0 +1,15 @@
+export declare function stripVoiceModeSystemPrompt(existing?: string): string | undefined;
+export declare function buildVoiceModeSystemPrompt(existing: string | undefined, enabled: boolean): string;
+export declare function wrapSpokenInput(text: string): string;
+export declare function buildVoiceAgentMcpServerConfig(params: {
+    command: string;
+    baseArgs: string[];
+    socketPath: string;
+    env?: Record<string, string>;
+}): {
+    type: "stdio";
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+};
+//# sourceMappingURL=voice-config.d.ts.map

package/dist/server/server/voice-config.js

@@ -0,0 +1,54 @@
+const VOICE_PROMPT_BLOCK_START = "<otto_voice_mode>";
+const VOICE_PROMPT_BLOCK_END = "</otto_voice_mode>";
+const VOICE_AGENT_SYSTEM_INSTRUCTION = [
+    "Otto voice mode is now on.",
+    "You are the Otto voice assistant.",
+    "The user cannot see your chat messages or tool calls.",
+    "Always use the speak tool for all user-facing communication.",
+    "Before calling any non-speak tool, first call speak with a short acknowledgement of what you heard and what you will do next.",
+    "For long-running work, use speak to provide progress updates before and during execution.",
+    "Treat the user input as transcribed speech.",
+    "If the user intent is clear, proceed without extra confirmation.",
+    "If the transcription seems incomplete, cut off, ambiguous, or may contain a non-obvious mistake or misspelling, ask a clarifying question via speak before taking action.",
+    "Use concise plain language suitable for speech output.",
+].join(" ");
+const VOICE_AGENT_DISABLED_INSTRUCTION = [
+    "Otto voice mode is now off.",
+    "Ignore any earlier Otto voice mode instructions in this thread.",
+].join(" ");
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function makeVoicePromptBlockRegex() {
+    return new RegExp(`${escapeRegExp(VOICE_PROMPT_BLOCK_START)}[\\s\\S]*?${escapeRegExp(VOICE_PROMPT_BLOCK_END)}`, "g");
+}
+export function stripVoiceModeSystemPrompt(existing) {
+    const trimmed = existing?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const stripped = trimmed.replace(makeVoicePromptBlockRegex(), "").trim();
+    return stripped.length > 0 ? stripped : undefined;
+}
+export function buildVoiceModeSystemPrompt(existing, enabled) {
+    const basePrompt = stripVoiceModeSystemPrompt(existing);
+    const voiceInstruction = enabled
+        ? VOICE_AGENT_SYSTEM_INSTRUCTION
+        : VOICE_AGENT_DISABLED_INSTRUCTION;
+    const voiceBlock = [VOICE_PROMPT_BLOCK_START, voiceInstruction, VOICE_PROMPT_BLOCK_END].join("\n");
+    return [basePrompt, voiceBlock]
+        .filter((entry) => typeof entry === "string" && entry.length > 0)
+        .join("\n\n");
+}
+export function wrapSpokenInput(text) {
+    return `<spoken-input>\n${text}\n</spoken-input>\n<instruction>This message was spoken by the user. Respond using the speak tool only, not normal messages, because the user may not be looking at the chat.</instruction>`;
+}
+export function buildVoiceAgentMcpServerConfig(params) {
+    return {
+        type: "stdio",
+        command: params.command,
+        args: [...params.baseArgs, "--socket", params.socketPath],
+        ...(params.env ? { env: params.env } : {}),
+    };
+}
+//# sourceMappingURL=voice-config.js.map

package/dist/server/server/voice-permission-policy.d.ts

@@ -0,0 +1,4 @@
+import type { AgentPermissionRequest } from "./agent/agent-sdk-types.js";
+/** Voice assistant policy: only allow the speak tool. */
+export declare function isVoicePermissionAllowed(request: AgentPermissionRequest): boolean;
+//# sourceMappingURL=voice-permission-policy.d.ts.map

package/dist/server/server/voice-permission-policy.js

@@ -0,0 +1,13 @@
+import { isSpeakToolName } from "@otto-code/protocol/tool-name-normalization";
+/** Voice assistant policy: only allow the speak tool. */
+export function isVoicePermissionAllowed(request) {
+    if (request.kind !== "tool") {
+        return false;
+    }
+    const normalizedName = request.name.trim().toLowerCase();
+    if (!normalizedName) {
+        return false;
+    }
+    return isSpeakToolName(normalizedName);
+}
+//# sourceMappingURL=voice-permission-policy.js.map

package/dist/server/server/voice-types.d.ts

@@ -0,0 +1,12 @@
+export type VoiceSpeakHandler = (params: {
+    text: string;
+    callerAgentId: string;
+    signal?: AbortSignal;
+}) => Promise<void>;
+export interface VoiceCallerContext {
+    childAgentDefaultLabels?: Record<string, string>;
+    lockedCwd?: string;
+    allowCustomCwd?: boolean;
+    enableVoiceTools?: boolean;
+}
+//# sourceMappingURL=voice-types.d.ts.map

package/dist/server/server/voice-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=voice-types.js.map

package/dist/server/server/web-ui.d.ts

@@ -0,0 +1,10 @@
+import type { RequestHandler } from "express";
+import type { Logger } from "pino";
+export interface WebUiMiddlewareOptions {
+    enabled: boolean;
+    distDir: string | null;
+    label: string;
+    logger: Logger;
+}
+export declare function createWebUiMiddleware(options: WebUiMiddlewareOptions): RequestHandler;
+//# sourceMappingURL=web-ui.d.ts.map