@boboddy/sdk 0.0.7-alpha → 0.0.8-alpha

package/dist/packages/core/src/agent-sessions/project-runtime-session/application/stop-project-runtime-session.d.ts

@@ -0,0 +1,29 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { ProjectRepo } from "@boboddy/core/projects/project/application/project-repo";
+import type { AiContainerLauncher } from "./ai-container-launcher";
+import type { DevcontainerLauncher } from "./devcontainer-launcher";
+import type { ProjectRuntimeSessionRepo } from "./project-runtime-session-repo";
+import type { RuntimeSessionNetworkManager } from "./runtime-session-network-manager";
+import type { WorkspaceManager } from "./workspace-manager";
+import type { RuntimeOperationEventPublisher } from "../../runtime-operation-event/application/runtime-operation-event-publisher";
+import type { RuntimeServiceRepo } from "../../runtime-service/application/runtime-service-repo";
+import type { RuntimeSessionServiceExposureProvider } from "../../runtime-service/application/runtime-session-service-exposure-provider";
+import type { RuntimeServiceRunner } from "../../runtime-service/application/runtime-service-runner";
+import { type ProjectRuntimeSessionContract, type StopProjectRuntimeSessionInput } from "../contracts/project-runtime-session-contracts";
+export declare const stopProjectRuntimeSession: (input: StopProjectRuntimeSessionInput, { userId, projectRepo, projectRuntimeSessionRepo, devcontainerLauncher, aiContainerLauncher, runtimeSessionNetworkManager, runtimeSessionServiceExposureProvider, runtimeServiceRepo, runtimeServiceRunner, runtimeOperationEventPublisher, workspaceManager, timeProvider, dbExecutor, }: {
+    userId: UuidV7;
+    projectRepo: ProjectRepo;
+    projectRuntimeSessionRepo: ProjectRuntimeSessionRepo;
+    devcontainerLauncher: DevcontainerLauncher;
+    aiContainerLauncher: AiContainerLauncher;
+    runtimeSessionNetworkManager: RuntimeSessionNetworkManager;
+    runtimeSessionServiceExposureProvider: RuntimeSessionServiceExposureProvider;
+    runtimeServiceRepo: RuntimeServiceRepo;
+    runtimeServiceRunner: RuntimeServiceRunner;
+    runtimeOperationEventPublisher: RuntimeOperationEventPublisher;
+    workspaceManager: WorkspaceManager;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<ProjectRuntimeSessionContract>;

package/dist/packages/core/src/agent-sessions/project-runtime-session/application/workspace-manager.d.ts

@@ -0,0 +1,10 @@
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+export type ProvisionedWorkspace = {
+    workspacePath: string;
+};
+export type WorkspaceManager = {
+    createWorkspace(input: {
+        sessionId: UuidV7;
+    }): Promise<ProvisionedWorkspace>;
+    removeWorkspace(workspacePath: string): Promise<void>;
+};

package/dist/packages/core/src/agent-sessions/project-runtime-session/contracts/project-runtime-session-contracts.d.ts

@@ -0,0 +1,62 @@
+import { z } from "zod";
+export declare const projectRuntimeSessionStatusSchema: z.ZodEnum<{
+    queued: "queued";
+    running: "running";
+    failed: "failed";
+    cloning: "cloning";
+    validating_spec: "validating_spec";
+    launching: "launching";
+    stopped: "stopped";
+}>;
+export declare const projectRuntimeSessionSchema: z.ZodObject<{
+    id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    requestedByUserId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    gitUrl: z.ZodString;
+    requestedBranch: z.ZodNullable<z.ZodString>;
+    resolvedBranch: z.ZodNullable<z.ZodString>;
+    projectEnvironmentRef: z.ZodNullable<z.ZodString>;
+    agentEnvironmentRef: z.ZodNullable<z.ZodString>;
+    runnerAssignment: z.ZodNullable<z.ZodString>;
+    workspacePath: z.ZodNullable<z.ZodString>;
+    devcontainerId: z.ZodNullable<z.ZodString>;
+    aiContainerId: z.ZodNullable<z.ZodString>;
+    aiBaseUrl: z.ZodNullable<z.ZodString>;
+    aiImage: z.ZodNullable<z.ZodString>;
+    devcontainerConfigPath: z.ZodNullable<z.ZodString>;
+    projectEnvironmentReadyAt: z.ZodNullable<z.ZodISODateTime>;
+    agentEnvironmentReadyAt: z.ZodNullable<z.ZodISODateTime>;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        failed: "failed";
+        cloning: "cloning";
+        validating_spec: "validating_spec";
+        launching: "launching";
+        stopped: "stopped";
+    }>;
+    failureReason: z.ZodNullable<z.ZodString>;
+    metadata: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown>>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export declare const createProjectRuntimeSessionInputSchema: z.ZodObject<{
+    projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    requestedBranch: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const getProjectRuntimeSessionInputSchema: z.ZodObject<{
+    projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    runtimeSessionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+}, z.core.$strip>;
+export declare const listProjectRuntimeSessionsInputSchema: z.ZodObject<{
+    projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+}, z.core.$strip>;
+export declare const stopProjectRuntimeSessionInputSchema: z.ZodObject<{
+    projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    runtimeSessionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+}, z.core.$strip>;
+export type ProjectRuntimeSessionContract = z.infer<typeof projectRuntimeSessionSchema>;
+export type CreateProjectRuntimeSessionInput = z.input<typeof createProjectRuntimeSessionInputSchema>;
+export type GetProjectRuntimeSessionInput = z.input<typeof getProjectRuntimeSessionInputSchema>;
+export type ListProjectRuntimeSessionsInput = z.input<typeof listProjectRuntimeSessionsInputSchema>;
+export type StopProjectRuntimeSessionInput = z.input<typeof stopProjectRuntimeSessionInputSchema>;

package/dist/packages/core/src/agent-sessions/project-runtime-session/domain/project-runtime-session-entity-helpers.d.ts

@@ -0,0 +1,12 @@
+import type { RuntimeEnvironmentRef, RuntimeRunnerAssignment } from "@boboddy/core/agent-sessions/runtime-environment/domain/runtime-environment";
+import type { ProjectRuntimeSessionStatus } from "./project-runtime-session-entity";
+type RunningProjectRuntimeSessionProps = {
+    resolvedBranch: string | null;
+    runnerAssignment: RuntimeRunnerAssignment | null;
+    projectEnvironmentRef: RuntimeEnvironmentRef | null;
+    agentEnvironmentRef: RuntimeEnvironmentRef | null;
+    projectEnvironmentReadyAt: Date | null | undefined;
+    agentEnvironmentReadyAt: Date | null | undefined;
+};
+export declare function assertRunningSessionProps(status: ProjectRuntimeSessionStatus, props: RunningProjectRuntimeSessionProps): void;
+export {};

package/dist/packages/core/src/agent-sessions/project-runtime-session/domain/project-runtime-session-entity.d.ts

@@ -0,0 +1,99 @@
+import { type UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { AnyJsonObject } from "@boboddy/core/common/contracts/json";
+import { type RuntimeEnvironmentRef, type RuntimeRunnerAssignment } from "@boboddy/core/agent-sessions/runtime-environment/domain/runtime-environment";
+import { type ProjectRuntimeSessionExecutionEnvironment, type ProjectRuntimeSessionExecutionTarget } from "./project-runtime-session-execution-target";
+export declare const PROJECT_RUNTIME_SESSION_STATUSES: readonly ["queued", "cloning", "validating_spec", "launching", "running", "failed", "stopped"];
+export type ProjectRuntimeSessionStatus = (typeof PROJECT_RUNTIME_SESSION_STATUSES)[number];
+export type ProjectRuntimeSessionProps = {
+    id: UuidV7;
+    projectId: UuidV7;
+    requestedByUserId: UuidV7;
+    gitUrl: string;
+    requestedBranch?: string | null | undefined;
+    resolvedBranch?: string | null | undefined;
+    projectEnvironmentRef?: string | null | undefined;
+    agentEnvironmentRef?: string | null | undefined;
+    runnerAssignment?: string | null | undefined;
+    workspacePath?: string | null | undefined;
+    devcontainerId?: string | null | undefined;
+    aiContainerId?: string | null | undefined;
+    aiBaseUrl?: string | null | undefined;
+    aiImage?: string | null | undefined;
+    devcontainerConfigPath?: string | null | undefined;
+    projectEnvironmentReadyAt?: Date | string | null | undefined;
+    agentEnvironmentReadyAt?: Date | string | null | undefined;
+    status: ProjectRuntimeSessionStatus;
+    failureReason?: string | null | undefined;
+    metadata?: AnyJsonObject | null | undefined;
+    createdAt?: Date | string | null | undefined;
+    updatedAt?: Date | string | null | undefined;
+};
+export type CreateProjectRuntimeSessionProps = Omit<ProjectRuntimeSessionProps, "id"> & {
+    id?: UuidV7;
+};
+export declare class ProjectRuntimeSessionEntity {
+    readonly id: UuidV7;
+    readonly projectId: UuidV7;
+    readonly requestedByUserId: UuidV7;
+    readonly gitUrl: string;
+    readonly requestedBranch: string | null;
+    readonly resolvedBranch: string | null;
+    readonly projectEnvironmentRef: RuntimeEnvironmentRef | null;
+    readonly agentEnvironmentRef: RuntimeEnvironmentRef | null;
+    readonly runnerAssignment: RuntimeRunnerAssignment | null;
+    readonly workspacePath: string | null;
+    readonly devcontainerId: string | null;
+    readonly aiContainerId: string | null;
+    readonly aiBaseUrl: string | null;
+    readonly aiImage: string | null;
+    readonly devcontainerConfigPath: string | null;
+    readonly projectEnvironmentReadyAt: Date | null | undefined;
+    readonly agentEnvironmentReadyAt: Date | null | undefined;
+    readonly status: ProjectRuntimeSessionStatus;
+    readonly failureReason: string | null;
+    readonly metadata: AnyJsonObject;
+    readonly createdAt: Date | null | undefined;
+    readonly updatedAt: Date | null | undefined;
+    private constructor();
+    get isActive(): boolean;
+    static createQueued(props: Omit<CreateProjectRuntimeSessionProps, "status" | "resolvedBranch" | "projectEnvironmentRef" | "agentEnvironmentRef" | "runnerAssignment" | "workspacePath" | "devcontainerId" | "aiContainerId" | "aiBaseUrl" | "aiImage" | "devcontainerConfigPath" | "projectEnvironmentReadyAt" | "agentEnvironmentReadyAt" | "failureReason" | "metadata">): ProjectRuntimeSessionEntity;
+    static rehydrate(props: ProjectRuntimeSessionProps): ProjectRuntimeSessionEntity;
+    markCloning(updatedAt: Date): ProjectRuntimeSessionEntity;
+    markValidatingSpec(input: {
+        updatedAt: Date;
+        workspacePath: string;
+        resolvedBranch: string;
+    }): ProjectRuntimeSessionEntity;
+    markLaunching(input: {
+        updatedAt: Date;
+        workspacePath: string;
+        resolvedBranch: string;
+        devcontainerConfigPath: string;
+    }): ProjectRuntimeSessionEntity;
+    markRunning(input: {
+        updatedAt: Date;
+        workspacePath?: string | null | undefined;
+        resolvedBranch: string;
+        projectEnvironmentRef?: string | null | undefined;
+        agentEnvironmentRef?: string | null | undefined;
+        runnerAssignment?: string | null | undefined;
+        devcontainerConfigPath?: string | null | undefined;
+        devcontainerId?: string | null | undefined;
+        aiContainerId?: string | null | undefined;
+        aiBaseUrl?: string | null | undefined;
+        aiImage?: string | null | undefined;
+        projectEnvironmentReadyAt?: Date | null | undefined;
+        agentEnvironmentReadyAt?: Date | null | undefined;
+        metadata?: AnyJsonObject | undefined;
+    }): ProjectRuntimeSessionEntity;
+    markFailed(input: {
+        updatedAt: Date;
+        reason: string;
+        metadata?: AnyJsonObject | undefined;
+    }): ProjectRuntimeSessionEntity;
+    stop(updatedAt: Date): ProjectRuntimeSessionEntity;
+    toJSON(): ProjectRuntimeSessionProps;
+    getExecutionTarget(environmentRole: ProjectRuntimeSessionExecutionEnvironment): ProjectRuntimeSessionExecutionTarget;
+    private assertMutable;
+    private copy;
+}

package/dist/packages/core/src/agent-sessions/project-runtime-session/domain/project-runtime-session-execution-target.d.ts

@@ -0,0 +1,16 @@
+import type { AnyJsonObject } from "@boboddy/core/common/contracts/json";
+import { type RuntimeEnvironmentRef, type RuntimeEnvironmentRole, type RuntimeRunnerAssignment } from "@boboddy/core/agent-sessions/runtime-environment/domain/runtime-environment";
+export declare const PROJECT_RUNTIME_SESSION_EXECUTION_ENVIRONMENTS: readonly ["project", "agent"];
+export type ProjectRuntimeSessionExecutionEnvironment = RuntimeEnvironmentRole;
+export type ProjectRuntimeSessionExecutionTarget = {
+    environmentRole: ProjectRuntimeSessionExecutionEnvironment;
+    runnerAssignment: RuntimeRunnerAssignment;
+    environmentRef: RuntimeEnvironmentRef;
+    metadata: AnyJsonObject;
+};
+export declare const createProjectRuntimeSessionExecutionTarget: (input: {
+    environmentRole: ProjectRuntimeSessionExecutionEnvironment;
+    runnerAssignment: RuntimeRunnerAssignment | string;
+    environmentRef: RuntimeEnvironmentRef | string;
+    metadata?: AnyJsonObject | null | undefined;
+}) => ProjectRuntimeSessionExecutionTarget;

package/dist/packages/core/src/agent-sessions/project-runtime-session/infra/devcontainer-cli-launcher.d.ts

@@ -0,0 +1,6 @@
+import type { DevcontainerLauncher, LaunchDevcontainerInput, LaunchDevcontainerResult, ResolveDevcontainerConfigInput } from "../application/devcontainer-launcher";
+export declare class DevcontainerCliLauncher implements DevcontainerLauncher {
+    resolveConfigPath(input: ResolveDevcontainerConfigInput): Promise<string>;
+    launch(input: LaunchDevcontainerInput): Promise<LaunchDevcontainerResult>;
+    stop(containerId: string): Promise<void>;
+}

package/dist/packages/core/src/agent-sessions/project-runtime-session/infra/docker-ai-container-launcher.d.ts

@@ -0,0 +1,8 @@
+import type { AiContainerLauncher, LaunchAiContainerInput, LaunchAiContainerResult } from "../application/ai-container-launcher";
+export declare function getSessionOpencodeLogDirectory(workspacePath: string): string;
+export declare function getSessionHomePath(workspacePath: string): string;
+export declare function ensureBoboddyRuntimeWorkspaceRoot(workspacePath: string): Promise<void>;
+export declare class DockerAiContainerLauncher implements AiContainerLauncher {
+    launch(input: LaunchAiContainerInput): Promise<LaunchAiContainerResult>;
+    stop(containerId: string): Promise<void>;
+}

package/dist/packages/core/src/agent-sessions/project-runtime-session/infra/drizzle-project-runtime-session-repo.d.ts

@@ -0,0 +1,11 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { ProjectRuntimeSessionRepo } from "../application/project-runtime-session-repo";
+import { ProjectRuntimeSessionEntity } from "../domain/project-runtime-session-entity";
+export declare class DrizzleProjectRuntimeSessionRepo implements ProjectRuntimeSessionRepo {
+    load(id: UuidV7, dbExecutor?: DbExecutor): Promise<ProjectRuntimeSessionEntity | null>;
+    listByProjectId(projectId: UuidV7, dbExecutor?: DbExecutor): Promise<ProjectRuntimeSessionEntity[]>;
+    loadQueued(limit: number, dbExecutor?: DbExecutor): Promise<ProjectRuntimeSessionEntity[]>;
+    create(session: ProjectRuntimeSessionEntity, dbExecutor?: DbExecutor): Promise<ProjectRuntimeSessionEntity>;
+    save(session: ProjectRuntimeSessionEntity, dbExecutor?: DbExecutor): Promise<ProjectRuntimeSessionEntity>;
+}

package/dist/packages/core/src/agent-sessions/project-runtime-session/infra/git-cli-clone-service.d.ts

@@ -0,0 +1,4 @@
+import type { CloneRepositoryInput, CloneRepositoryResult, GitCloneService } from "../application/git-clone-service";
+export declare class GitCliCloneService implements GitCloneService {
+    cloneRepository(input: CloneRepositoryInput): Promise<CloneRepositoryResult>;
+}

package/dist/packages/core/src/agent-sessions/project-runtime-session/infra/local-devcontainer-jsonc.d.ts

@@ -0,0 +1,4 @@
+import type { AnyJsonValue } from "@boboddy/core/common/contracts/json";
+export declare const parseDevcontainerConfigContent: (content: string) => AnyJsonValue;
+export declare const parseDevcontainerForwardPortsFromContent: (content: string) => number[];
+export declare const parseDevcontainerWorkspaceFolderFromContent: (content: string, workspacePath: string) => string | null;

package/dist/packages/core/src/agent-sessions/project-runtime-session/infra/local-devcontainer-port-forward-manager-support.d.ts

@@ -0,0 +1,42 @@
+import type { AnyJsonValue } from "@boboddy/core/common/contracts/json";
+import type { ProjectRuntimeSessionExecutionTarget } from "../domain/project-runtime-session-execution-target";
+export declare const PROXY_DIRECTORY_PATH = "/tmp/boboddy-runtime-proxy";
+export declare const PROXY_BINARY_PATH = "/tmp/boboddy-runtime-proxy/boboddy-runtime-proxy";
+export declare const PROXY_CONFIG_PATH = "/tmp/boboddy-runtime-proxy/config.json";
+export declare const PROXY_LOG_PATH = "/tmp/boboddy-runtime-proxy/proxy.log";
+export declare const PROXY_PID_PATH = "/tmp/boboddy-runtime-proxy/proxy.pid";
+export declare const PROXY_BOOT_WAIT_MS = 500;
+export declare const AGENT_PROXY_DIRECTORY_PATH = "/tmp/boboddy-agent-proxy";
+export declare const AGENT_PROXY_BINARY_PATH = "/tmp/boboddy-agent-proxy/boboddy-agent-proxy";
+export declare const AGENT_PROXY_CONFIG_PATH = "/tmp/boboddy-agent-proxy/config.json";
+export declare const AGENT_PROXY_LOG_PATH = "/tmp/boboddy-agent-proxy/proxy.log";
+export declare const AGENT_PROXY_PID_PATH = "/tmp/boboddy-agent-proxy/proxy.pid";
+export declare const PROXY_PORT_SEARCH_START = 39000;
+export declare const PROXY_PORT_SEARCH_END = 65535;
+export type RuntimeProxyBinaryArchitecture = "x64" | "arm64";
+export type RuntimeProxyMapping = {
+    listenPort: number;
+    targetHost: string;
+    targetPort: number;
+    protocol: "tcp";
+};
+export type RuntimeProxyConfig = {
+    mappings: readonly RuntimeProxyMapping[];
+};
+export declare const readRuntimeProxyMappings: (value: object | null | undefined) => RuntimeProxyMapping[];
+export declare const parseRuntimeProxyMappingsContent: (content: string) => RuntimeProxyMapping[];
+export declare const resolveRepoRootFromModuleUrl: (moduleUrl: string) => string;
+export declare const readLocalExecutionMetadata: (executionTarget: ProjectRuntimeSessionExecutionTarget) => {
+    containerId: string;
+    workspacePath: string | null;
+    devcontainerConfigPath: string | null;
+    agentContainerId: string | null;
+};
+export declare const toRuntimeProxyBinaryArchitecture: (architecture: string) => RuntimeProxyBinaryArchitecture;
+export declare const normalizeForwardPortValue: (value: number | string | undefined) => number | null;
+export declare const delay: (milliseconds: number) => Promise<void>;
+export declare const parseDevcontainerForwardPorts: (value: AnyJsonValue) => number[];
+export declare const resolveRuntimeProxyMappings: ({ existingMappings, targetPorts, }: {
+    existingMappings: readonly RuntimeProxyMapping[];
+    targetPorts: readonly number[];
+}) => RuntimeProxyMapping[];

package/dist/packages/core/src/agent-sessions/project-runtime-session/infra/local-devcontainer-port-forward-manager.d.ts

@@ -0,0 +1,24 @@
+import type { EnsureDefaultRuntimeServiceAccessPointsInput, EnsureRuntimeServiceAccessPointInput, RuntimeSessionServiceExposureProvider } from "@boboddy/core/agent-sessions/runtime-service/application/runtime-session-service-exposure-provider";
+import { type RuntimeServiceAccessPoint } from "@boboddy/core/agent-sessions/runtime-service/domain/runtime-service-access-point";
+import type { ProjectRuntimeSessionExecutionTarget } from "../domain/project-runtime-session-execution-target";
+export declare class LocalDevcontainerPortForwardManager implements RuntimeSessionServiceExposureProvider {
+    private readonly repoRoot;
+    ensureDefaultAccessPoints(input: EnsureDefaultRuntimeServiceAccessPointsInput): Promise<(RuntimeServiceAccessPoint & {
+        targetPort: number;
+    })[]>;
+    ensureAccessPoint(input: EnsureRuntimeServiceAccessPointInput): Promise<RuntimeServiceAccessPoint & {
+        targetPort: number;
+    }>;
+    stop(executionTarget: ProjectRuntimeSessionExecutionTarget): Promise<void>;
+    private ensureProxy;
+    private ensureAgentProxy;
+    private resolveMappings;
+    private readExistingMappings;
+    private readProxyStartupLog;
+    private copyConfigIntoContainer;
+    private copyAgentConfigIntoContainer;
+    private ensureLocalBinary;
+    private ensureRuntimeProxyBuilt;
+    private readContainerArchitecture;
+    private readForwardPorts;
+}

package/dist/packages/core/src/agent-sessions/project-runtime-session/infra/local-devcontainer-working-directory.d.ts

@@ -0,0 +1,5 @@
+export declare const resolveDevcontainerWorkingDirectory: (input: {
+    workspacePath: string;
+    devcontainerConfigPath: string;
+    cwd: string | null;
+}) => Promise<string | null>;

package/dist/packages/core/src/agent-sessions/project-runtime-session/infra/local-docker-runtime-session-network-manager.d.ts

@@ -0,0 +1,17 @@
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { AttachRuntimeSessionContainerInput, CreateRuntimeSessionNetworkResult, RuntimeSessionNetworkManager } from "../application/runtime-session-network-manager";
+export declare const RUNTIME_SESSION_NETWORK_NAME_PREFIX = "boboddy-project-runtime-session";
+export declare class LocalDockerRuntimeSessionNetworkManager implements RuntimeSessionNetworkManager {
+    private readonly deps;
+    constructor(deps?: {
+        execFileAsync(file: string, args: string[]): Promise<{
+            stdout: string;
+            stderr: string;
+        }>;
+    });
+    private inspectNetwork;
+    private recreateEmptyExistingNetwork;
+    createNetwork(sessionId: UuidV7): Promise<CreateRuntimeSessionNetworkResult>;
+    attachContainer({ networkName, containerId, alias, }: AttachRuntimeSessionContainerInput): Promise<void>;
+    removeNetwork(networkName: string): Promise<void>;
+}

package/dist/packages/core/src/agent-sessions/project-runtime-session/infra/local-workspace-manager.d.ts

@@ -0,0 +1,11 @@
+import type { WorkspaceManager } from "../application/workspace-manager";
+export declare class LocalWorkspaceManager implements WorkspaceManager {
+    private readonly rootDir;
+    constructor(rootDir?: string);
+    createWorkspace(input: {
+        sessionId: string;
+    }): Promise<{
+        workspacePath: string;
+    }>;
+    removeWorkspace(workspacePath: string): Promise<void>;
+}

package/dist/packages/core/src/agent-sessions/runtime-command/application/complete-claimed-runtime-command.d.ts

@@ -0,0 +1,11 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import { type Logger } from "@boboddy/core/lib/logger";
+import { type CompleteClaimedRuntimeCommandInput, type GetRuntimeCommandInput, type RuntimeCommandContract } from "../contracts/runtime-command-contracts";
+import type { RuntimeCommandRepo } from "./runtime-command-repo";
+export declare const completeClaimedRuntimeCommand: (runtimeCommandIdInput: GetRuntimeCommandInput, input: CompleteClaimedRuntimeCommandInput, { runtimeCommandRepo, timeProvider, dbExecutor, logger, }: {
+    runtimeCommandRepo: RuntimeCommandRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+    logger?: Logger | undefined;
+}) => Promise<RuntimeCommandContract>;

package/dist/packages/core/src/agent-sessions/runtime-command/application/create-runtime-command.d.ts

@@ -0,0 +1,17 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import { type Logger } from "@boboddy/core/lib/logger";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { ProjectRepo } from "@boboddy/core/projects/project/application/project-repo";
+import type { ProjectRuntimeSessionRepo } from "@boboddy/core/agent-sessions/project-runtime-session/application/project-runtime-session-repo";
+import type { RuntimeCommandRepo } from "./runtime-command-repo";
+import { type CreateRuntimeCommandInput, type RuntimeCommandContract } from "../contracts/runtime-command-contracts";
+export declare const createRuntimeCommand: (input: CreateRuntimeCommandInput, { userId, projectRepo, projectRuntimeSessionRepo, runtimeCommandRepo, timeProvider, dbExecutor, logger, }: {
+    userId: UuidV7;
+    projectRepo: ProjectRepo;
+    projectRuntimeSessionRepo: ProjectRuntimeSessionRepo;
+    runtimeCommandRepo: RuntimeCommandRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+    logger?: Logger | undefined;
+}) => Promise<RuntimeCommandContract>;

package/dist/packages/core/src/agent-sessions/runtime-command/application/fail-claimed-runtime-command.d.ts

@@ -0,0 +1,11 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import { type Logger } from "@boboddy/core/lib/logger";
+import { type FailClaimedRuntimeCommandInput, type GetRuntimeCommandInput, type RuntimeCommandContract } from "../contracts/runtime-command-contracts";
+import type { RuntimeCommandRepo } from "./runtime-command-repo";
+export declare const failClaimedRuntimeCommand: (runtimeCommandIdInput: GetRuntimeCommandInput, input: FailClaimedRuntimeCommandInput, { runtimeCommandRepo, timeProvider, dbExecutor, logger, }: {
+    runtimeCommandRepo: RuntimeCommandRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+    logger?: Logger | undefined;
+}) => Promise<RuntimeCommandContract>;

package/dist/packages/core/src/agent-sessions/runtime-command/application/interrupt-claimed-runtime-command.d.ts

@@ -0,0 +1,11 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import { type Logger } from "@boboddy/core/lib/logger";
+import { type GetRuntimeCommandInput, type InterruptClaimedRuntimeCommandInput, type RuntimeCommandContract } from "../contracts/runtime-command-contracts";
+import type { RuntimeCommandRepo } from "./runtime-command-repo";
+export declare const interruptClaimedRuntimeCommand: (runtimeCommandIdInput: GetRuntimeCommandInput, input: InterruptClaimedRuntimeCommandInput, { runtimeCommandRepo, timeProvider, dbExecutor, logger, }: {
+    runtimeCommandRepo: RuntimeCommandRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+    logger?: Logger | undefined;
+}) => Promise<RuntimeCommandContract>;

package/dist/packages/core/src/agent-sessions/runtime-command/application/run-runtime-command-locally.d.ts

@@ -0,0 +1,26 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import { type Logger } from "@boboddy/core/lib/logger";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { AuthorizationService } from "@boboddy/core/access/authorization/application/authorization-service";
+import type { ProjectRuntimeSessionRepo } from "@boboddy/core/agent-sessions/project-runtime-session/application/project-runtime-session-repo";
+import type { RuntimeCommandRepo } from "./runtime-command-repo";
+import type { RuntimeCommandRunner } from "./runtime-command-runner";
+import type { RuntimeOperationEventPublisher } from "../../runtime-operation-event/application/runtime-operation-event-publisher";
+import type { RuntimeCommandContract } from "../contracts/runtime-command-contracts";
+type RunRuntimeCommandLocallyDeps = {
+    userId: UuidV7;
+    projectId: UuidV7;
+    projectRuntimeSessionId: UuidV7;
+    authz: AuthorizationService;
+    workerId: string;
+    runtimeCommandRepo: RuntimeCommandRepo;
+    projectRuntimeSessionRepo: ProjectRuntimeSessionRepo;
+    runtimeCommandRunner: RuntimeCommandRunner;
+    runtimeOperationEventPublisher: RuntimeOperationEventPublisher;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+    logger?: Logger | undefined;
+};
+export declare const runRuntimeCommandLocally: (runtimeCommandId: UuidV7, deps: RunRuntimeCommandLocallyDeps) => Promise<RuntimeCommandContract>;
+export {};

package/dist/packages/core/src/agent-sessions/runtime-command/application/runtime-command-claim-helpers.d.ts

@@ -0,0 +1 @@
+export declare const buildLeaseExpiresAt: (now: Date, leaseDurationSeconds: number) => Date;

package/dist/packages/core/src/agent-sessions/runtime-command/application/runtime-command-contract-mapper.d.ts

@@ -0,0 +1,3 @@
+import { type RuntimeCommandContract } from "../contracts/runtime-command-contracts";
+import type { RuntimeCommandEntity } from "../domain/runtime-command-entity";
+export declare const runtimeCommandEntityToContract: (runtimeCommand: RuntimeCommandEntity) => RuntimeCommandContract;

package/dist/packages/core/src/agent-sessions/runtime-command/application/runtime-command-output-summary.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeCommandExecutionOutputTransport } from "./runtime-command-runner";
+import type { RuntimeCommandExecutionResult } from "../domain/runtime-command-entity";
+export declare const RUNTIME_COMMAND_OUTPUT_PREVIEW_LIMIT = 4000;
+export declare const summarizeRuntimeCommandOutput: (output: RuntimeCommandExecutionOutputTransport) => RuntimeCommandExecutionResult["output"];

package/dist/packages/core/src/agent-sessions/runtime-command/application/runtime-command-repo.d.ts

@@ -0,0 +1,20 @@
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { RuntimeCommandEntity, RuntimeCommandEnvironmentRole } from "../domain/runtime-command-entity";
+export type RuntimeCommandRepo = {
+    load(id: UuidV7, dbExecutor?: DbExecutor): Promise<RuntimeCommandEntity | null>;
+    listByProjectRuntimeSessionId(projectRuntimeSessionId: UuidV7, dbExecutor?: DbExecutor): Promise<RuntimeCommandEntity[]>;
+    loadClaimableByProjectRuntimeSessionId(projectRuntimeSessionId: UuidV7, environmentRole: RuntimeCommandEnvironmentRole, limit: number, now: Date, dbExecutor?: DbExecutor): Promise<RuntimeCommandEntity[]>;
+    create(runtimeCommand: RuntimeCommandEntity, dbExecutor?: DbExecutor): Promise<RuntimeCommandEntity>;
+    claim(runtimeCommandId: UuidV7, claim: {
+        workerId: string;
+        claimToken: string;
+        claimedAt: Date;
+        leaseExpiresAt: Date;
+    }, dbExecutor?: DbExecutor): Promise<RuntimeCommandEntity | null>;
+    heartbeat(runtimeCommandId: UuidV7, claimToken: string, heartbeat: {
+        lastHeartbeatAt: Date;
+        leaseExpiresAt: Date;
+    }, dbExecutor?: DbExecutor): Promise<RuntimeCommandEntity | null>;
+    save(runtimeCommand: RuntimeCommandEntity, dbExecutor?: DbExecutor): Promise<RuntimeCommandEntity>;
+};

package/dist/packages/core/src/agent-sessions/runtime-command/application/runtime-command-runner.d.ts

@@ -0,0 +1,25 @@
+import type { AnyJsonObject } from "@boboddy/core/common/contracts/json";
+import type { ProjectRuntimeSessionExecutionTarget } from "@boboddy/core/agent-sessions/project-runtime-session/domain/project-runtime-session-execution-target";
+export type RuntimeCommandExecutionOutputTransport = {
+    stdout: string;
+    stderr: string;
+    logRef?: string | null | undefined;
+};
+export type RuntimeCommandExecutionOutcome = {
+    exitCode: number | null;
+    signal: string | null;
+    output: RuntimeCommandExecutionOutputTransport;
+    metadata?: AnyJsonObject | undefined;
+};
+export type RuntimeCommandRunner = {
+    executeOneShot(input: {
+        command: string;
+        executionTarget: ProjectRuntimeSessionExecutionTarget;
+        metadata?: AnyJsonObject | undefined;
+        onOutput?: ((output: {
+            stream: "stdout" | "stderr";
+            chunk: string;
+        }) => Promise<void> | void) | undefined;
+        signal?: AbortSignal | undefined;
+    }): Promise<RuntimeCommandExecutionOutcome>;
+};