@otto-code/server 0.5.0

package/dist/server/executable-resolution/executable-resolution.js

@@ -0,0 +1,118 @@
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import { execCommand } from "../utils/spawn.js";
+import { isWindowsCommandScript } from "../utils/windows-command.js";
+import { windowsExecutableResolution } from "./windows.js";
+export { quoteWindowsArgument, quoteWindowsCommand } from "../utils/windows-command.js";
+const require = createRequire(import.meta.url);
+const which = require("which");
+const PROBE_TIMEOUT_MS = 2000;
+function hasPathSeparator(value) {
+    return value.includes("/") || value.includes("\\");
+}
+async function enumerateCandidates(name) {
+    if (process.platform !== "win32" && existsSync("/usr/bin/which")) {
+        return enumerateCandidatesViaSystemWhich(name);
+    }
+    return enumerateCandidatesViaLibrary(name);
+}
+async function enumerateCandidatesViaSystemWhich(name) {
+    try {
+        const { stdout } = await execCommand("/usr/bin/which", ["-a", name], {
+            timeout: 3000,
+            killSignal: "SIGKILL",
+        });
+        return Array.from(new Set(stdout.trim().split("\n").filter(Boolean)));
+    }
+    catch {
+        return [];
+    }
+}
+async function enumerateCandidatesViaLibrary(name) {
+    let candidates;
+    try {
+        candidates = await which(name, { all: true });
+    }
+    catch (error) {
+        // `which` throws ENOENT when the command is absent from PATH.
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+    const seen = new Set();
+    return candidates.filter((candidate) => {
+        if (seen.has(candidate)) {
+            return false;
+        }
+        seen.add(candidate);
+        return true;
+    });
+}
+export async function probeExecutable(executablePath, timeoutMs = PROBE_TIMEOUT_MS) {
+    try {
+        await execCommand(executablePath, ["--version"], {
+            timeout: timeoutMs,
+            killSignal: "SIGKILL",
+            maxBuffer: 64 * 1024,
+            shell: isWindowsCommandScript(executablePath),
+        });
+        return true;
+    }
+    catch (error) {
+        return classifyProbeError(error);
+    }
+}
+function classifyProbeError(error) {
+    const err = error;
+    if (err.killed) {
+        return true;
+    }
+    if (typeof err.code === "number") {
+        return true;
+    }
+    if (err.code === "ENOENT" ||
+        err.code === "EACCES" ||
+        err.code === "ENOEXEC" ||
+        err.code === "UNKNOWN") {
+        return false;
+    }
+    return false;
+}
+/**
+ * Check a literal executable path. PATH search is handled by findExecutable().
+ */
+export function executableExists(executablePath, exists = existsSync) {
+    if (process.platform === "win32") {
+        return windowsExecutableResolution.exists(executablePath, { exists });
+    }
+    return exists(executablePath) ? executablePath : null;
+}
+export async function findExecutable(name, probeTimeoutMs = PROBE_TIMEOUT_MS) {
+    const trimmed = name.trim();
+    if (!trimmed) {
+        return null;
+    }
+    if (process.platform === "win32") {
+        return windowsExecutableResolution.find(trimmed, {
+            enumeratePathCandidates: enumerateCandidates,
+            probeExecutable,
+            exists: existsSync,
+            probeTimeoutMs,
+        });
+    }
+    if (hasPathSeparator(trimmed)) {
+        return (await probeExecutable(trimmed, probeTimeoutMs)) ? trimmed : null;
+    }
+    const candidates = await enumerateCandidates(trimmed);
+    for (const candidate of candidates) {
+        if (await probeExecutable(candidate, probeTimeoutMs)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+export async function isCommandAvailable(command) {
+    return (await findExecutable(command)) !== null;
+}
+//# sourceMappingURL=executable-resolution.js.map

package/dist/server/executable-resolution/windows.d.ts

@@ -0,0 +1,18 @@
+interface WindowsFindExecutableOptions {
+    enumeratePathCandidates: (name: string) => Promise<string[]>;
+    probeExecutable: (executablePath: string, timeoutMs: number) => Promise<boolean>;
+    exists: (path: string) => boolean;
+    localAppData?: string;
+    probeTimeoutMs: number;
+}
+interface WindowsExecutableExistsOptions {
+    exists: (path: string) => boolean;
+}
+declare function find(input: string, options: WindowsFindExecutableOptions): Promise<string | null>;
+declare function exists(executablePath: string, options: WindowsExecutableExistsOptions): string | null;
+export declare const windowsExecutableResolution: {
+    exists: typeof exists;
+    find: typeof find;
+};
+export {};
+//# sourceMappingURL=windows.d.ts.map

package/dist/server/executable-resolution/windows.js

@@ -0,0 +1,65 @@
+import { readdirSync } from "node:fs";
+import { extname, join } from "node:path";
+function hasPathSeparator(value) {
+    return value.includes("/") || value.includes("\\");
+}
+function enumerateLiteralPathCandidates(executablePath) {
+    if (extname(executablePath)) {
+        return [executablePath];
+    }
+    return [executablePath, `${executablePath}.exe`, `${executablePath}.cmd`];
+}
+function enumerateWingetPackageCandidates(name, localAppData) {
+    if (!localAppData) {
+        return [];
+    }
+    const wingetPackages = join(localAppData, "Microsoft", "WinGet", "Packages");
+    let packageDirs;
+    try {
+        packageDirs = readdirSync(wingetPackages, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+    const exeName = `${name}.exe`;
+    return packageDirs.map((packageDir) => join(wingetPackages, packageDir, exeName));
+}
+async function find(input, options) {
+    if (hasPathSeparator(input)) {
+        return findFirstProbeable(enumerateLiteralPathCandidates(input), options);
+    }
+    const pathCandidates = await options.enumeratePathCandidates(input);
+    const wingetCandidates = enumerateWingetPackageCandidates(input, options.localAppData ?? process.env.LOCALAPPDATA).filter(options.exists);
+    return findFirstProbeable([...pathCandidates, ...wingetCandidates], options);
+}
+async function findFirstProbeable(candidates, options) {
+    const seen = new Set();
+    for (const candidate of candidates) {
+        if (seen.has(candidate)) {
+            continue;
+        }
+        seen.add(candidate);
+        if (!options.exists(candidate)) {
+            continue;
+        }
+        if (await options.probeExecutable(candidate, options.probeTimeoutMs)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function exists(executablePath, options) {
+    for (const candidate of enumerateLiteralPathCandidates(executablePath)) {
+        if (options.exists(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+export const windowsExecutableResolution = {
+    exists,
+    find,
+};
+//# sourceMappingURL=windows.js.map

package/dist/server/server/agent/activity-curator.d.ts

@@ -0,0 +1,28 @@
+import type { AgentTimelineItem } from "./agent-sdk-types.js";
+import type { AgentAttachment } from "@otto-code/protocol/messages";
+import type { AgentTimelineRow } from "./agent-timeline-store-types.js";
+interface ActivityCuratorOptions {
+    maxItems?: number;
+    labelAssistantMessages?: boolean;
+    includeKinds?: readonly AgentTimelineItem["type"][];
+    includeExternalToolInput?: boolean;
+}
+type TextAgentAttachment = Extract<AgentAttachment, {
+    type: "text";
+}>;
+/**
+ * Convert normalized agent timeline items into a concise text summary.
+ */
+export declare function curateAgentActivity(timeline: AgentTimelineItem[], options?: ActivityCuratorOptions): string;
+export declare function buildAgentForkContextAttachment(input: {
+    rows: readonly AgentTimelineRow[];
+    boundaryMessageId?: string | null;
+    agentTitle?: string | null;
+    cwd?: string | null;
+}): {
+    attachment: TextAgentAttachment;
+    itemCount: number;
+    boundaryMessageId: string | null;
+};
+export {};
+//# sourceMappingURL=activity-curator.d.ts.map

package/dist/server/server/agent/activity-curator.js

@@ -0,0 +1,227 @@
+import { isLikelyExternalToolName } from "@otto-code/protocol/tool-name-normalization";
+import { buildToolCallDisplayModel } from "@otto-code/protocol/tool-call-display";
+import { projectTimelineRows } from "./timeline-projection.js";
+const DEFAULT_MAX_ITEMS = 0;
+const MAX_TOOL_INPUT_CHARS = 400;
+const MAX_TOOL_SUMMARY_CHARS = 200;
+function appendText(buffer, text) {
+    const normalized = text.trim();
+    if (!normalized) {
+        return buffer;
+    }
+    if (!buffer) {
+        return normalized;
+    }
+    return `${buffer}\n${normalized}`;
+}
+function activityEntry(text) {
+    return { text };
+}
+function flushBuffers(entries, buffers, options) {
+    if (buffers.message.trim()) {
+        const text = buffers.message.trim();
+        entries.push(activityEntry(options?.labelAssistantMessages ? `[Assistant] ${text}` : text));
+    }
+    if (buffers.thought.trim()) {
+        const text = buffers.thought.trim();
+        entries.push(activityEntry(`[Thought] ${text}`));
+    }
+    buffers.message = "";
+    buffers.thought = "";
+}
+function formatToolInputJson(input) {
+    if (input === undefined) {
+        return null;
+    }
+    try {
+        const encoded = JSON.stringify(input);
+        if (!encoded) {
+            return null;
+        }
+        if (encoded.length <= MAX_TOOL_INPUT_CHARS) {
+            return encoded;
+        }
+        return `${encoded.slice(0, MAX_TOOL_INPUT_CHARS)}...`;
+    }
+    catch {
+        return null;
+    }
+}
+function formatToolSummary(summary) {
+    if (typeof summary !== "string") {
+        return null;
+    }
+    const normalized = summary.replace(/\s+/g, " ").trim();
+    if (!normalized) {
+        return null;
+    }
+    if (normalized.length <= MAX_TOOL_SUMMARY_CHARS) {
+        return normalized;
+    }
+    return `${normalized.slice(0, MAX_TOOL_SUMMARY_CHARS - 3)}...`;
+}
+function inputFromUnknownDetail(detail) {
+    return detail.type === "unknown" ? detail.input : null;
+}
+function projectForCuration(items) {
+    const rows = items.map((item, index) => ({
+        seq: index + 1,
+        timestamp: "",
+        item,
+    }));
+    return projectTimelineRows({ rows, mode: "projected" }).map((entry) => entry.item);
+}
+function shouldIncludeItem(item, options) {
+    if (!options?.includeKinds) {
+        return true;
+    }
+    return options.includeKinds.includes(item.type);
+}
+function formatToolCallEntry(item, options) {
+    const inputJson = formatToolInputJson(inputFromUnknownDetail(item.detail));
+    const display = buildToolCallDisplayModel({
+        name: item.name,
+        status: item.status,
+        error: item.error,
+        detail: item.detail,
+        metadata: item.metadata,
+    });
+    const displayName = display.displayName;
+    const summary = formatToolSummary(display.summary);
+    if ((options?.includeExternalToolInput ?? true) &&
+        isLikelyExternalToolName(item.name) &&
+        inputJson) {
+        return activityEntry(`[${displayName}] ${inputJson}`);
+    }
+    return activityEntry(summary ? `[${displayName}] ${summary}` : `[${displayName}]`);
+}
+function curateProjectedActivityEntries(items, options) {
+    if (items.length === 0) {
+        return [];
+    }
+    const maxItems = options?.maxItems ?? DEFAULT_MAX_ITEMS;
+    const recentItems = maxItems > 0 && items.length > maxItems ? items.slice(-maxItems) : items;
+    const entries = [];
+    const buffers = { message: "", thought: "" };
+    for (const item of recentItems) {
+        if (!shouldIncludeItem(item, options)) {
+            continue;
+        }
+        switch (item.type) {
+            case "user_message":
+                flushBuffers(entries, buffers, options);
+                entries.push(activityEntry(`[User] ${item.text.trim()}`));
+                break;
+            case "assistant_message":
+                buffers.message = appendText(buffers.message, item.text);
+                break;
+            case "reasoning":
+                buffers.thought = appendText(buffers.thought, item.text);
+                break;
+            case "tool_call": {
+                flushBuffers(entries, buffers, options);
+                entries.push(formatToolCallEntry(item, options));
+                break;
+            }
+            case "todo":
+                flushBuffers(entries, buffers, options);
+                entries.push(activityEntry("[Tasks]"));
+                for (const entry of item.items) {
+                    const checkbox = entry.completed ? "[x]" : "[ ]";
+                    const text = `- ${checkbox} ${entry.text}`;
+                    entries.push(activityEntry(text));
+                }
+                break;
+            case "error":
+                flushBuffers(entries, buffers, options);
+                entries.push(activityEntry(`[Error] ${item.message}`));
+                break;
+            case "compaction":
+                flushBuffers(entries, buffers, options);
+                entries.push(activityEntry("[Compacted]"));
+                break;
+        }
+    }
+    flushBuffers(entries, buffers, options);
+    return entries;
+}
+function curateAgentActivityEntries(timeline, options) {
+    const collapsed = projectForCuration(timeline);
+    return curateProjectedActivityEntries(collapsed, options);
+}
+/**
+ * Convert normalized agent timeline items into a concise text summary.
+ */
+export function curateAgentActivity(timeline, options) {
+    const entries = curateAgentActivityEntries(timeline, options);
+    return entries.length > 0
+        ? entries.map((entry) => entry.text).join("\n")
+        : "No activity to display.";
+}
+function selectForkContextRows(input) {
+    const boundaryMessageId = input.boundaryMessageId?.trim() || null;
+    if (!boundaryMessageId) {
+        const projected = projectTimelineRows({ rows: input.rows, mode: "projected" });
+        return {
+            items: projected.map((entry) => entry.item),
+            boundaryMessageId: null,
+        };
+    }
+    const boundaryIndex = input.rows.findLastIndex((row) => row.item.type === "assistant_message" && row.item.messageId === boundaryMessageId);
+    if (boundaryIndex < 0) {
+        throw new Error("Selected assistant message is no longer available.");
+    }
+    const selectedRows = input.rows.slice(0, boundaryIndex + 1);
+    const projected = projectTimelineRows({ rows: selectedRows, mode: "projected" });
+    return {
+        items: projected.map((entry) => entry.item),
+        boundaryMessageId,
+    };
+}
+function trimContextMetadata(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : null;
+}
+function buildForkContextText(input) {
+    const header = ["Chat history from a previous Otto agent."];
+    const agentTitle = trimContextMetadata(input.agentTitle);
+    const cwd = trimContextMetadata(input.cwd);
+    if (agentTitle) {
+        header.push(`Source agent: ${agentTitle}`);
+    }
+    if (cwd) {
+        header.push(`Source directory: ${cwd}`);
+    }
+    return `${header.join("\n")}\n\n${input.body}`;
+}
+export function buildAgentForkContextAttachment(input) {
+    const selected = selectForkContextRows({
+        rows: input.rows,
+        boundaryMessageId: input.boundaryMessageId,
+    });
+    const entries = curateProjectedActivityEntries(selected.items, {
+        maxItems: 0,
+        labelAssistantMessages: true,
+        includeKinds: ["user_message", "assistant_message", "tool_call"],
+        includeExternalToolInput: false,
+    });
+    const body = entries.length > 0
+        ? entries.map((entry) => entry.text).join("\n")
+        : "No chat history to display.";
+    return {
+        attachment: {
+            type: "text",
+            mimeType: "text/plain",
+            contextKind: "chat_history",
+            title: "Chat history",
+            text: buildForkContextText({
+                body,
+                agentTitle: input.agentTitle,
+                cwd: input.cwd,
+            }),
+        },
+        itemCount: selected.items.length,
+        boundaryMessageId: selected.boundaryMessageId,
+    };
+}
+//# sourceMappingURL=activity-curator.js.map

package/dist/server/server/agent/agent-archive.d.ts

@@ -0,0 +1,11 @@
+import type { StoredAgentRecord } from "./agent-storage.js";
+export type ArchivedStoredAgentRecord = StoredAgentRecord & {
+    archivedAt: string;
+};
+interface BuildArchivedAgentRecordOptions {
+    archivedAt?: string;
+    updatedAt?: string;
+}
+export declare function buildArchivedAgentRecord(record: StoredAgentRecord, options?: BuildArchivedAgentRecordOptions): ArchivedStoredAgentRecord;
+export {};
+//# sourceMappingURL=agent-archive.d.ts.map

package/dist/server/server/agent/agent-archive.js

@@ -0,0 +1,16 @@
+export function buildArchivedAgentRecord(record, options) {
+    const archivedAt = options?.archivedAt ?? new Date().toISOString();
+    return {
+        ...record,
+        archivedAt,
+        updatedAt: options?.updatedAt ?? record.updatedAt,
+        lastStatus: normalizeArchivedStatus(record.lastStatus),
+        requiresAttention: false,
+        attentionReason: null,
+        attentionTimestamp: null,
+    };
+}
+function normalizeArchivedStatus(status) {
+    return status === "running" || status === "initializing" ? "idle" : status;
+}
+//# sourceMappingURL=agent-archive.js.map

package/dist/server/server/agent/agent-loading.d.ts

@@ -0,0 +1,14 @@
+import type { Logger } from "pino";
+import type { AgentProvider } from "./agent-sdk-types.js";
+import type { AgentManager, ManagedAgent } from "./agent-manager.js";
+import type { AgentStorage } from "./agent-storage.js";
+type AgentLoaderManager = Pick<AgentManager, "createAgent" | "getAgent" | "getRegisteredProviderIds" | "hydrateTimelineFromProvider" | "resumeAgentFromPersistence">;
+export interface EnsureAgentLoadedDeps {
+    agentManager: AgentLoaderManager;
+    agentStorage: AgentStorage;
+    validProviders?: Iterable<AgentProvider>;
+    logger: Logger;
+}
+export declare function ensureAgentLoaded(agentId: string, deps: EnsureAgentLoadedDeps): Promise<ManagedAgent>;
+export {};
+//# sourceMappingURL=agent-loading.d.ts.map

package/dist/server/server/agent/agent-loading.js

@@ -0,0 +1,54 @@
+import { buildConfigOverrides, buildSessionConfig, extractTimestamps, isStoredAgentProviderAvailable, toAgentPersistenceHandle, } from "../persistence-hooks.js";
+const pendingAgentInitializations = new Map();
+export async function ensureAgentLoaded(agentId, deps) {
+    const existing = deps.agentManager.getAgent(agentId);
+    if (existing) {
+        return existing;
+    }
+    const inflight = pendingAgentInitializations.get(agentId);
+    if (inflight) {
+        return inflight;
+    }
+    const initPromise = (async () => {
+        const record = await deps.agentStorage.get(agentId);
+        if (!record) {
+            throw new Error(`Agent not found: ${agentId}`);
+        }
+        const validProviders = deps.validProviders ?? deps.agentManager.getRegisteredProviderIds();
+        if (!isStoredAgentProviderAvailable(record, validProviders)) {
+            throw new Error(`Agent ${agentId} references unavailable provider '${record.provider}'`);
+        }
+        const handle = toAgentPersistenceHandle(validProviders, record.persistence);
+        let snapshot;
+        if (handle) {
+            snapshot = await deps.agentManager.resumeAgentFromPersistence(handle, buildConfigOverrides(record), agentId, extractTimestamps(record));
+            deps.logger.info({ agentId, provider: record.provider }, "Agent resumed from persistence");
+        }
+        else {
+            const config = buildSessionConfig(record, {
+                validProviders,
+            });
+            if (!config) {
+                throw new Error(`Agent ${agentId} references unavailable provider '${record.provider}'`);
+            }
+            snapshot = await deps.agentManager.createAgent(config, agentId, {
+                labels: record.labels,
+                workspaceId: record.workspaceId,
+            });
+            deps.logger.info({ agentId, provider: record.provider }, "Agent created from stored config");
+        }
+        await deps.agentManager.hydrateTimelineFromProvider(agentId);
+        return deps.agentManager.getAgent(agentId) ?? snapshot;
+    })();
+    pendingAgentInitializations.set(agentId, initPromise);
+    try {
+        return await initPromise;
+    }
+    finally {
+        const current = pendingAgentInitializations.get(agentId);
+        if (current === initPromise) {
+            pendingAgentInitializations.delete(agentId);
+        }
+    }
+}
+//# sourceMappingURL=agent-loading.js.map