@otto-code/server 0.5.0

package/dist/server/server/workspace-service-env.js

@@ -0,0 +1,85 @@
+import { projectServiceProxyUrls } from "./service-proxy.js";
+export function normalizeServiceEnvName(scriptName) {
+    return scriptName
+        .toUpperCase()
+        .replace(/[^A-Z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+}
+export function buildWorkspaceServiceEnv(options) {
+    const scriptNames = options.peers.map((peer) => peer.scriptName);
+    assertNoServiceEnvNameCollisions(scriptNames);
+    const selfPeer = options.peers.find((peer) => peer.scriptName === options.scriptName);
+    if (!selfPeer) {
+        throw new Error(`Service '${options.scriptName}' is missing from workspace service peers`);
+    }
+    const env = {
+        HOST: resolveServiceBindHost(options.daemonListenHost),
+        OTTO_PORT: String(selfPeer.port),
+    };
+    const selfProxyUrl = buildServiceProxyUrl({
+        projectSlug: options.projectSlug,
+        branchName: options.branchName,
+        scriptName: options.scriptName,
+        daemonPort: options.daemonPort,
+        serviceProxyPublicBaseUrl: options.serviceProxyPublicBaseUrl,
+    });
+    if (selfProxyUrl) {
+        env.OTTO_URL = selfProxyUrl;
+    }
+    for (const peer of options.peers) {
+        const envName = normalizeServiceEnvName(peer.scriptName);
+        env[`OTTO_SERVICE_${envName}_PORT`] = String(peer.port);
+        const peerProxyUrl = buildServiceProxyUrl({
+            projectSlug: options.projectSlug,
+            branchName: options.branchName,
+            scriptName: peer.scriptName,
+            daemonPort: options.daemonPort,
+            serviceProxyPublicBaseUrl: options.serviceProxyPublicBaseUrl,
+        });
+        if (peerProxyUrl) {
+            env[`OTTO_SERVICE_${envName}_URL`] = peerProxyUrl;
+        }
+    }
+    return env;
+}
+export function resolveServiceBindHost(daemonListenHost) {
+    return isLoopbackListenHost(daemonListenHost) ? "127.0.0.1" : "0.0.0.0";
+}
+function buildServiceProxyUrl(options) {
+    return projectServiceProxyUrls({
+        projectSlug: options.projectSlug,
+        branchName: options.branchName,
+        scriptName: options.scriptName,
+        daemonPort: options.daemonPort,
+        publicBaseUrl: options.serviceProxyPublicBaseUrl,
+    }).proxyUrl;
+}
+function isLoopbackListenHost(host) {
+    if (!host) {
+        return true;
+    }
+    const normalizedHost = host.trim().toLowerCase();
+    return (normalizedHost === "localhost" ||
+        normalizedHost === "127.0.0.1" ||
+        normalizedHost === "::1" ||
+        normalizedHost === "[::1]");
+}
+export function assertNoServiceEnvNameCollisions(scriptNames) {
+    const scriptNamesByEnvName = new Map();
+    for (const scriptName of scriptNames) {
+        const envName = normalizeServiceEnvName(scriptName);
+        const namesForEnvName = scriptNamesByEnvName.get(envName) ?? [];
+        namesForEnvName.push(scriptName);
+        scriptNamesByEnvName.set(envName, namesForEnvName);
+    }
+    const collisions = [];
+    for (const [envName, names] of scriptNamesByEnvName) {
+        if (names.length > 1) {
+            collisions.push(`Service env name collision for ${envName}: ${names.join(", ")}`);
+        }
+    }
+    if (collisions.length > 0) {
+        throw new Error(collisions.join("; "));
+    }
+}
+//# sourceMappingURL=workspace-service-env.js.map

package/dist/server/server/workspace-service-port-registry.d.ts

@@ -0,0 +1,19 @@
+interface WorkspaceServicePortDeclaration {
+    scriptName: string;
+    port?: number;
+}
+interface EnsureWorkspaceServicePortPlanOptions {
+    workspaceId: string;
+    services: readonly WorkspaceServicePortDeclaration[];
+    allocatePort: () => Promise<number>;
+}
+interface RefreshWorkspaceServicePortOptions {
+    workspaceId: string;
+    service: WorkspaceServicePortDeclaration;
+    allocatePort: () => Promise<number>;
+}
+export declare function ensureWorkspaceServicePortPlan(options: EnsureWorkspaceServicePortPlanOptions): Promise<ReadonlyMap<string, number>>;
+export declare function requirePlannedWorkspaceServicePort(plan: ReadonlyMap<string, number>, scriptName: string): number;
+export declare function refreshWorkspaceServicePort(options: RefreshWorkspaceServicePortOptions): Promise<number>;
+export {};
+//# sourceMappingURL=workspace-service-port-registry.d.ts.map

package/dist/server/server/workspace-service-port-registry.js

@@ -0,0 +1,59 @@
+const workspaceServicePortPlans = new Map();
+const pendingWorkspaceServicePortPlans = new Map();
+export async function ensureWorkspaceServicePortPlan(options) {
+    const existingPlan = workspaceServicePortPlans.get(options.workspaceId);
+    if (existingPlan) {
+        return new Map(existingPlan);
+    }
+    let pendingPlan = pendingWorkspaceServicePortPlans.get(options.workspaceId);
+    if (!pendingPlan) {
+        pendingPlan = createPendingWorkspaceServicePortPlan({
+            workspaceId: options.workspaceId,
+            services: options.services,
+            allocatePort: options.allocatePort,
+        });
+        pendingWorkspaceServicePortPlans.set(options.workspaceId, pendingPlan);
+    }
+    return new Map(await pendingPlan);
+}
+export function requirePlannedWorkspaceServicePort(plan, scriptName) {
+    const port = plan.get(scriptName);
+    if (port === undefined) {
+        throw new Error(`Service '${scriptName}' is missing from workspace service port plan`);
+    }
+    return port;
+}
+async function createPendingWorkspaceServicePortPlan(options) {
+    try {
+        const plan = await buildWorkspaceServicePortPlan({
+            services: options.services,
+            allocatePort: options.allocatePort,
+        });
+        workspaceServicePortPlans.set(options.workspaceId, plan);
+        return plan;
+    }
+    finally {
+        pendingWorkspaceServicePortPlans.delete(options.workspaceId);
+    }
+}
+async function buildWorkspaceServicePortPlan(options) {
+    const plan = new Map();
+    for (const service of options.services) {
+        plan.set(service.scriptName, await resolveServicePort(service, options.allocatePort));
+    }
+    return plan;
+}
+export async function refreshWorkspaceServicePort(options) {
+    const plan = workspaceServicePortPlans.get(options.workspaceId) ?? new Map();
+    const port = await resolveServicePort(options.service, options.allocatePort);
+    plan.set(options.service.scriptName, port);
+    workspaceServicePortPlans.set(options.workspaceId, plan);
+    return port;
+}
+async function resolveServicePort(service, allocatePort) {
+    if (service.port !== undefined) {
+        return service.port;
+    }
+    return await allocatePort();
+}
+//# sourceMappingURL=workspace-service-port-registry.js.map

package/dist/server/server/worktree/commands.d.ts

@@ -0,0 +1,55 @@
+import { type ArchiveDependencies, type ArchiveScope } from "../workspace-archive-service.js";
+import type { CreateOttoWorktreeInput, CreateOttoWorktreeResult } from "../otto-worktree-service.js";
+import { type WorktreeWireError } from "../worktree-errors.js";
+import type { WorkspaceGitService, WorkspaceGitWorktreeInfo } from "../workspace-git-service.js";
+export interface ListOttoWorktreesCommandDependencies {
+    workspaceGitService: Pick<WorkspaceGitService, "listWorktrees">;
+}
+export interface ListOttoWorktreesCommandInput {
+    cwd: string;
+    reason?: string;
+}
+export declare function listOttoWorktreesCommand(dependencies: ListOttoWorktreesCommandDependencies, input: ListOttoWorktreesCommandInput): Promise<WorkspaceGitWorktreeInfo[]>;
+type CreateOttoWorktreeWorkflow<Result extends CreateOttoWorktreeResult> = (input: CreateOttoWorktreeInput) => Promise<Result>;
+export interface CreateOttoWorktreeCommandDependencies<Result extends CreateOttoWorktreeResult = CreateOttoWorktreeResult> {
+    ottoHome?: string;
+    worktreesRoot?: string;
+    createOttoWorktreeWorkflow?: CreateOttoWorktreeWorkflow<Result>;
+}
+export type CreateOttoWorktreeCommandInput = Omit<CreateOttoWorktreeInput, "ottoHome" | "runSetup"> & {
+    ottoHome?: string;
+    worktreesRoot?: string;
+};
+export type CreateOttoWorktreeCommandResult<Result extends CreateOttoWorktreeResult> = {
+    ok: true;
+    createdWorktree: Result;
+} | {
+    ok: false;
+    error: WorktreeWireError;
+    cause: unknown;
+};
+export declare function createOttoWorktreeCommand<Result extends CreateOttoWorktreeResult>(dependencies: CreateOttoWorktreeCommandDependencies<Result>, input: CreateOttoWorktreeCommandInput): Promise<CreateOttoWorktreeCommandResult<Result>>;
+export interface ArchiveCommandDependencies extends Omit<ArchiveDependencies, "workspaceGitService"> {
+    workspaceGitService: Pick<WorkspaceGitService, "getSnapshot" | "listWorktrees">;
+}
+export interface ArchiveCommandInput {
+    requestId: string;
+    repoRoot?: string | null;
+    worktreePath?: string;
+    worktreeSlug?: string;
+    branchName?: string;
+    workspaceId?: string;
+    scope?: ArchiveScope["kind"];
+}
+export type ArchiveCommandResult = {
+    ok: true;
+    removedAgents: string[];
+} | {
+    ok: false;
+    code: "NOT_ALLOWED";
+    message: string;
+    removedAgents: [];
+};
+export declare function archiveCommand(dependencies: ArchiveCommandDependencies, input: ArchiveCommandInput): Promise<ArchiveCommandResult>;
+export {};
+//# sourceMappingURL=commands.d.ts.map

package/dist/server/server/worktree/commands.js

@@ -0,0 +1,107 @@
+import { join } from "node:path";
+import { getOttoWorktreesRoot, isOttoOwnedWorktreeCwd } from "../../utils/worktree.js";
+import { archiveByScope, resolveWorkspaceIdAtPath, } from "../workspace-archive-service.js";
+import { toWorktreeWireError } from "../worktree-errors.js";
+export async function listOttoWorktreesCommand(dependencies, input) {
+    if (input.reason) {
+        return dependencies.workspaceGitService.listWorktrees(input.cwd, { reason: input.reason });
+    }
+    return dependencies.workspaceGitService.listWorktrees(input.cwd);
+}
+export async function createOttoWorktreeCommand(dependencies, input) {
+    try {
+        if (!dependencies.createOttoWorktreeWorkflow) {
+            throw new Error("Otto worktree service is not configured");
+        }
+        const createdWorktree = await dependencies.createOttoWorktreeWorkflow({
+            ...input,
+            runSetup: false,
+            ottoHome: input.ottoHome ?? dependencies.ottoHome,
+            worktreesRoot: input.worktreesRoot ?? dependencies.worktreesRoot,
+        });
+        return { ok: true, createdWorktree };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: toWorktreeWireError(error),
+            cause: error,
+        };
+    }
+}
+export async function archiveCommand(dependencies, input) {
+    const resolvedTarget = await resolveArchiveTarget(dependencies, input);
+    const scope = input.scope ?? "workspace";
+    if (scope === "worktree") {
+        const ownership = await isOttoOwnedWorktreeCwd(resolvedTarget.targetPath, {
+            ottoHome: dependencies.ottoHome,
+            worktreesRoot: dependencies.ottoWorktreesBaseRoot,
+        });
+        if (!ownership.allowed) {
+            return {
+                ok: false,
+                code: "NOT_ALLOWED",
+                message: "Worktree is not a Otto-owned worktree",
+                removedAgents: [],
+            };
+        }
+        const result = await archiveByScope(dependencies, {
+            scope: { kind: "worktree", targetPath: resolvedTarget.targetPath },
+            repoRoot: ownership.repoRoot ?? resolvedTarget.repoRoot ?? null,
+            repoWorktreesRoot: ownership.worktreeRoot,
+            ottoWorktreesBaseRoot: dependencies.ottoWorktreesBaseRoot,
+            requestId: input.requestId,
+        });
+        return {
+            ok: true,
+            removedAgents: result.archivedAgentIds,
+        };
+    }
+    const workspaceId = input.workspaceId ?? (await resolveWorkspaceIdAtPath(dependencies, resolvedTarget.targetPath));
+    if (!workspaceId) {
+        dependencies.sessionLogger?.warn({ targetPath: resolvedTarget.targetPath }, "Could not resolve workspace for archive; skipping");
+        return {
+            ok: true,
+            removedAgents: [],
+        };
+    }
+    const result = await archiveByScope(dependencies, {
+        scope: { kind: "workspace", workspaceId },
+        repoRoot: resolvedTarget.repoRoot,
+        ottoWorktreesBaseRoot: dependencies.ottoWorktreesBaseRoot,
+        requestId: input.requestId,
+    });
+    return {
+        ok: true,
+        removedAgents: result.archivedAgentIds,
+    };
+}
+async function resolveArchiveTarget(dependencies, input) {
+    const repoRoot = input.repoRoot ?? null;
+    if (input.worktreePath) {
+        return { targetPath: input.worktreePath, repoRoot };
+    }
+    if (input.worktreeSlug) {
+        if (!repoRoot) {
+            throw new Error("repoRoot is required when worktreeSlug is supplied");
+        }
+        return {
+            targetPath: await resolveWorktreeSlugPath(dependencies, repoRoot, input.worktreeSlug),
+            repoRoot,
+        };
+    }
+    if (repoRoot && input.branchName) {
+        const worktrees = await dependencies.workspaceGitService.listWorktrees(repoRoot);
+        const match = worktrees.find((entry) => entry.branchName === input.branchName);
+        if (!match) {
+            throw new Error(`Otto worktree not found for branch ${input.branchName}`);
+        }
+        return { targetPath: match.path, repoRoot };
+    }
+    throw new Error("worktreePath, worktreeSlug, or repoRoot+branchName is required");
+}
+async function resolveWorktreeSlugPath(dependencies, repoRoot, worktreeSlug) {
+    const worktreesRoot = await getOttoWorktreesRoot(repoRoot, dependencies.ottoHome, dependencies.ottoWorktreesBaseRoot);
+    return join(worktreesRoot, worktreeSlug);
+}
+//# sourceMappingURL=commands.js.map

package/dist/server/server/worktree-bootstrap.d.ts

@@ -0,0 +1,76 @@
+import type { Logger } from "pino";
+import type { TerminalManager } from "../terminal/terminal-manager.js";
+import { runWorktreeSetupCommands, type WorktreeConfig, type WorktreeSetupCommandResult } from "../utils/worktree.js";
+import { type ServiceProxySubsystem } from "./service-proxy.js";
+import type { WorkspaceScriptRuntimeStore } from "./workspace-script-runtime-store.js";
+import type { AgentTimelineItem, ToolCallDetail } from "./agent/agent-sdk-types.js";
+export interface WorktreeBootstrapTerminalResult {
+    name: string | null;
+    command: string;
+    status: "started" | "failed";
+    terminalId: string | null;
+    error: string | null;
+}
+export interface RunAsyncWorktreeBootstrapOptions {
+    agentId: string;
+    workspaceId: string;
+    worktree: WorktreeConfig;
+    shouldBootstrap?: boolean;
+    terminalManager: TerminalManager | null;
+    appendTimelineItem: (item: AgentTimelineItem) => Promise<boolean>;
+    emitLiveTimelineItem?: (item: AgentTimelineItem) => Promise<boolean>;
+    logger?: Logger;
+}
+interface MiddleTruncationAccumulator {
+    totalBytes: number;
+    head: string;
+    tail: string;
+    truncated: boolean;
+}
+export type WorktreeSetupOutputAccumulator = MiddleTruncationAccumulator;
+export interface WorktreeSetupProgressAccumulator {
+    resultsByIndex: Map<number, WorktreeSetupCommandResult>;
+    outputAccumulatorsByIndex: Map<number, WorktreeSetupOutputAccumulator>;
+}
+export declare function createWorktreeSetupOutputAccumulator(): WorktreeSetupOutputAccumulator;
+export declare function appendWorktreeSetupOutputAccumulator(accumulator: WorktreeSetupOutputAccumulator, chunk: string): void;
+export declare function createWorktreeSetupProgressAccumulator(): WorktreeSetupProgressAccumulator;
+export declare function applyWorktreeSetupProgressEvent(accumulator: WorktreeSetupProgressAccumulator, event: Parameters<NonNullable<Parameters<typeof runWorktreeSetupCommands>[0]["onEvent"]>>[0]): void;
+export declare function getWorktreeSetupProgressResults(accumulator: WorktreeSetupProgressAccumulator): WorktreeSetupCommandResult[];
+export declare function buildWorktreeSetupDetail(input: {
+    worktree: WorktreeConfig;
+    results: WorktreeSetupCommandResult[];
+    outputAccumulatorsByIndex?: Map<number, WorktreeSetupOutputAccumulator>;
+}): Extract<ToolCallDetail, {
+    type: "worktree_setup";
+}>;
+export declare function runAsyncWorktreeBootstrap(options: RunAsyncWorktreeBootstrapOptions): Promise<void>;
+export interface WorktreeScriptResult {
+    scriptName: string;
+    hostname: string | null;
+    port: number | null;
+    terminalId: string;
+}
+export interface SpawnWorkspaceScriptOptions {
+    repoRoot: string;
+    workspaceId: string;
+    projectSlug: string;
+    branchName: string | null;
+    scriptName: string;
+    daemonPort?: number | null;
+    daemonListenHost?: string | null;
+    serviceProxyPublicBaseUrl?: string | null;
+    serviceProxy: ServiceProxySubsystem;
+    runtimeStore: WorkspaceScriptRuntimeStore;
+    terminalManager: TerminalManager;
+    logger?: Logger;
+    onLifecycleChanged?: () => void;
+}
+export declare function spawnWorkspaceScript(options: SpawnWorkspaceScriptOptions): Promise<WorktreeScriptResult>;
+export declare function teardownWorktreeScripts(options: {
+    hostnames: string[];
+    serviceProxy: Pick<ServiceProxySubsystem, "removeServiceRoutesByHostnames">;
+    logger: Logger;
+}): void;
+export {};
+//# sourceMappingURL=worktree-bootstrap.d.ts.map