@boboddy/sdk 0.0.7-alpha → 0.0.8-alpha

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

@@ -0,0 +1,194 @@
+import { z } from "zod";
+export declare const runtimeCommandEnvironmentRoleSchema: z.ZodEnum<{
+    project: "project";
+    agent: "agent";
+}>;
+export declare const runtimeCommandStatusSchema: z.ZodEnum<{
+    queued: "queued";
+    running: "running";
+    succeeded: "succeeded";
+    failed: "failed";
+    cancelled: "cancelled";
+    claimed: "claimed";
+    interrupted: "interrupted";
+}>;
+export declare const runtimeCommandExecutionResultSchema: z.ZodObject<{
+    exitCode: z.ZodNullable<z.ZodNumber>;
+    signal: z.ZodNullable<z.ZodString>;
+    output: z.ZodObject<{
+        stdoutPreview: z.ZodString;
+        stderrPreview: z.ZodString;
+        stdoutBytes: z.ZodNumber;
+        stderrBytes: z.ZodNumber;
+        logRef: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const runtimeCommandSchema: 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>>;
+    projectRuntimeSessionId: 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>>;
+    environmentRole: z.ZodEnum<{
+        project: "project";
+        agent: "agent";
+    }>;
+    command: z.ZodString;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        cancelled: "cancelled";
+        claimed: "claimed";
+        interrupted: "interrupted";
+    }>;
+    claimedBy: z.ZodNullable<z.ZodString>;
+    claimedAt: z.ZodNullable<z.ZodISODateTime>;
+    lastHeartbeatAt: z.ZodNullable<z.ZodISODateTime>;
+    leaseExpiresAt: z.ZodNullable<z.ZodISODateTime>;
+    startedAt: z.ZodNullable<z.ZodISODateTime>;
+    completedAt: z.ZodNullable<z.ZodISODateTime>;
+    result: z.ZodNullable<z.ZodObject<{
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        signal: z.ZodNullable<z.ZodString>;
+        output: z.ZodObject<{
+            stdoutPreview: z.ZodString;
+            stderrPreview: z.ZodString;
+            stdoutBytes: z.ZodNumber;
+            stderrBytes: z.ZodNumber;
+            logRef: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    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 runtimeCommandClaimSchema: z.ZodObject<{
+    runtimeCommand: 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>>;
+        projectRuntimeSessionId: 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>>;
+        environmentRole: z.ZodEnum<{
+            project: "project";
+            agent: "agent";
+        }>;
+        command: z.ZodString;
+        status: z.ZodEnum<{
+            queued: "queued";
+            running: "running";
+            succeeded: "succeeded";
+            failed: "failed";
+            cancelled: "cancelled";
+            claimed: "claimed";
+            interrupted: "interrupted";
+        }>;
+        claimedBy: z.ZodNullable<z.ZodString>;
+        claimedAt: z.ZodNullable<z.ZodISODateTime>;
+        lastHeartbeatAt: z.ZodNullable<z.ZodISODateTime>;
+        leaseExpiresAt: z.ZodNullable<z.ZodISODateTime>;
+        startedAt: z.ZodNullable<z.ZodISODateTime>;
+        completedAt: z.ZodNullable<z.ZodISODateTime>;
+        result: z.ZodNullable<z.ZodObject<{
+            exitCode: z.ZodNullable<z.ZodNumber>;
+            signal: z.ZodNullable<z.ZodString>;
+            output: z.ZodObject<{
+                stdoutPreview: z.ZodString;
+                stderrPreview: z.ZodString;
+                stdoutBytes: z.ZodNumber;
+                stderrBytes: z.ZodNumber;
+                logRef: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        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>;
+    claimToken: z.ZodString;
+}, z.core.$strip>;
+export declare const createRuntimeCommandInputSchema: 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>>;
+    projectRuntimeSessionId: 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>>;
+    environmentRole: z.ZodDefault<z.ZodEnum<{
+        project: "project";
+        agent: "agent";
+    }>>;
+    command: z.ZodString;
+    metadata: z.ZodOptional<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown>>>;
+}, z.core.$strip>;
+export declare const claimRuntimeCommandsInputSchema: z.ZodObject<{
+    projectRuntimeSessionId: 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>>;
+    workerId: z.ZodString;
+    environmentRole: z.ZodDefault<z.ZodEnum<{
+        project: "project";
+        agent: "agent";
+    }>>;
+    batchSize: z.ZodDefault<z.ZodNumber>;
+    leaseDurationSeconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const runtimeCommandClaimCommandInputSchema: z.ZodObject<{
+    claimToken: z.ZodString;
+    leaseDurationSeconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const completeClaimedRuntimeCommandInputSchema: z.ZodObject<{
+    claimToken: z.ZodString;
+    result: z.ZodObject<{
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        signal: z.ZodNullable<z.ZodString>;
+        output: z.ZodObject<{
+            stdoutPreview: z.ZodString;
+            stderrPreview: z.ZodString;
+            stdoutBytes: z.ZodNumber;
+            stderrBytes: z.ZodNumber;
+            logRef: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    metadata: z.ZodOptional<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown>>>;
+}, z.core.$strip>;
+export declare const failClaimedRuntimeCommandInputSchema: z.ZodObject<{
+    claimToken: z.ZodString;
+    reason: z.ZodString;
+    result: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        signal: z.ZodNullable<z.ZodString>;
+        output: z.ZodObject<{
+            stdoutPreview: z.ZodString;
+            stderrPreview: z.ZodString;
+            stdoutBytes: z.ZodNumber;
+            stderrBytes: z.ZodNumber;
+            logRef: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    metadata: z.ZodOptional<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown>>>;
+}, z.core.$strip>;
+export declare const interruptClaimedRuntimeCommandInputSchema: z.ZodObject<{
+    claimToken: z.ZodString;
+    reason: z.ZodString;
+    result: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        signal: z.ZodNullable<z.ZodString>;
+        output: z.ZodObject<{
+            stdoutPreview: z.ZodString;
+            stderrPreview: z.ZodString;
+            stdoutBytes: z.ZodNumber;
+            stderrBytes: z.ZodNumber;
+            logRef: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    metadata: z.ZodOptional<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown>>>;
+}, z.core.$strip>;
+export declare const cancelRuntimeCommandInputSchema: z.ZodObject<{
+    reason: z.ZodString;
+    metadata: z.ZodOptional<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown>>>;
+}, z.core.$strip>;
+export declare const getRuntimeCommandInputSchema: 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>>;
+export type RuntimeCommandContract = z.infer<typeof runtimeCommandSchema>;
+export type RuntimeCommandClaimContract = z.infer<typeof runtimeCommandClaimSchema>;
+export type CreateRuntimeCommandInput = z.input<typeof createRuntimeCommandInputSchema>;
+export type ClaimRuntimeCommandsInput = z.input<typeof claimRuntimeCommandsInputSchema>;
+export type RuntimeCommandClaimCommandInput = z.input<typeof runtimeCommandClaimCommandInputSchema>;
+export type CompleteClaimedRuntimeCommandInput = z.input<typeof completeClaimedRuntimeCommandInputSchema>;
+export type FailClaimedRuntimeCommandInput = z.input<typeof failClaimedRuntimeCommandInputSchema>;
+export type InterruptClaimedRuntimeCommandInput = z.input<typeof interruptClaimedRuntimeCommandInputSchema>;
+export type CancelRuntimeCommandInput = z.input<typeof cancelRuntimeCommandInputSchema>;
+export type GetRuntimeCommandInput = z.input<typeof getRuntimeCommandInputSchema>;

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

@@ -0,0 +1,111 @@
+import { type UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { AnyJsonObject } from "@boboddy/core/common/contracts/json";
+import { type RuntimeEnvironmentRole } from "@boboddy/core/agent-sessions/runtime-environment/domain/runtime-environment";
+export declare const RUNTIME_COMMAND_ENVIRONMENT_ROLES: readonly ["project", "agent"];
+export type RuntimeCommandEnvironmentRole = RuntimeEnvironmentRole;
+export declare const RUNTIME_COMMAND_STATUSES: readonly ["queued", "claimed", "running", "succeeded", "failed", "cancelled", "interrupted"];
+export type RuntimeCommandStatus = (typeof RUNTIME_COMMAND_STATUSES)[number];
+export type RuntimeCommandExecutionResult = {
+    exitCode: number | null;
+    signal: string | null;
+    output: {
+        stdoutPreview: string;
+        stderrPreview: string;
+        stdoutBytes: number;
+        stderrBytes: number;
+        logRef: string | null;
+    };
+};
+export type RuntimeCommandEntityProps = {
+    id: UuidV7;
+    projectId: UuidV7;
+    projectRuntimeSessionId: UuidV7;
+    environmentRole: RuntimeCommandEnvironmentRole;
+    command: string;
+    status: RuntimeCommandStatus;
+    claimedBy?: string | null | undefined;
+    claimToken?: string | null | undefined;
+    claimedAt?: Date | string | null | undefined;
+    lastHeartbeatAt?: Date | string | null | undefined;
+    leaseExpiresAt?: Date | string | null | undefined;
+    startedAt?: Date | string | null | undefined;
+    completedAt?: Date | string | null | undefined;
+    result?: RuntimeCommandExecutionResult | null | undefined;
+    failureReason?: string | null | undefined;
+    metadata?: AnyJsonObject | null | undefined;
+    createdAt?: Date | string | null | undefined;
+    updatedAt?: Date | string | null | undefined;
+};
+export type CreateRuntimeCommandEntityProps = Omit<RuntimeCommandEntityProps, "id"> & {
+    id?: UuidV7 | undefined;
+};
+export declare class RuntimeCommandEntity {
+    readonly id: UuidV7;
+    readonly projectId: UuidV7;
+    readonly projectRuntimeSessionId: UuidV7;
+    readonly environmentRole: RuntimeCommandEnvironmentRole;
+    readonly command: string;
+    readonly status: RuntimeCommandStatus;
+    readonly claimedBy: string | null;
+    readonly claimToken: string | null;
+    readonly claimedAt: Date | null | undefined;
+    readonly lastHeartbeatAt: Date | null | undefined;
+    readonly leaseExpiresAt: Date | null | undefined;
+    readonly startedAt: Date | null | undefined;
+    readonly completedAt: Date | null | undefined;
+    readonly result: RuntimeCommandExecutionResult | null;
+    readonly failureReason: string | null;
+    readonly metadata: AnyJsonObject;
+    readonly createdAt: Date | null | undefined;
+    readonly updatedAt: Date | null | undefined;
+    private constructor();
+    get isTerminal(): boolean;
+    static createQueued(props: Omit<CreateRuntimeCommandEntityProps, "status" | "claimedBy" | "claimToken" | "claimedAt" | "lastHeartbeatAt" | "leaseExpiresAt" | "startedAt" | "completedAt" | "result" | "failureReason">): RuntimeCommandEntity;
+    static rehydrate(props: RuntimeCommandEntityProps): RuntimeCommandEntity;
+    canBeClaimedAt(now: Date): boolean;
+    claim(input: {
+        workerId: string;
+        claimToken: string;
+        claimedAt: Date;
+        leaseExpiresAt: Date;
+    }): RuntimeCommandEntity;
+    markRunning(input: {
+        claimToken: string;
+        startedAt: Date;
+    }): RuntimeCommandEntity;
+    heartbeat(input: {
+        claimToken: string;
+        heartbeatAt: Date;
+        leaseExpiresAt: Date;
+    }): RuntimeCommandEntity;
+    succeed(input: {
+        claimToken: string;
+        completedAt: Date;
+        result: RuntimeCommandExecutionResult;
+        metadata?: AnyJsonObject | undefined;
+    }): RuntimeCommandEntity;
+    fail(input: {
+        claimToken: string;
+        completedAt: Date;
+        reason: string;
+        result?: RuntimeCommandExecutionResult | null | undefined;
+        metadata?: AnyJsonObject | undefined;
+    }): RuntimeCommandEntity;
+    interrupt(input: {
+        claimToken: string;
+        completedAt: Date;
+        reason: string;
+        result?: RuntimeCommandExecutionResult | null | undefined;
+        metadata?: AnyJsonObject | undefined;
+    }): RuntimeCommandEntity;
+    cancel(input: {
+        completedAt: Date;
+        reason: string;
+        metadata?: AnyJsonObject | undefined;
+    }): RuntimeCommandEntity;
+    toJSON(): RuntimeCommandEntityProps;
+    private assertClaimOwnership;
+    private assertNotTerminal;
+    private clearClaimFields;
+    private copy;
+}

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

@@ -0,0 +1,20 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { RuntimeCommandRepo } from "../application/runtime-command-repo";
+import { RuntimeCommandEntity, type RuntimeCommandEntityProps } from "../domain/runtime-command-entity";
+export declare class DrizzleRuntimeCommandRepo implements RuntimeCommandRepo {
+    load(id: RuntimeCommandEntityProps["id"], dbExecutor?: DbExecutor): Promise<RuntimeCommandEntity | null>;
+    listByProjectRuntimeSessionId(projectRuntimeSessionId: RuntimeCommandEntityProps["projectRuntimeSessionId"], dbExecutor?: DbExecutor): Promise<RuntimeCommandEntity[]>;
+    loadClaimableByProjectRuntimeSessionId(projectRuntimeSessionId: RuntimeCommandEntityProps["projectRuntimeSessionId"], environmentRole: RuntimeCommandEntityProps["environmentRole"], limit: number, now: Date, dbExecutor?: DbExecutor): Promise<RuntimeCommandEntity[]>;
+    create(runtimeCommand: RuntimeCommandEntity, dbExecutor?: DbExecutor): Promise<RuntimeCommandEntity>;
+    claim(runtimeCommandId: RuntimeCommandEntityProps["id"], claim: {
+        workerId: string;
+        claimToken: string;
+        claimedAt: Date;
+        leaseExpiresAt: Date;
+    }, dbExecutor?: DbExecutor): Promise<RuntimeCommandEntity | null>;
+    heartbeat(runtimeCommandId: RuntimeCommandEntityProps["id"], 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/infra/local-runtime-command-runner.d.ts

@@ -0,0 +1,25 @@
+import type { AnyJsonObject } from "@boboddy/core/common/contracts/json";
+import { type Logger } from "@boboddy/core/lib/logger";
+import type { ProjectRuntimeSessionExecutionTarget } from "@boboddy/core/agent-sessions/project-runtime-session/domain/project-runtime-session-execution-target";
+import type { RuntimeCommandRunner } from "../application/runtime-command-runner";
+export declare class LocalRuntimeCommandRunner implements RuntimeCommandRunner {
+    private readonly logger;
+    constructor(logger?: Logger);
+    executeOneShot({ command, executionTarget, metadata, onOutput, signal, }: {
+        command: string;
+        executionTarget: ProjectRuntimeSessionExecutionTarget;
+        metadata?: AnyJsonObject | undefined;
+        onOutput?: ((output: {
+            stream: "stdout" | "stderr";
+            chunk: string;
+        }) => Promise<void> | void) | undefined;
+        signal?: AbortSignal | undefined;
+    }): Promise<{
+        metadata: {
+            mode: string;
+        };
+        exitCode: number | null;
+        signal: string | null;
+        output: import("../application/runtime-command-runner").RuntimeCommandExecutionOutputTransport;
+    }>;
+}

package/dist/packages/core/src/agent-sessions/runtime-environment/domain/runtime-environment.d.ts

@@ -0,0 +1,12 @@
+export declare const RUNTIME_ENVIRONMENT_ROLES: readonly ["project", "agent"];
+export type RuntimeEnvironmentRole = (typeof RUNTIME_ENVIRONMENT_ROLES)[number];
+export type RuntimeEnvironmentRef = string & {
+    readonly __brand: "RuntimeEnvironmentRef";
+};
+export type RuntimeRunnerAssignment = string & {
+    readonly __brand: "RuntimeRunnerAssignment";
+};
+export declare const parseRuntimeEnvironmentRef: (value: string) => RuntimeEnvironmentRef;
+export declare const parseOptionalRuntimeEnvironmentRef: (value?: string | null) => RuntimeEnvironmentRef | null;
+export declare const parseRuntimeRunnerAssignment: (value: string) => RuntimeRunnerAssignment;
+export declare const parseOptionalRuntimeRunnerAssignment: (value?: string | null) => RuntimeRunnerAssignment | null;

package/dist/packages/core/src/agent-sessions/runtime-operation-event/application/runtime-operation-event-publisher.d.ts

@@ -0,0 +1,24 @@
+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 { AnyJsonObject } from "@boboddy/core/common/contracts/json";
+import { RuntimeOperationEvent, type RuntimeOperationEventType, type RuntimeOperationKind } from "../domain/runtime-operation-event";
+import type { RuntimeOperationEventRepo } from "./runtime-operation-event-repo";
+export type PublishRuntimeOperationEventInput = {
+    projectId: UuidV7;
+    projectRuntimeSessionId: UuidV7;
+    operationKind: RuntimeOperationKind;
+    operationId: UuidV7;
+    eventType: RuntimeOperationEventType;
+    payload?: AnyJsonObject | undefined;
+};
+export type RuntimeOperationEventPublisher = {
+    publish(input: PublishRuntimeOperationEventInput, dbExecutor?: DbExecutor): Promise<RuntimeOperationEvent>;
+};
+export declare class DefaultRuntimeOperationEventPublisher implements RuntimeOperationEventPublisher {
+    private readonly runtimeOperationEventRepo;
+    private readonly timeProvider;
+    private readonly pendingPublishes;
+    constructor(runtimeOperationEventRepo: RuntimeOperationEventRepo, timeProvider: TimeProvider);
+    publish(input: PublishRuntimeOperationEventInput, dbExecutor?: DbExecutor): Promise<RuntimeOperationEvent>;
+}

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

@@ -0,0 +1,17 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { RuntimeOperationEvent, RuntimeOperationKind } from "../domain/runtime-operation-event";
+export type RuntimeOperationEventRepo = {
+    create(event: RuntimeOperationEvent, dbExecutor?: DbExecutor): Promise<RuntimeOperationEvent>;
+    listByProjectRuntimeSessionId(projectRuntimeSessionId: UuidV7, dbExecutor?: DbExecutor): Promise<RuntimeOperationEvent[]>;
+    listByOperation(input: {
+        projectRuntimeSessionId: UuidV7;
+        operationKind: RuntimeOperationKind;
+        operationId: UuidV7;
+    }, dbExecutor?: DbExecutor): Promise<RuntimeOperationEvent[]>;
+    getLatestSequence(input: {
+        projectRuntimeSessionId: UuidV7;
+        operationKind: RuntimeOperationKind;
+        operationId: UuidV7;
+    }, dbExecutor?: DbExecutor): Promise<number>;
+};

package/dist/packages/core/src/agent-sessions/runtime-operation-event/domain/runtime-operation-event.d.ts

@@ -0,0 +1,35 @@
+import { type UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { AnyJsonObject } from "@boboddy/core/common/contracts/json";
+export declare const RUNTIME_OPERATION_KINDS: readonly ["command", "service"];
+export type RuntimeOperationKind = (typeof RUNTIME_OPERATION_KINDS)[number];
+export declare const RUNTIME_OPERATION_EVENT_TYPES: readonly ["started", "stdout", "stderr", "ready", "failed", "completed", "stopped", "access_point_announced"];
+export type RuntimeOperationEventType = (typeof RUNTIME_OPERATION_EVENT_TYPES)[number];
+export type RuntimeOperationEventProps = {
+    id: UuidV7;
+    projectId: UuidV7;
+    projectRuntimeSessionId: UuidV7;
+    operationKind: RuntimeOperationKind;
+    operationId: UuidV7;
+    sequence: number;
+    eventType: RuntimeOperationEventType;
+    payload?: AnyJsonObject | null | undefined;
+    createdAt?: Date | string | null | undefined;
+};
+export type CreateRuntimeOperationEventProps = Omit<RuntimeOperationEventProps, "id"> & {
+    id?: UuidV7 | undefined;
+};
+export declare class RuntimeOperationEvent {
+    readonly id: UuidV7;
+    readonly projectId: UuidV7;
+    readonly projectRuntimeSessionId: UuidV7;
+    readonly operationKind: RuntimeOperationKind;
+    readonly operationId: UuidV7;
+    readonly sequence: number;
+    readonly eventType: RuntimeOperationEventType;
+    readonly payload: AnyJsonObject;
+    readonly createdAt: Date | null | undefined;
+    private constructor();
+    static create(props: CreateRuntimeOperationEventProps): RuntimeOperationEvent;
+    static rehydrate(props: RuntimeOperationEventProps): RuntimeOperationEvent;
+    toJSON(): RuntimeOperationEventProps;
+}

package/dist/packages/core/src/agent-sessions/runtime-operation-event/infra/file-runtime-operation-event-repo.d.ts

@@ -0,0 +1,25 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { ProjectRuntimeSessionRepo } from "@boboddy/core/agent-sessions/project-runtime-session/application/project-runtime-session-repo";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { RuntimeOperationEventRepo } from "../application/runtime-operation-event-repo";
+import { RuntimeOperationEvent, type RuntimeOperationKind } from "../domain/runtime-operation-event";
+export declare class FileRuntimeOperationEventRepo implements RuntimeOperationEventRepo {
+    private readonly projectRuntimeSessionRepo;
+    constructor(projectRuntimeSessionRepo: ProjectRuntimeSessionRepo);
+    create(event: RuntimeOperationEvent, dbExecutor?: DbExecutor): Promise<RuntimeOperationEvent>;
+    listByProjectRuntimeSessionId(projectRuntimeSessionId: UuidV7, dbExecutor?: DbExecutor): Promise<RuntimeOperationEvent[]>;
+    listByOperation(input: {
+        projectRuntimeSessionId: UuidV7;
+        operationKind: RuntimeOperationKind;
+        operationId: UuidV7;
+    }, dbExecutor?: DbExecutor): Promise<RuntimeOperationEvent[]>;
+    getLatestSequence(input: {
+        projectRuntimeSessionId: UuidV7;
+        operationKind: RuntimeOperationKind;
+        operationId: UuidV7;
+    }, dbExecutor?: DbExecutor): Promise<number>;
+    private resolveOperationStreamPath;
+    private resolveEventsDirectoryPath;
+    private readEventsFromFile;
+    private pathExists;
+}

package/dist/packages/core/src/agent-sessions/runtime-service/application/create-runtime-service.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 { RuntimeServiceRepo } from "./runtime-service-repo";
+import { type CreateRuntimeServiceInput, type RuntimeServiceContract } from "../contracts/runtime-service-contracts";
+export declare const createRuntimeService: (input: CreateRuntimeServiceInput, { userId, projectRepo, projectRuntimeSessionRepo, runtimeServiceRepo, timeProvider, dbExecutor, logger, }: {
+    userId: UuidV7;
+    projectRepo: ProjectRepo;
+    projectRuntimeSessionRepo: ProjectRuntimeSessionRepo;
+    runtimeServiceRepo: RuntimeServiceRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+    logger?: Logger | undefined;
+}) => Promise<RuntimeServiceContract>;

package/dist/packages/core/src/agent-sessions/runtime-service/application/get-runtime-service.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 { ProjectRepo } from "@boboddy/core/projects/project/application/project-repo";
+import type { RuntimeServiceRepo } from "./runtime-service-repo";
+import { type GetRuntimeServiceInput, type RuntimeServiceContract } from "../contracts/runtime-service-contracts";
+export declare const getRuntimeService: (input: GetRuntimeServiceInput, { userId, projectRepo, runtimeServiceRepo, dbExecutor, }: {
+    userId: UuidV7;
+    projectRepo: ProjectRepo;
+    runtimeServiceRepo: RuntimeServiceRepo;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<RuntimeServiceContract>;

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

@@ -0,0 +1,3 @@
+import { type RuntimeServiceContract } from "../contracts/runtime-service-contracts";
+import type { RuntimeServiceEntity } from "../domain/runtime-service-entity";
+export declare const runtimeServiceEntityToContract: (runtimeService: RuntimeServiceEntity) => RuntimeServiceContract;

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

@@ -0,0 +1,10 @@
+export declare const RUNTIME_SERVICE_OUTPUT_PREVIEW_LIMIT = 4000;
+export declare const summarizeRuntimeServiceOutput: (output: {
+    stdout: string;
+    stderr: string;
+}) => {
+    stdoutPreview: string;
+    stderrPreview: string;
+    stdoutBytes: number;
+    stderrBytes: number;
+};

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

@@ -0,0 +1,9 @@
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { RuntimeServiceEntity } from "../domain/runtime-service-entity";
+export type RuntimeServiceRepo = {
+    load(id: UuidV7, dbExecutor?: DbExecutor): Promise<RuntimeServiceEntity | null>;
+    listByProjectRuntimeSessionId(projectRuntimeSessionId: UuidV7, dbExecutor?: DbExecutor): Promise<RuntimeServiceEntity[]>;
+    create(runtimeService: RuntimeServiceEntity, dbExecutor?: DbExecutor): Promise<RuntimeServiceEntity>;
+    save(runtimeService: RuntimeServiceEntity, dbExecutor?: DbExecutor): Promise<RuntimeServiceEntity>;
+};

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

@@ -0,0 +1,23 @@
+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";
+import type { RuntimeServiceAccessPoint } from "../domain/runtime-service-access-point";
+import type { RuntimeServiceEntity } from "../domain/runtime-service-entity";
+export type RuntimeServiceOutputEvent = {
+    stream: "stdout" | "stderr";
+    chunk: string;
+};
+export type RuntimeServiceRunner = {
+    start(input: {
+        runtimeService: RuntimeServiceEntity;
+        executionTarget: ProjectRuntimeSessionExecutionTarget;
+        onOutput?: ((output: RuntimeServiceOutputEvent) => Promise<void> | void) | undefined;
+    }): Promise<{
+        accessPoints: RuntimeServiceAccessPoint[];
+        readyAt: Date;
+        metadata?: AnyJsonObject | undefined;
+    }>;
+    stop(input: {
+        runtimeService: RuntimeServiceEntity;
+        executionTarget: ProjectRuntimeSessionExecutionTarget;
+    }): Promise<void>;
+};

package/dist/packages/core/src/agent-sessions/runtime-service/application/runtime-session-service-exposure-provider.d.ts

@@ -0,0 +1,19 @@
+import type { ProjectRuntimeSessionExecutionTarget } from "@boboddy/core/agent-sessions/project-runtime-session/domain/project-runtime-session-execution-target";
+import type { RuntimeServiceAccessPoint, RuntimeServiceAccessPointProtocol } from "../domain/runtime-service-access-point";
+export type RuntimeSessionServiceAccessPoint = RuntimeServiceAccessPoint & {
+    targetPort: number;
+};
+export type EnsureDefaultRuntimeServiceAccessPointsInput = {
+    executionTarget: ProjectRuntimeSessionExecutionTarget;
+    workspacePath: string;
+    devcontainerConfigPath: string;
+};
+export type EnsureRuntimeServiceAccessPointInput = EnsureDefaultRuntimeServiceAccessPointsInput & {
+    targetPort: number;
+    protocol: RuntimeServiceAccessPointProtocol;
+};
+export type RuntimeSessionServiceExposureProvider = {
+    ensureDefaultAccessPoints(input: EnsureDefaultRuntimeServiceAccessPointsInput): Promise<RuntimeSessionServiceAccessPoint[]>;
+    ensureAccessPoint(input: EnsureRuntimeServiceAccessPointInput): Promise<RuntimeSessionServiceAccessPoint>;
+    stop(executionTarget: ProjectRuntimeSessionExecutionTarget): Promise<void>;
+};

package/dist/packages/core/src/agent-sessions/runtime-service/application/start-runtime-service-locally.d.ts

@@ -0,0 +1,21 @@
+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 { RuntimeOperationEventPublisher } from "@boboddy/core/agent-sessions/runtime-operation-event/application/runtime-operation-event-publisher";
+import type { RuntimeServiceRepo } from "./runtime-service-repo";
+import type { RuntimeServiceRunner } from "./runtime-service-runner";
+import { type RuntimeServiceContract, type StartRuntimeServiceInput } from "../contracts/runtime-service-contracts";
+export declare const startRuntimeServiceLocally: (input: StartRuntimeServiceInput, { userId, projectRepo, projectRuntimeSessionRepo, runtimeServiceRepo, runtimeServiceRunner, runtimeOperationEventPublisher, timeProvider, dbExecutor, logger, }: {
+    userId: UuidV7;
+    projectRepo: ProjectRepo;
+    projectRuntimeSessionRepo: ProjectRuntimeSessionRepo;
+    runtimeServiceRepo: RuntimeServiceRepo;
+    runtimeServiceRunner: RuntimeServiceRunner;
+    runtimeOperationEventPublisher: RuntimeOperationEventPublisher;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+    logger?: Logger | undefined;
+}) => Promise<RuntimeServiceContract>;

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

@@ -0,0 +1,32 @@
+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 { getProjectRuntimeSessionExecutionTarget } from "@boboddy/core/agent-sessions/project-runtime-session/application/project-runtime-session-execution-target";
+import type { RuntimeOperationEventPublisher } from "@boboddy/core/agent-sessions/runtime-operation-event/application/runtime-operation-event-publisher";
+import type { RuntimeServiceRepo } from "./runtime-service-repo";
+import type { RuntimeServiceRunner } from "./runtime-service-runner";
+import type { RuntimeServiceEntity } from "../domain/runtime-service-entity";
+import { type RuntimeServiceContract, type StopRuntimeServiceInput } from "../contracts/runtime-service-contracts";
+export declare const stopOwnedRuntimeService: (runtimeService: RuntimeServiceEntity, { runtimeServiceRepo, runtimeServiceRunner, runtimeOperationEventPublisher, executionTarget, timeProvider, dbExecutor, logger, }: {
+    runtimeServiceRepo: RuntimeServiceRepo;
+    runtimeServiceRunner: RuntimeServiceRunner;
+    runtimeOperationEventPublisher: RuntimeOperationEventPublisher;
+    executionTarget?: ReturnType<typeof getProjectRuntimeSessionExecutionTarget> | undefined;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+    logger?: Logger | undefined;
+}) => Promise<RuntimeServiceEntity>;
+export declare const stopRuntimeService: (input: StopRuntimeServiceInput, { userId, projectRepo, projectRuntimeSessionRepo, runtimeServiceRepo, runtimeServiceRunner, runtimeOperationEventPublisher, timeProvider, dbExecutor, logger, }: {
+    userId: UuidV7;
+    projectRepo: ProjectRepo;
+    projectRuntimeSessionRepo: ProjectRuntimeSessionRepo;
+    runtimeServiceRepo: RuntimeServiceRepo;
+    runtimeServiceRunner: RuntimeServiceRunner;
+    runtimeOperationEventPublisher: RuntimeOperationEventPublisher;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+    logger?: Logger | undefined;
+}) => Promise<RuntimeServiceContract>;