@boboddy/sdk 0.0.7-alpha → 0.0.8-alpha

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

@@ -0,0 +1,140 @@
+import { z } from "zod";
+export declare const runtimeServiceEnvironmentRoleSchema: z.ZodEnum<{
+    project: "project";
+    agent: "agent";
+}>;
+export declare const runtimeServiceStatusSchema: z.ZodEnum<{
+    queued: "queued";
+    failed: "failed";
+    stopped: "stopped";
+    starting: "starting";
+    ready: "ready";
+    stopping: "stopping";
+}>;
+export declare const runtimeServiceAccessPointProtocolSchema: z.ZodEnum<{
+    tcp: "tcp";
+    http: "http";
+}>;
+export declare const runtimeServiceHealthcheckProtocolKindSchema: z.ZodEnum<{
+    tcp: "tcp";
+    http: "http";
+}>;
+export declare const runtimeServiceAccessPointSchema: z.ZodObject<{
+    host: z.ZodString;
+    port: z.ZodNumber;
+    protocol: z.ZodEnum<{
+        tcp: "tcp";
+        http: "http";
+    }>;
+}, z.core.$strip>;
+export declare const runtimeServiceHealthcheckSchema: z.ZodObject<{
+    protocolKind: z.ZodEnum<{
+        tcp: "tcp";
+        http: "http";
+    }>;
+    targetPort: z.ZodNumber;
+    path: z.ZodNullable<z.ZodString>;
+    expectedStatus: z.ZodNullable<z.ZodNumber>;
+    intervalMs: z.ZodNumber;
+    timeoutMs: z.ZodNumber;
+    retries: z.ZodNumber;
+}, z.core.$strip>;
+export declare const createRuntimeServiceHealthcheckInputSchema: z.ZodObject<{
+    protocolKind: z.ZodEnum<{
+        tcp: "tcp";
+        http: "http";
+    }>;
+    targetPort: z.ZodNumber;
+    path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    expectedStatus: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    intervalMs: z.ZodOptional<z.ZodNumber>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    retries: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const runtimeServiceSchema: 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";
+        failed: "failed";
+        stopped: "stopped";
+        starting: "starting";
+        ready: "ready";
+        stopping: "stopping";
+    }>;
+    healthcheck: z.ZodObject<{
+        protocolKind: z.ZodEnum<{
+            tcp: "tcp";
+            http: "http";
+        }>;
+        targetPort: z.ZodNumber;
+        path: z.ZodNullable<z.ZodString>;
+        expectedStatus: z.ZodNullable<z.ZodNumber>;
+        intervalMs: z.ZodNumber;
+        timeoutMs: z.ZodNumber;
+        retries: z.ZodNumber;
+    }, z.core.$strip>;
+    accessPoints: z.ZodArray<z.ZodObject<{
+        host: z.ZodString;
+        port: z.ZodNumber;
+        protocol: z.ZodEnum<{
+            tcp: "tcp";
+            http: "http";
+        }>;
+    }, 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;
+    startedAt: z.ZodNullable<z.ZodISODateTime>;
+    readyAt: z.ZodNullable<z.ZodISODateTime>;
+    stoppedAt: z.ZodNullable<z.ZodISODateTime>;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export declare const createRuntimeServiceInputSchema: 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;
+    healthcheck: z.ZodObject<{
+        protocolKind: z.ZodEnum<{
+            tcp: "tcp";
+            http: "http";
+        }>;
+        targetPort: z.ZodNumber;
+        path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        expectedStatus: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        intervalMs: z.ZodOptional<z.ZodNumber>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        retries: z.ZodOptional<z.ZodNumber>;
+    }, 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 getRuntimeServiceInputSchema: 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>>;
+    runtimeServiceId: 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 startRuntimeServiceInputSchema: 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>>;
+    runtimeServiceId: 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 stopRuntimeServiceInputSchema: 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>>;
+    runtimeServiceId: 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 RuntimeServiceContract = z.infer<typeof runtimeServiceSchema>;
+export type CreateRuntimeServiceInput = z.input<typeof createRuntimeServiceInputSchema>;
+export type GetRuntimeServiceInput = z.input<typeof getRuntimeServiceInputSchema>;
+export type StartRuntimeServiceInput = z.input<typeof startRuntimeServiceInputSchema>;
+export type StopRuntimeServiceInput = z.input<typeof stopRuntimeServiceInputSchema>;

package/dist/packages/core/src/agent-sessions/runtime-service/domain/runtime-service-access-point.d.ts

@@ -0,0 +1,12 @@
+export declare const RUNTIME_SERVICE_ACCESS_POINT_PROTOCOLS: readonly ["tcp", "http"];
+export type RuntimeServiceAccessPointProtocol = (typeof RUNTIME_SERVICE_ACCESS_POINT_PROTOCOLS)[number];
+export type RuntimeServiceAccessPoint = {
+    host: string;
+    port: number;
+    protocol: RuntimeServiceAccessPointProtocol;
+};
+export declare const createRuntimeServiceAccessPoint: (input: {
+    host: string;
+    port: number;
+    protocol: string;
+}) => RuntimeServiceAccessPoint;

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

@@ -0,0 +1,76 @@
+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";
+import { type RuntimeServiceAccessPoint } from "./runtime-service-access-point";
+import { type RuntimeServiceHealthcheck } from "./runtime-service-healthcheck";
+export declare const RUNTIME_SERVICE_ENVIRONMENT_ROLES: readonly ["project", "agent"];
+export type RuntimeServiceEnvironmentRole = RuntimeEnvironmentRole;
+export declare const RUNTIME_SERVICE_STATUSES: readonly ["queued", "starting", "ready", "stopping", "stopped", "failed"];
+export type RuntimeServiceStatus = (typeof RUNTIME_SERVICE_STATUSES)[number];
+export type RuntimeServiceEntityProps = {
+    id: UuidV7;
+    projectId: UuidV7;
+    projectRuntimeSessionId: UuidV7;
+    environmentRole: RuntimeServiceEnvironmentRole;
+    command: string;
+    status: RuntimeServiceStatus;
+    healthcheck: RuntimeServiceHealthcheck;
+    accessPoints?: RuntimeServiceAccessPoint[] | null | undefined;
+    failureReason?: string | null | undefined;
+    metadata?: AnyJsonObject | null | undefined;
+    createdAt?: Date | string | null | undefined;
+    startedAt?: Date | string | null | undefined;
+    readyAt?: Date | string | null | undefined;
+    stoppedAt?: Date | string | null | undefined;
+    updatedAt?: Date | string | null | undefined;
+};
+export type CreateRuntimeServiceEntityProps = Omit<RuntimeServiceEntityProps, "id"> & {
+    id?: UuidV7 | undefined;
+};
+export declare class RuntimeServiceEntity {
+    readonly id: UuidV7;
+    readonly projectId: UuidV7;
+    readonly projectRuntimeSessionId: UuidV7;
+    readonly environmentRole: RuntimeServiceEnvironmentRole;
+    readonly command: string;
+    readonly status: RuntimeServiceStatus;
+    readonly healthcheck: RuntimeServiceHealthcheck;
+    readonly accessPoints: RuntimeServiceAccessPoint[];
+    readonly failureReason: string | null;
+    readonly metadata: AnyJsonObject;
+    readonly createdAt: Date | null | undefined;
+    readonly startedAt: Date | null | undefined;
+    readonly readyAt: Date | null | undefined;
+    readonly stoppedAt: Date | null | undefined;
+    readonly updatedAt: Date | null | undefined;
+    private constructor();
+    get isTerminal(): boolean;
+    static createQueued(props: Omit<CreateRuntimeServiceEntityProps, "status" | "accessPoints" | "failureReason" | "startedAt" | "readyAt" | "stoppedAt"> & {
+        runtimeSessionIsActive: boolean;
+    }): RuntimeServiceEntity;
+    static rehydrate(props: RuntimeServiceEntityProps): RuntimeServiceEntity;
+    markStarting(input: {
+        startedAt: Date;
+        metadata?: AnyJsonObject | undefined;
+    }): RuntimeServiceEntity;
+    markReady(input: {
+        readyAt: Date;
+        accessPoints: RuntimeServiceAccessPoint[];
+        metadata?: AnyJsonObject | undefined;
+    }): RuntimeServiceEntity;
+    markFailed(input: {
+        failedAt: Date;
+        reason: string;
+        metadata?: AnyJsonObject | undefined;
+    }): RuntimeServiceEntity;
+    beginStopping(input: {
+        stoppedAt: Date;
+        metadata?: AnyJsonObject | undefined;
+    }): RuntimeServiceEntity;
+    markStopped(input: {
+        stoppedAt: Date;
+        metadata?: AnyJsonObject | undefined;
+    }): RuntimeServiceEntity;
+    toJSON(): RuntimeServiceEntityProps;
+    private copy;
+}

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

@@ -0,0 +1,20 @@
+export declare const RUNTIME_SERVICE_HEALTHCHECK_PROTOCOL_KINDS: readonly ["http", "tcp"];
+export type RuntimeServiceHealthcheckProtocolKind = (typeof RUNTIME_SERVICE_HEALTHCHECK_PROTOCOL_KINDS)[number];
+export type RuntimeServiceHealthcheck = {
+    protocolKind: RuntimeServiceHealthcheckProtocolKind;
+    targetPort: number;
+    path: string | null;
+    expectedStatus: number | null;
+    intervalMs: number;
+    timeoutMs: number;
+    retries: number;
+};
+export declare const createRuntimeServiceHealthcheck: (input: {
+    protocolKind: RuntimeServiceHealthcheckProtocolKind;
+    targetPort: number;
+    path?: string | null | undefined;
+    expectedStatus?: number | null | undefined;
+    intervalMs?: number | undefined;
+    timeoutMs?: number | undefined;
+    retries?: number | undefined;
+}) => RuntimeServiceHealthcheck;

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

@@ -0,0 +1,9 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { RuntimeServiceRepo } from "../application/runtime-service-repo";
+import { RuntimeServiceEntity, type RuntimeServiceEntityProps } from "../domain/runtime-service-entity";
+export declare class DrizzleRuntimeServiceRepo implements RuntimeServiceRepo {
+    load(id: RuntimeServiceEntityProps["id"], dbExecutor?: DbExecutor): Promise<RuntimeServiceEntity | null>;
+    listByProjectRuntimeSessionId(projectRuntimeSessionId: RuntimeServiceEntityProps["projectRuntimeSessionId"], 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/infra/local-runtime-service-readiness-probe.d.ts

@@ -0,0 +1,42 @@
+import type { RuntimeServiceAccessPoint } from "@boboddy/core/agent-sessions/runtime-service/domain/runtime-service-access-point";
+import type { RuntimeServiceHealthcheck } from "@boboddy/core/agent-sessions/runtime-service/domain/runtime-service-healthcheck";
+import type { Logger } from "@boboddy/core/lib/logger";
+export declare const READY_CHECK_SCRIPT = "const mode = process.argv[1];\nif (mode === \"http\") {\n  const [url, timeoutMs, expectedStatus] = process.argv.slice(2);\n  const http = require(\"node:http\");\n  const { URL } = require(\"node:url\");\n  const targetUrl = new URL(url);\n  const request = http.request(\n    targetUrl,\n    {\n      method: \"GET\",\n      timeout: Number(timeoutMs),\n    },\n    (response) => {\n      response.resume();\n      response.on(\"end\", () => {\n        if (response.statusCode === Number(expectedStatus)) {\n          process.exit(0);\n        }\n        console.error(\n          \"HTTP readiness probe expected status\",\n          expectedStatus,\n          \"but received\",\n          response.statusCode,\n          \"for\",\n          url,\n        );\n        process.exit(1);\n      });\n    },\n  );\n  request.on(\"timeout\", () => {\n    console.error(\"HTTP readiness probe timed out for\", url);\n    request.destroy();\n    process.exit(1);\n  });\n  request.on(\"error\", (error) => {\n    console.error(\"HTTP readiness probe request failed for\", url, error?.message ?? String(error));\n    process.exit(1);\n  });\n  request.end();\n} else {\n  const net = require(\"node:net\");\n  const [host, port, timeoutMs] = process.argv.slice(2);\n  const socket = net.connect({ host, port: Number(port) });\n  socket.setTimeout(Number(timeoutMs));\n  socket.on(\"connect\", () => {\n    socket.destroy();\n    process.exit(0);\n  });\n  socket.on(\"timeout\", () => {\n    console.error(\"TCP readiness probe timed out for\", host + \":\" + port);\n    socket.destroy();\n    process.exit(1);\n  });\n  socket.on(\"error\", (error) => {\n    console.error(\"TCP readiness probe connection failed for\", host + \":\" + port, error?.message ?? String(error));\n    process.exit(1);\n  });\n}\n";
+export type ReadinessProbeFailure = {
+    exitCode: number | null;
+    signal: string | null;
+    stdout: string;
+    stderr: string;
+    reason: string;
+};
+export declare const buildProbeOutputPreview: (value: string) => string;
+export declare const formatReadinessTarget: (input: {
+    healthcheck: RuntimeServiceHealthcheck;
+    accessPoint: RuntimeServiceAccessPoint;
+    checkHost: string;
+}) => string;
+export declare const summarizeReadinessProbeFailure: (failure: ReadinessProbeFailure) => {
+    exitCode: number | null;
+    signal: string | null;
+    reason: string;
+    stdoutPreview: string;
+    stderrPreview: string;
+};
+export declare function runReadinessProbe(input: {
+    healthcheck: RuntimeServiceHealthcheck;
+    accessPoint: RuntimeServiceAccessPoint;
+    checkContainerId: string;
+    checkHost: string;
+}): Promise<{
+    succeeded: true;
+} | {
+    succeeded: false;
+    failure: ReadinessProbeFailure;
+}>;
+export declare function waitForReady(input: {
+    healthcheck: RuntimeServiceHealthcheck;
+    accessPoint: RuntimeServiceAccessPoint;
+    checkContainerId: string;
+    checkHost: string;
+    log: Logger;
+}): Promise<void>;

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

@@ -0,0 +1,32 @@
+import type { AnyJsonObject } from "@boboddy/core/common/contracts/json";
+import { type Logger } from "@boboddy/core/lib/logger";
+import type { RuntimeSessionServiceExposureProvider } from "@boboddy/core/agent-sessions/runtime-service/application/runtime-session-service-exposure-provider";
+import type { RuntimeServiceRunner } from "@boboddy/core/agent-sessions/runtime-service/application/runtime-service-runner";
+import type { RuntimeServiceAccessPoint } from "@boboddy/core/agent-sessions/runtime-service/domain/runtime-service-access-point";
+import type { RuntimeServiceEntity } from "@boboddy/core/agent-sessions/runtime-service/domain/runtime-service-entity";
+import type { ProjectRuntimeSessionExecutionTarget } from "@boboddy/core/agent-sessions/project-runtime-session/domain/project-runtime-session-execution-target";
+export declare class LocalRuntimeServiceRunner implements RuntimeServiceRunner {
+    private readonly runtimeSessionServiceExposureProvider;
+    private readonly logger;
+    private readonly runningServices;
+    constructor(runtimeSessionServiceExposureProvider: RuntimeSessionServiceExposureProvider, logger?: Logger);
+    start({ runtimeService, executionTarget, onOutput, }: {
+        runtimeService: RuntimeServiceEntity;
+        executionTarget: ProjectRuntimeSessionExecutionTarget;
+        onOutput?: ((output: {
+            stream: "stdout" | "stderr";
+            chunk: string;
+        }) => Promise<void> | void) | undefined;
+    }): Promise<{
+        accessPoints: RuntimeServiceAccessPoint[];
+        readyAt: Date;
+        metadata?: AnyJsonObject | undefined;
+    }>;
+    stop({ runtimeService, executionTarget, }: {
+        runtimeService: RuntimeServiceEntity;
+        executionTarget: ProjectRuntimeSessionExecutionTarget;
+    }): Promise<void>;
+    private copyCommandScript;
+    private readServiceOutputSummary;
+    private readServiceStreamOutput;
+}

package/dist/packages/core/src/common/contracts/json.d.ts

@@ -0,0 +1,9 @@
+import z from "zod";
+export type AnyJsonPrimitive = string | number | boolean | null;
+export type AnyJsonValue = AnyJsonPrimitive | AnyJsonObject | AnyJsonArray;
+export interface AnyJsonObject {
+    [key: string]: AnyJsonValue;
+}
+export type AnyJsonArray = AnyJsonValue[];
+export declare const anyJsonValueSchema: z.ZodType<AnyJsonValue>;
+export declare const anyJsonObjectSchema: z.ZodType<AnyJsonObject>;

package/dist/packages/core/src/common/contracts/opencode-mcp.d.ts

@@ -0,0 +1,73 @@
+import { z } from "zod";
+export declare const openCodeMcpLocalConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"local">;
+    command: z.ZodArray<z.ZodString>;
+    environment: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    timeout: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>;
+export declare const openCodeMcpOAuthConfigSchema: z.ZodObject<{
+    clientId: z.ZodOptional<z.ZodString>;
+    clientSecret: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+    redirectUri: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const openCodeMcpRemoteConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"remote">;
+    url: z.ZodString;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    oauth: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        clientId: z.ZodOptional<z.ZodString>;
+        clientSecret: z.ZodOptional<z.ZodString>;
+        scope: z.ZodOptional<z.ZodString>;
+        redirectUri: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodLiteral<false>]>>;
+    timeout: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>;
+export declare const openCodeMcpEnabledOverrideSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const openCodeMcpServerConfigSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"local">;
+    command: z.ZodArray<z.ZodString>;
+    environment: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    timeout: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"remote">;
+    url: z.ZodString;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    oauth: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        clientId: z.ZodOptional<z.ZodString>;
+        clientSecret: z.ZodOptional<z.ZodString>;
+        scope: z.ZodOptional<z.ZodString>;
+        redirectUri: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodLiteral<false>]>>;
+    timeout: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    enabled: z.ZodBoolean;
+}, z.core.$strict>]>;
+export declare const openCodeMcpServersSchema: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"local">;
+    command: z.ZodArray<z.ZodString>;
+    environment: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    timeout: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"remote">;
+    url: z.ZodString;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    oauth: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        clientId: z.ZodOptional<z.ZodString>;
+        clientSecret: z.ZodOptional<z.ZodString>;
+        scope: z.ZodOptional<z.ZodString>;
+        redirectUri: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodLiteral<false>]>>;
+    timeout: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    enabled: z.ZodBoolean;
+}, z.core.$strict>]>>;
+export type OpenCodeMcpServers = z.infer<typeof openCodeMcpServersSchema>;

package/dist/packages/core/src/common/contracts/uuid-v7.d.ts

@@ -0,0 +1,8 @@
+import z from "zod";
+export type UuidV7 = string & {
+    readonly __brand: "uuidv7";
+};
+export declare const isUuidV7: (value: string) => value is UuidV7;
+export declare const parseUuidV7: (value: string) => UuidV7;
+export declare const createUuidV7: () => UuidV7;
+export declare const uuidV7Schema: z.ZodString & z.ZodType<UuidV7, string, z.core.$ZodTypeInternals<UuidV7, string>>;

package/dist/packages/core/src/lib/db/db-executor.d.ts

@@ -0,0 +1,4 @@
+import { type getDb } from "./index";
+export type DbClient = ReturnType<typeof getDb>;
+export type DbTransaction = Parameters<Parameters<DbClient["transaction"]>[0]>[0];
+export type DbExecutor = DbClient | DbTransaction;

package/dist/packages/core/src/lib/db/index.d.ts

@@ -0,0 +1,7 @@
+import postgres from "postgres";
+import * as schema from "./schema";
+export declare const getDb: () => import("drizzle-orm/postgres-js").PostgresJsDatabase<typeof schema> & {
+    $client: postgres.Sql<{}>;
+};
+export declare const closeDb: () => Promise<void>;
+export declare const resetDbForTests: () => Promise<void>;