@otto-code/server 0.5.0

package/dist/server/server/hostnames.js

@@ -0,0 +1,94 @@
+import net from "node:net";
+function normalizeHostname(hostname) {
+    return hostname.trim().toLowerCase();
+}
+function parseHostnameFromHostHeader(hostHeader) {
+    const trimmed = hostHeader.trim();
+    if (!trimmed)
+        return null;
+    // IPv6 in brackets: [::1]:6868
+    if (trimmed.startsWith("[")) {
+        const end = trimmed.indexOf("]");
+        if (end === -1)
+            return null;
+        return normalizeHostname(trimmed.slice(1, end));
+    }
+    // IPv4/hostname with optional port: localhost:6868
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1) {
+        return normalizeHostname(trimmed);
+    }
+    return normalizeHostname(trimmed.slice(0, colonIndex));
+}
+function matchesHostnamePattern(hostname, pattern) {
+    const normalizedPattern = normalizeHostname(pattern);
+    if (!normalizedPattern)
+        return false;
+    if (normalizedPattern.startsWith(".")) {
+        const base = normalizedPattern.slice(1);
+        if (!base)
+            return false;
+        return hostname === base || hostname.endsWith(`.${base}`);
+    }
+    return hostname === normalizedPattern;
+}
+function isDefaultAllowedHostname(hostname) {
+    // Vite-style defaults: localhost, *.localhost, and all IP addresses.
+    if (hostname === "localhost")
+        return true;
+    if (hostname.endsWith(".localhost"))
+        return true;
+    if (net.isIP(hostname) !== 0)
+        return true;
+    return false;
+}
+/**
+ * Vite-style hostname allowlist check, adapted to raw Host headers.
+ *
+ * Semantics:
+ * - `hostnames === true` => allow any host.
+ * - `hostnames === []` or `undefined` => allow localhost, *.localhost, and all IPs.
+ * - `hostnames === ['.example.com', 'myhost']` => allow those *in addition* to defaults.
+ */
+export function isHostnameAllowed(hostHeader, hostnames) {
+    const hostname = hostHeader ? parseHostnameFromHostHeader(hostHeader) : null;
+    if (!hostname)
+        return false;
+    if (hostnames === true)
+        return true;
+    // Defaults are always allowed.
+    if (isDefaultAllowedHostname(hostname))
+        return true;
+    const patterns = hostnames ?? [];
+    for (const pattern of patterns) {
+        if (matchesHostnamePattern(hostname, pattern))
+            return true;
+    }
+    return false;
+}
+export function mergeHostnames(values) {
+    let merged = [];
+    for (const value of values) {
+        if (value === true)
+            return true;
+        if (!value)
+            continue;
+        merged = merged.concat(value);
+    }
+    const deduped = Array.from(new Set(merged.map((v) => v.trim()).filter((v) => v.length > 0)));
+    return deduped;
+}
+export function parseHostnamesEnv(raw) {
+    if (!raw)
+        return undefined;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return undefined;
+    if (trimmed.toLowerCase() === "true")
+        return true;
+    return trimmed
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+}
+//# sourceMappingURL=hostnames.js.map

package/dist/server/server/json-utils.d.ts

@@ -0,0 +1,11 @@
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/**
+ * Coerce arbitrary values into JSON-safe structures.
+ * Unlike the previous implementation, this never throws on undefined—
+ * it replaces unsupported values (undefined, functions, symbols) with null
+ * so responses always make it back to the client.
+ */
+export declare function ensureValidJson<T>(value: T): T;
+//# sourceMappingURL=json-utils.d.ts.map

package/dist/server/server/json-utils.js

@@ -0,0 +1,45 @@
+/**
+ * Coerce arbitrary values into JSON-safe structures.
+ * Unlike the previous implementation, this never throws on undefined—
+ * it replaces unsupported values (undefined, functions, symbols) with null
+ * so responses always make it back to the client.
+ */
+export function ensureValidJson(value) {
+    const seen = new WeakSet();
+    const sanitize = (current) => {
+        if (current === null || current === undefined) {
+            return null;
+        }
+        if (typeof current === "string" || typeof current === "number") {
+            return current;
+        }
+        if (typeof current === "boolean") {
+            return current;
+        }
+        if (typeof current === "bigint") {
+            return current.toString();
+        }
+        if (current instanceof Date) {
+            return current.toISOString();
+        }
+        if (Array.isArray(current)) {
+            return current.map((item) => sanitize(item));
+        }
+        if (typeof current === "object") {
+            if (seen.has(current)) {
+                throw new Error("Cannot serialize circular structure to JSON");
+            }
+            seen.add(current);
+            const obj = {};
+            for (const [key, val] of Object.entries(current)) {
+                obj[key] = sanitize(val);
+            }
+            seen.delete(current);
+            return obj;
+        }
+        // functions, symbols, undefined, etc.
+        return null;
+    };
+    return sanitize(value);
+}
+//# sourceMappingURL=json-utils.js.map

package/dist/server/server/lifecycle-reasons.d.ts

@@ -0,0 +1,4 @@
+export declare const CLIENT_SHUTDOWN_RPC_REASON = "client_shutdown_rpc";
+export declare const DEFAULT_CLIENT_RESTART_RPC_REASON = "client_restart_rpc";
+export declare function normalizeClientRestartRpcReason(reason: string | undefined): string;
+//# sourceMappingURL=lifecycle-reasons.d.ts.map

package/dist/server/server/lifecycle-reasons.js

@@ -0,0 +1,6 @@
+export const CLIENT_SHUTDOWN_RPC_REASON = "client_shutdown_rpc";
+export const DEFAULT_CLIENT_RESTART_RPC_REASON = "client_restart_rpc";
+export function normalizeClientRestartRpcReason(reason) {
+    return reason?.trim() || DEFAULT_CLIENT_RESTART_RPC_REASON;
+}
+//# sourceMappingURL=lifecycle-reasons.js.map

package/dist/server/server/logger.d.ts

@@ -0,0 +1,29 @@
+import pino from "pino";
+import type { PersistedConfig } from "./persisted-config.js";
+export type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal";
+export type LogFormat = "pretty" | "json";
+export interface ResolvedLogConfig {
+    level: LogLevel;
+    console: {
+        level: LogLevel;
+        format: LogFormat;
+    };
+    file?: {
+        level: LogLevel;
+        path: string;
+    };
+}
+interface LegacyLogConfig {
+    level?: LogLevel;
+    format?: LogFormat;
+}
+type LoggerConfigInput = PersistedConfig | LegacyLogConfig | undefined;
+interface ResolveLogConfigOptions {
+    ottoHome?: string;
+    file?: boolean;
+}
+export declare function resolveLogConfig(configInput: LoggerConfigInput, options?: ResolveLogConfigOptions): ResolvedLogConfig;
+export declare function createRootLogger(configInput: LoggerConfigInput, options?: ResolveLogConfigOptions): pino.Logger;
+export declare function createChildLogger(parent: pino.Logger, name: string): pino.Logger;
+export {};
+//# sourceMappingURL=logger.d.ts.map

package/dist/server/server/logger.js

@@ -0,0 +1,125 @@
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import pino from "pino";
+import pretty from "pino-pretty";
+import { resolveOttoHome } from "./otto-home.js";
+const LOG_LEVEL_PRIORITIES = {
+    trace: 10,
+    debug: 20,
+    info: 30,
+    warn: 40,
+    error: 50,
+    fatal: 60,
+};
+const DEFAULT_CONSOLE_LEVEL = "info";
+const DEFAULT_CONSOLE_FORMAT = "json";
+const DEFAULT_FILE_LEVEL = "info";
+const DEFAULT_DAEMON_LOG_FILENAME = "daemon.log";
+const REDACT_PATHS = [
+    "authorization",
+    "Authorization",
+    "headers.authorization",
+    "headers.Authorization",
+    "req.headers.authorization",
+    "req.headers.Authorization",
+    '["sec-websocket-protocol"]',
+    "Sec-WebSocket-Protocol",
+    'headers["sec-websocket-protocol"]',
+    "headers.Sec-WebSocket-Protocol",
+    'req.headers["sec-websocket-protocol"]',
+    "req.headers.Sec-WebSocket-Protocol",
+];
+function resolveFilePath(ottoHome, configuredPath) {
+    const fallback = path.join(ottoHome, DEFAULT_DAEMON_LOG_FILENAME);
+    if (!configuredPath) {
+        return fallback;
+    }
+    if (path.isAbsolute(configuredPath)) {
+        return configuredPath;
+    }
+    return path.resolve(ottoHome, configuredPath);
+}
+function minLogLevel(levels) {
+    let minLevel = levels[0];
+    for (const level of levels) {
+        if (LOG_LEVEL_PRIORITIES[level] < LOG_LEVEL_PRIORITIES[minLevel]) {
+            minLevel = level;
+        }
+    }
+    return minLevel;
+}
+function resolveConfiguredOttoHome(options) {
+    if (options?.ottoHome) {
+        return options.ottoHome;
+    }
+    return resolveOttoHome();
+}
+function normalizeLoggerConfigInput(config) {
+    if (!config) {
+        return undefined;
+    }
+    if ("log" in config) {
+        return config;
+    }
+    if ("level" in config || "format" in config) {
+        const legacy = config;
+        return {
+            log: {
+                ...(legacy.level ? { level: legacy.level } : {}),
+                ...(legacy.format ? { format: legacy.format } : {}),
+            },
+        };
+    }
+    return config;
+}
+function resolveLogLevelsAndFormat(persistedLog) {
+    const persistedGlobalLevel = persistedLog?.level;
+    const consoleLevel = persistedLog?.console?.level ?? persistedGlobalLevel ?? DEFAULT_CONSOLE_LEVEL;
+    const fileLevel = persistedLog?.file
+        ? (persistedLog.file.level ?? persistedGlobalLevel ?? DEFAULT_FILE_LEVEL)
+        : undefined;
+    const consoleFormat = persistedLog?.console?.format ?? persistedLog?.format ?? DEFAULT_CONSOLE_FORMAT;
+    return { consoleLevel, fileLevel, consoleFormat };
+}
+export function resolveLogConfig(configInput, options) {
+    const persistedConfig = normalizeLoggerConfigInput(configInput);
+    const ottoHome = resolveConfiguredOttoHome(options);
+    const persistedLog = persistedConfig?.log;
+    const { consoleLevel, fileLevel, consoleFormat } = resolveLogLevelsAndFormat(persistedLog);
+    const file = options?.file !== false && persistedLog?.file
+        ? {
+            level: fileLevel ?? DEFAULT_FILE_LEVEL,
+            path: resolveFilePath(ottoHome, persistedLog.file.path),
+        }
+        : undefined;
+    return {
+        level: minLogLevel(file ? [consoleLevel, file.level] : [consoleLevel]),
+        console: {
+            level: consoleLevel,
+            format: consoleFormat,
+        },
+        ...(file ? { file } : {}),
+    };
+}
+export function createRootLogger(configInput, options) {
+    const config = resolveLogConfig(configInput, options);
+    if (config.file) {
+        mkdirSync(path.dirname(config.file.path), { recursive: true });
+    }
+    const stream = config.console.format === "pretty"
+        ? pretty({
+            colorize: true,
+            singleLine: true,
+            ignore: "pid,hostname",
+            destination: config.file?.path ?? 1,
+        })
+        : pino.destination({ dest: config.file?.path ?? 1, sync: false });
+    return pino({
+        level: config.file?.level ?? config.console.level,
+        redact: { paths: REDACT_PATHS, remove: true },
+    }, stream);
+}
+export function createChildLogger(parent, name) {
+    return parent.child({ name });
+}
+//# sourceMappingURL=logger.js.map

package/dist/server/server/loop-service.d.ts

@@ -0,0 +1,234 @@
+import { z } from "zod";
+import type { Logger } from "pino";
+import { type BoundCreateAgentCommand, type EnsureWorkspaceForCreate } from "./agent/create-agent/create.js";
+import type { AgentManager } from "./agent/agent-manager.js";
+import type { AgentProvider } from "./agent/agent-sdk-types.js";
+declare const LoopLogEntrySchema: z.ZodObject<{
+    seq: z.ZodNumber;
+    timestamp: z.ZodString;
+    iteration: z.ZodNullable<z.ZodNumber>;
+    source: z.ZodEnum<{
+        worker: "worker";
+        loop: "loop";
+        verifier: "verifier";
+        "verify-check": "verify-check";
+    }>;
+    level: z.ZodEnum<{
+        error: "error";
+        info: "info";
+    }>;
+    text: z.ZodString;
+}, z.core.$strip>;
+declare const LoopVerifyCheckResultSchema: z.ZodObject<{
+    command: z.ZodString;
+    exitCode: z.ZodNumber;
+    passed: z.ZodBoolean;
+    stdout: z.ZodString;
+    stderr: z.ZodString;
+    startedAt: z.ZodString;
+    completedAt: z.ZodString;
+}, z.core.$strip>;
+declare const LoopVerifyPromptResultSchema: z.ZodObject<{
+    passed: z.ZodBoolean;
+    reason: z.ZodString;
+    verifierAgentId: z.ZodNullable<z.ZodString>;
+    startedAt: z.ZodString;
+    completedAt: z.ZodString;
+}, z.core.$strip>;
+declare const LoopIterationRecordSchema: z.ZodObject<{
+    index: z.ZodNumber;
+    workerAgentId: z.ZodNullable<z.ZodString>;
+    workerStartedAt: z.ZodString;
+    workerCompletedAt: z.ZodNullable<z.ZodString>;
+    verifierAgentId: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        running: "running";
+        failed: "failed";
+        stopped: "stopped";
+        succeeded: "succeeded";
+    }>;
+    workerOutcome: z.ZodNullable<z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        canceled: "canceled";
+    }>>;
+    failureReason: z.ZodNullable<z.ZodString>;
+    verifyChecks: z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        exitCode: z.ZodNumber;
+        passed: z.ZodBoolean;
+        stdout: z.ZodString;
+        stderr: z.ZodString;
+        startedAt: z.ZodString;
+        completedAt: z.ZodString;
+    }, z.core.$strip>>;
+    verifyPrompt: z.ZodNullable<z.ZodObject<{
+        passed: z.ZodBoolean;
+        reason: z.ZodString;
+        verifierAgentId: z.ZodNullable<z.ZodString>;
+        startedAt: z.ZodString;
+        completedAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const LoopRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    prompt: z.ZodString;
+    cwd: z.ZodString;
+    provider: z.ZodString;
+    model: z.ZodNullable<z.ZodString>;
+    modeId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    workerProvider: z.ZodNullable<z.ZodString>;
+    workerModel: z.ZodNullable<z.ZodString>;
+    verifierProvider: z.ZodNullable<z.ZodString>;
+    verifierModel: z.ZodNullable<z.ZodString>;
+    verifierModeId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    verifyPrompt: z.ZodNullable<z.ZodString>;
+    verifyChecks: z.ZodArray<z.ZodString>;
+    archive: z.ZodBoolean;
+    sleepMs: z.ZodNumber;
+    maxIterations: z.ZodNullable<z.ZodNumber>;
+    maxTimeMs: z.ZodNullable<z.ZodNumber>;
+    status: z.ZodEnum<{
+        running: "running";
+        failed: "failed";
+        stopped: "stopped";
+        succeeded: "succeeded";
+    }>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    startedAt: z.ZodString;
+    completedAt: z.ZodNullable<z.ZodString>;
+    stopRequestedAt: z.ZodNullable<z.ZodString>;
+    iterations: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        workerAgentId: z.ZodNullable<z.ZodString>;
+        workerStartedAt: z.ZodString;
+        workerCompletedAt: z.ZodNullable<z.ZodString>;
+        verifierAgentId: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            running: "running";
+            failed: "failed";
+            stopped: "stopped";
+            succeeded: "succeeded";
+        }>;
+        workerOutcome: z.ZodNullable<z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+            canceled: "canceled";
+        }>>;
+        failureReason: z.ZodNullable<z.ZodString>;
+        verifyChecks: z.ZodArray<z.ZodObject<{
+            command: z.ZodString;
+            exitCode: z.ZodNumber;
+            passed: z.ZodBoolean;
+            stdout: z.ZodString;
+            stderr: z.ZodString;
+            startedAt: z.ZodString;
+            completedAt: z.ZodString;
+        }, z.core.$strip>>;
+        verifyPrompt: z.ZodNullable<z.ZodObject<{
+            passed: z.ZodBoolean;
+            reason: z.ZodString;
+            verifierAgentId: z.ZodNullable<z.ZodString>;
+            startedAt: z.ZodString;
+            completedAt: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    logs: z.ZodArray<z.ZodObject<{
+        seq: z.ZodNumber;
+        timestamp: z.ZodString;
+        iteration: z.ZodNullable<z.ZodNumber>;
+        source: z.ZodEnum<{
+            worker: "worker";
+            loop: "loop";
+            verifier: "verifier";
+            "verify-check": "verify-check";
+        }>;
+        level: z.ZodEnum<{
+            error: "error";
+            info: "info";
+        }>;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    nextLogSeq: z.ZodNumber;
+    activeIteration: z.ZodNullable<z.ZodNumber>;
+    activeWorkerAgentId: z.ZodNullable<z.ZodString>;
+    activeVerifierAgentId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type LoopStatus = z.infer<typeof LoopRecordSchema>["status"];
+export type LoopLogEntry = z.infer<typeof LoopLogEntrySchema>;
+export type LoopVerifyCheckResult = z.infer<typeof LoopVerifyCheckResultSchema>;
+export type LoopVerifyPromptResult = z.infer<typeof LoopVerifyPromptResultSchema>;
+export type LoopIterationRecord = z.infer<typeof LoopIterationRecordSchema>;
+export type LoopRecord = z.infer<typeof LoopRecordSchema>;
+export interface LoopRunOptions {
+    prompt: string;
+    cwd: string;
+    provider?: AgentProvider;
+    model?: string;
+    modeId?: string;
+    workerProvider?: AgentProvider;
+    workerModel?: string;
+    verifierProvider?: AgentProvider;
+    verifierModel?: string;
+    verifierModeId?: string;
+    verifyPrompt?: string;
+    verifyChecks?: string[];
+    archive?: boolean;
+    name?: string;
+    sleepMs?: number;
+    maxIterations?: number;
+    maxTimeMs?: number;
+}
+export interface LoopListItem {
+    id: string;
+    name: string | null;
+    status: LoopStatus;
+    cwd: string;
+    createdAt: string;
+    updatedAt: string;
+    activeIteration: number | null;
+}
+export interface LoopLogsResult {
+    loop: LoopRecord;
+    entries: LoopLogEntry[];
+    nextCursor: number;
+}
+type LoopAgentManager = Pick<AgentManager, "archiveAgent" | "cancelAgentRun" | "closeAgent" | "runAgent" | "subscribe" | "waitForAgentEvent">;
+export declare class LoopService {
+    private readonly options;
+    private readonly storePath;
+    private readonly logger;
+    private loaded;
+    private readonly loops;
+    private persistQueue;
+    private readonly running;
+    constructor(options: {
+        ottoHome: string;
+        agentManager: LoopAgentManager;
+        logger: Logger;
+        createAgent: BoundCreateAgentCommand;
+        ensureWorkspaceForCreate: EnsureWorkspaceForCreate;
+    });
+    initialize(): Promise<void>;
+    runLoop(input: LoopRunOptions): Promise<LoopRecord>;
+    listLoops(): Promise<LoopListItem[]>;
+    inspectLoop(idOrPrefix: string): Promise<LoopRecord>;
+    getLoopLogs(idOrPrefix: string, afterSeq?: number): Promise<LoopLogsResult>;
+    stopLoop(idOrPrefix: string): Promise<LoopRecord>;
+    private executeLoop;
+    private handleExecuteLoopError;
+    private runWorkerIteration;
+    private runVerification;
+    private formatWorkerProviderModel;
+    private formatVerifierProviderModel;
+    private resolveFinalText;
+    private toPrompt;
+    private finishLoop;
+    private appendLog;
+    private requireLoop;
+    private persist;
+}
+export {};
+//# sourceMappingURL=loop-service.d.ts.map