codex-relay 1.0.0

package/dist/src.js

@@ -0,0 +1,730 @@
+import { z } from "zod";
+//#region ../../packages/api-schema/src/index.ts
+const IsoDateTimeSchema = z.string().datetime();
+const ThreadStateSchema = z.enum([
+	"idle",
+	"running",
+	"completed",
+	"failed"
+]);
+const ChatMessageRoleSchema = z.enum([
+	"user",
+	"assistant",
+	"status",
+	"tool",
+	"reasoning",
+	"error"
+]);
+const ChatMessageStateSchema = z.enum([
+	"streaming",
+	"completed",
+	"failed"
+]);
+const ChatMessageKindSchema = z.enum([
+	"chat",
+	"thinking",
+	"toolActivity",
+	"commandExecution",
+	"fileChange",
+	"plan",
+	"approvalRequest",
+	"structuredUserInput",
+	"subagentAction",
+	"webSearch",
+	"unknown"
+]);
+const ApprovalModeSchema = z.enum([
+	"on-request",
+	"on-failure",
+	"never"
+]);
+const RuntimeModeSchema = z.enum([
+	"default",
+	"auto",
+	"full-access",
+	"on-request"
+]);
+const SandboxModeSchema = z.enum([
+	"workspace-write",
+	"danger-full-access",
+	"read-only"
+]);
+const ReasoningEffortSchema = z.enum([
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+]);
+const ThreadCollaborationModeSchema = z.enum(["default", "plan"]);
+const ThreadRunOptionsSchema = z.object({
+	model: z.string().trim().min(1).optional(),
+	runtimeMode: RuntimeModeSchema.default("default"),
+	approvalPolicy: ApprovalModeSchema.optional(),
+	sandboxMode: SandboxModeSchema.optional(),
+	reasoningEffort: ReasoningEffortSchema.optional(),
+	collaborationMode: ThreadCollaborationModeSchema.default("default")
+});
+const CodexModelSchema = z.object({
+	id: z.string().min(1),
+	model: z.string().min(1),
+	displayName: z.string().min(1),
+	description: z.string().optional(),
+	isDefault: z.boolean().default(false),
+	defaultReasoningEffort: ReasoningEffortSchema.optional(),
+	supportedReasoningEfforts: z.array(ReasoningEffortSchema).default([])
+});
+const ContextWindowUsageSchema = z.object({
+	tokensUsed: z.number().int().nonnegative(),
+	tokenLimit: z.number().int().positive()
+});
+const RateLimitWindowSchema = z.object({
+	usedPercent: z.number().int().min(0).max(100),
+	windowDurationMins: z.number().int().positive().nullable().optional(),
+	resetsAt: z.number().int().positive().nullable().optional()
+});
+const RateLimitBucketSchema = z.object({
+	limitId: z.string().min(1),
+	limitName: z.string().nullable().optional(),
+	planType: z.string().nullable().optional(),
+	primary: RateLimitWindowSchema.nullable().optional(),
+	secondary: RateLimitWindowSchema.nullable().optional(),
+	rateLimitReachedType: z.string().nullable().optional()
+});
+const RateLimitsResponseSchema = z.object({ buckets: z.array(RateLimitBucketSchema) });
+const ThreadContextWindowResponseSchema = z.object({
+	threadId: z.string().min(1),
+	usage: ContextWindowUsageSchema.nullable(),
+	rolloutPath: z.string().nullable().optional()
+});
+const PromptAttachmentSchema = z.object({
+	type: z.literal("image"),
+	dataUri: z.string().trim().startsWith("data:image/"),
+	mimeType: z.string().trim().startsWith("image/").optional(),
+	name: z.string().trim().min(1).max(160).optional()
+});
+const ChatMessageSchema = z.object({
+	id: z.string().min(1),
+	threadId: z.string().min(1),
+	role: ChatMessageRoleSchema,
+	kind: ChatMessageKindSchema.default("chat"),
+	content: z.string(),
+	details: z.record(z.string(), z.unknown()).optional(),
+	createdAt: IsoDateTimeSchema,
+	updatedAt: IsoDateTimeSchema.optional(),
+	turnId: z.string().optional(),
+	state: ChatMessageStateSchema.optional()
+});
+const ThreadSummarySchema = z.object({
+	id: z.string().min(1),
+	title: z.string().min(1),
+	createdAt: IsoDateTimeSchema,
+	updatedAt: IsoDateTimeSchema,
+	state: ThreadStateSchema,
+	model: z.string().optional(),
+	cwd: z.string().optional(),
+	source: z.string().optional(),
+	messageCount: z.number().int().nonnegative().default(0),
+	lastMessagePreview: z.string().optional(),
+	lastActivityAt: IsoDateTimeSchema.optional(),
+	lastPrompt: z.string().optional(),
+	lastResult: z.string().optional(),
+	lastError: z.string().optional()
+});
+const StatusResponseSchema = z.object({
+	ok: z.boolean(),
+	service: z.literal("codex-relay-server"),
+	sdkAvailable: z.boolean(),
+	machineName: z.string().min(1),
+	workspacePath: z.string(),
+	threadCount: z.number().int().nonnegative(),
+	appServerAvailable: z.boolean().default(false)
+});
+const WorkspaceDirectoryEntrySchema = z.object({
+	name: z.string().min(1),
+	path: z.string().min(1)
+});
+const ListWorkspaceDirectoriesResponseSchema = z.object({
+	rootPath: z.string().min(1),
+	path: z.string().min(1),
+	parentPath: z.string().min(1).nullable(),
+	directories: z.array(WorkspaceDirectoryEntrySchema)
+});
+const WorkspaceChangesResponseSchema = z.object({
+	workspacePath: z.string().min(1),
+	status: z.string(),
+	diff: z.string(),
+	hasChanges: z.boolean(),
+	currentBranch: z.string().nullable().default(null),
+	branches: z.array(z.object({
+		current: z.boolean().default(false),
+		name: z.string().min(1)
+	})).default([]),
+	stats: z.object({
+		additions: z.number().int().nonnegative(),
+		deletions: z.number().int().nonnegative(),
+		filesChanged: z.number().int().nonnegative()
+	}).default({
+		additions: 0,
+		deletions: 0,
+		filesChanged: 0
+	}),
+	files: z.array(z.object({
+		additions: z.number().int().nonnegative(),
+		deletions: z.number().int().nonnegative(),
+		isBinary: z.boolean().default(false),
+		oldPath: z.string().nullable(),
+		path: z.string().min(1),
+		patch: z.string(),
+		stagedStatus: z.string().nullable(),
+		status: z.string().min(1),
+		worktreeStatus: z.string().nullable()
+	})).default([])
+});
+const CheckoutWorkspaceBranchRequestSchema = z.object({ branch: z.string().trim().min(1).refine((branch) => !branch.startsWith("-"), "Branch name cannot start with '-'.") });
+const CommitPushWorkspaceRequestSchema = z.object({ message: z.string().trim().min(1).max(240) });
+const WorkspaceGitActionResponseSchema = z.object({
+	branch: z.string().nullable(),
+	message: z.string().min(1),
+	output: z.string().default("")
+});
+const WebPreviewTargetSchema = z.object({
+	kind: z.literal("web"),
+	url: z.string().url(),
+	port: z.number().int().positive(),
+	label: z.string().min(1).optional(),
+	source: z.enum([
+		"detected-port",
+		"codex-output",
+		"user-entered"
+	]),
+	confidence: z.enum([
+		"low",
+		"medium",
+		"high"
+	]),
+	detectedAt: IsoDateTimeSchema
+});
+const PairRequestSchema = z.object({
+	clientName: z.string().trim().min(1).max(80).optional(),
+	secure: z.object({
+		clientEphemeralPublicKey: z.string().min(1),
+		clientNonce: z.string().min(1),
+		protocolVersion: z.literal(1)
+	}).optional()
+});
+const PairResponseSchema = z.object({
+	approvalCode: z.string().min(1).optional(),
+	approvalExpiresAt: IsoDateTimeSchema.optional(),
+	clientToken: z.string().min(1).optional(),
+	clientTokenExpiresAt: IsoDateTimeSchema.optional(),
+	secure: z.object({
+		encryptedPayload: z.string().min(1),
+		keyEpoch: z.number().int().nonnegative(),
+		protocolVersion: z.literal(1),
+		serverEphemeralPublicKey: z.string().min(1),
+		serverNonce: z.string().min(1),
+		serverSignature: z.string().min(1)
+	}).optional()
+});
+const EncryptedPayloadSchema = z.object({
+	ciphertext: z.string().min(1),
+	counter: z.number().int().nonnegative(),
+	keyEpoch: z.number().int().nonnegative(),
+	protocolVersion: z.literal(1),
+	sender: z.enum(["mobile", "server"])
+});
+z.object({
+	clientToken: z.string().min(1),
+	clientTokenExpiresAt: IsoDateTimeSchema
+});
+const ErrorResponseSchema = z.object({ error: z.object({
+	code: z.string(),
+	message: z.string(),
+	issues: z.array(z.string()).optional()
+}) });
+const CreateThreadRequestSchema = z.object({
+	attachments: z.array(PromptAttachmentSchema).max(6).optional(),
+	prompt: z.string().trim().min(1).optional(),
+	title: z.string().trim().min(1).max(120).optional(),
+	workspacePath: z.string().trim().min(1).optional()
+}).merge(ThreadRunOptionsSchema.partial());
+z.object({
+	thread: ThreadSummarySchema,
+	messages: z.array(ChatMessageSchema).default([]),
+	result: z.string().optional()
+});
+const RunThreadRequestSchema = z.object({
+	attachments: z.array(PromptAttachmentSchema).max(6).optional(),
+	prompt: z.string().trim().min(1)
+}).merge(ThreadRunOptionsSchema.partial());
+z.object({
+	thread: ThreadSummarySchema,
+	messages: z.array(ChatMessageSchema).default([]),
+	result: z.string()
+});
+const SubmitThreadInputResponseSchema = z.object({
+	acceptedAs: z.enum(["steering", "queued"]),
+	queueLength: z.number().int().nonnegative(),
+	thread: ThreadSummarySchema
+});
+const ApprovalDecisionSchema = z.enum([
+	"approve",
+	"approve-for-session",
+	"deny",
+	"cancel"
+]);
+const ResolveApprovalRequestSchema = z.object({
+	decision: ApprovalDecisionSchema,
+	answers: z.array(z.string()).optional()
+});
+const ResolveApprovalResponseSchema = z.object({ ok: z.boolean() });
+const ListThreadsResponseSchema = z.object({
+	threads: z.array(ThreadSummarySchema),
+	source: z.enum(["app-server", "memory"]).default("memory")
+});
+const ListModelsResponseSchema = z.object({ models: z.array(CodexModelSchema) });
+const ThreadDetailResponseSchema = z.object({
+	thread: ThreadSummarySchema,
+	messages: z.array(ChatMessageSchema)
+});
+const StreamThreadRunEventSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("thread.message.created"),
+		thread: ThreadSummarySchema,
+		message: ChatMessageSchema
+	}),
+	z.object({
+		type: z.literal("thread.message.delta"),
+		threadId: z.string().min(1),
+		messageId: z.string().min(1),
+		delta: z.string()
+	}),
+	z.object({
+		type: z.literal("thread.message.completed"),
+		thread: ThreadSummarySchema,
+		message: ChatMessageSchema
+	}),
+	z.object({
+		type: z.literal("thread.state.changed"),
+		thread: ThreadSummarySchema
+	}),
+	z.object({
+		type: z.literal("thread.error"),
+		thread: ThreadSummarySchema.optional(),
+		error: ErrorResponseSchema.shape.error
+	}),
+	z.object({
+		type: z.literal("thread.preview_target.detected"),
+		threadId: z.string().min(1),
+		target: WebPreviewTargetSchema
+	})
+]);
+const apiPaths = {
+	pair: "/v1/pair",
+	pairApproval: (approvalCode) => `/v1/pair/${encodeURIComponent(approvalCode)}`,
+	pairApprove: "/v1/pair/approve",
+	sessionRefresh: "/v1/session/refresh",
+	status: "/v1/status",
+	rateLimits: "/v1/rate-limits",
+	models: "/v1/models",
+	workspaceDirectories: "/v1/workspace-directories",
+	workspaceChanges: "/v1/workspace/changes",
+	workspaceCheckout: "/v1/workspace/checkout",
+	workspaceCommitPush: "/v1/workspace/commit-push",
+	threads: "/v1/threads",
+	thread: (threadId) => `/v1/threads/${encodeURIComponent(threadId)}`,
+	threadContextWindow: (threadId) => `/v1/threads/${encodeURIComponent(threadId)}/context-window`,
+	approval: (approvalId) => `/v1/approvals/${encodeURIComponent(approvalId)}`,
+	threadInput: (threadId) => `/v1/threads/${encodeURIComponent(threadId)}/input`,
+	threadRuns: (threadId) => `/v1/threads/${encodeURIComponent(threadId)}/runs`,
+	threadRunStream: (threadId) => `/v1/threads/${encodeURIComponent(threadId)}/runs/stream`
+};
+function createOpenApiDocument() {
+	return {
+		openapi: "3.1.0",
+		info: {
+			title: "Codex Relay Local Codex API",
+			version: "0.1.0"
+		},
+		paths: {
+			"/v1/status": { get: {
+				summary: "Local server status",
+				responses: { "200": jsonResponse("StatusResponse") }
+			} },
+			"/v1/threads": {
+				get: {
+					summary: "List locally known threads",
+					responses: { "200": jsonResponse("ListThreadsResponse") }
+				},
+				post: {
+					summary: "Start a Codex thread",
+					requestBody: jsonRequest("CreateThreadRequest"),
+					responses: {
+						"201": jsonResponse("CreateThreadResponse"),
+						"400": jsonResponse("ErrorResponse")
+					}
+				}
+			},
+			"/v1/workspace-directories": { get: {
+				summary: "List directories under the configured workspace",
+				responses: {
+					"200": jsonResponse("ListWorkspaceDirectoriesResponse"),
+					"400": jsonResponse("ErrorResponse")
+				}
+			} },
+			"/v1/threads/{threadId}/runs": { post: {
+				summary: "Run a prompt on a Codex thread",
+				parameters: [{
+					name: "threadId",
+					in: "path",
+					required: true,
+					schema: { type: "string" }
+				}],
+				requestBody: jsonRequest("RunThreadRequest"),
+				responses: {
+					"200": jsonResponse("RunThreadResponse"),
+					"400": jsonResponse("ErrorResponse"),
+					"404": jsonResponse("ErrorResponse")
+				}
+			} },
+			"/v1/threads/{threadId}/input": { post: {
+				summary: "Submit input to an already-running Codex thread",
+				requestBody: jsonRequest("RunThreadRequest"),
+				responses: {
+					"202": jsonResponse("SubmitThreadInputResponse"),
+					"400": jsonResponse("ErrorResponse"),
+					"404": jsonResponse("ErrorResponse"),
+					"409": jsonResponse("ErrorResponse")
+				}
+			} },
+			"/v1/threads/{threadId}/runs/stream": { post: {
+				summary: "Run a prompt on a Codex thread and stream events",
+				requestBody: jsonRequest("RunThreadRequest"),
+				responses: {
+					"200": {
+						description: "Server-sent events containing StreamThreadRunEvent payloads",
+						content: { "text/event-stream": { schema: { $ref: "#/components/schemas/StreamThreadRunEvent" } } }
+					},
+					"400": jsonResponse("ErrorResponse"),
+					"404": jsonResponse("ErrorResponse")
+				}
+			} }
+		},
+		components: { schemas: {
+			ThreadState: {
+				type: "string",
+				enum: ThreadStateSchema.options
+			},
+			ChatMessage: {
+				type: "object",
+				required: [
+					"id",
+					"threadId",
+					"role",
+					"content",
+					"createdAt"
+				],
+				properties: {
+					id: { type: "string" },
+					threadId: { type: "string" },
+					role: {
+						type: "string",
+						enum: ChatMessageRoleSchema.options
+					},
+					kind: {
+						type: "string",
+						enum: ChatMessageKindSchema.options
+					},
+					content: { type: "string" },
+					details: {
+						type: "object",
+						additionalProperties: true
+					},
+					createdAt: {
+						type: "string",
+						format: "date-time"
+					},
+					updatedAt: {
+						type: "string",
+						format: "date-time"
+					},
+					turnId: { type: "string" },
+					state: {
+						type: "string",
+						enum: ChatMessageStateSchema.options
+					}
+				}
+			},
+			ThreadSummary: {
+				type: "object",
+				required: [
+					"id",
+					"title",
+					"createdAt",
+					"updatedAt",
+					"state",
+					"messageCount"
+				],
+				properties: {
+					id: { type: "string" },
+					title: { type: "string" },
+					createdAt: {
+						type: "string",
+						format: "date-time"
+					},
+					updatedAt: {
+						type: "string",
+						format: "date-time"
+					},
+					state: { $ref: "#/components/schemas/ThreadState" },
+					messageCount: {
+						type: "integer",
+						minimum: 0
+					},
+					lastMessagePreview: { type: "string" },
+					lastActivityAt: {
+						type: "string",
+						format: "date-time"
+					},
+					lastPrompt: { type: "string" },
+					lastResult: { type: "string" },
+					lastError: { type: "string" }
+				}
+			},
+			StatusResponse: {
+				type: "object",
+				required: [
+					"ok",
+					"service",
+					"sdkAvailable",
+					"machineName",
+					"workspacePath",
+					"threadCount"
+				],
+				properties: {
+					ok: { type: "boolean" },
+					service: {
+						type: "string",
+						const: "codex-relay-server"
+					},
+					sdkAvailable: { type: "boolean" },
+					machineName: { type: "string" },
+					workspacePath: { type: "string" },
+					threadCount: {
+						type: "integer",
+						minimum: 0
+					}
+				}
+			},
+			WorkspaceDirectoryEntry: {
+				type: "object",
+				required: ["name", "path"],
+				properties: {
+					name: { type: "string" },
+					path: { type: "string" }
+				}
+			},
+			ListWorkspaceDirectoriesResponse: {
+				type: "object",
+				required: [
+					"rootPath",
+					"path",
+					"parentPath",
+					"directories"
+				],
+				properties: {
+					rootPath: { type: "string" },
+					path: { type: "string" },
+					parentPath: {
+						type: "string",
+						nullable: true
+					},
+					directories: {
+						type: "array",
+						items: { $ref: "#/components/schemas/WorkspaceDirectoryEntry" }
+					}
+				}
+			},
+			CreateThreadRequest: {
+				type: "object",
+				properties: {
+					attachments: {
+						type: "array",
+						maxItems: 6,
+						items: { $ref: "#/components/schemas/PromptAttachment" }
+					},
+					prompt: { type: "string" },
+					title: {
+						type: "string",
+						maxLength: 120
+					},
+					workspacePath: { type: "string" },
+					collaborationMode: {
+						type: "string",
+						enum: ["default", "plan"],
+						default: "default"
+					}
+				}
+			},
+			PromptAttachment: {
+				type: "object",
+				required: ["type", "dataUri"],
+				properties: {
+					type: {
+						type: "string",
+						const: "image"
+					},
+					dataUri: {
+						type: "string",
+						format: "uri",
+						pattern: "^data:image/"
+					},
+					mimeType: {
+						type: "string",
+						pattern: "^image/"
+					},
+					name: {
+						type: "string",
+						maxLength: 160
+					}
+				}
+			},
+			CreateThreadResponse: {
+				type: "object",
+				required: ["thread"],
+				properties: {
+					thread: { $ref: "#/components/schemas/ThreadSummary" },
+					messages: {
+						type: "array",
+						items: { $ref: "#/components/schemas/ChatMessage" }
+					},
+					result: { type: "string" }
+				}
+			},
+			RunThreadRequest: {
+				type: "object",
+				required: ["prompt"],
+				properties: {
+					attachments: {
+						type: "array",
+						maxItems: 6,
+						items: { $ref: "#/components/schemas/PromptAttachment" }
+					},
+					prompt: { type: "string" },
+					collaborationMode: {
+						type: "string",
+						enum: ["default", "plan"],
+						default: "default"
+					}
+				}
+			},
+			RunThreadResponse: {
+				type: "object",
+				required: ["thread", "result"],
+				properties: {
+					thread: { $ref: "#/components/schemas/ThreadSummary" },
+					messages: {
+						type: "array",
+						items: { $ref: "#/components/schemas/ChatMessage" }
+					},
+					result: { type: "string" }
+				}
+			},
+			SubmitThreadInputResponse: {
+				type: "object",
+				required: [
+					"acceptedAs",
+					"queueLength",
+					"thread"
+				],
+				properties: {
+					acceptedAs: {
+						type: "string",
+						enum: ["steering", "queued"]
+					},
+					queueLength: {
+						type: "integer",
+						minimum: 0
+					},
+					thread: { $ref: "#/components/schemas/ThreadSummary" }
+				}
+			},
+			ThreadDetailResponse: {
+				type: "object",
+				required: ["thread", "messages"],
+				properties: {
+					thread: { $ref: "#/components/schemas/ThreadSummary" },
+					messages: {
+						type: "array",
+						items: { $ref: "#/components/schemas/ChatMessage" }
+					}
+				}
+			},
+			StreamThreadRunEvent: { oneOf: [
+				{
+					type: "object",
+					properties: { type: { const: "thread.message.created" } }
+				},
+				{
+					type: "object",
+					properties: { type: { const: "thread.message.delta" } }
+				},
+				{
+					type: "object",
+					properties: { type: { const: "thread.message.completed" } }
+				},
+				{
+					type: "object",
+					properties: { type: { const: "thread.state.changed" } }
+				},
+				{
+					type: "object",
+					properties: { type: { const: "thread.error" } }
+				},
+				{
+					type: "object",
+					properties: { type: { const: "thread.preview_target.detected" } }
+				}
+			] },
+			ListThreadsResponse: {
+				type: "object",
+				required: ["threads"],
+				properties: { threads: {
+					type: "array",
+					items: { $ref: "#/components/schemas/ThreadSummary" }
+				} }
+			},
+			ErrorResponse: {
+				type: "object",
+				required: ["error"],
+				properties: { error: {
+					type: "object",
+					required: ["code", "message"],
+					properties: {
+						code: { type: "string" },
+						message: { type: "string" },
+						issues: {
+							type: "array",
+							items: { type: "string" }
+						}
+					}
+				} }
+			}
+		} }
+	};
+}
+function jsonRequest(schemaName) {
+	return {
+		required: true,
+		content: { "application/json": { schema: { $ref: `#/components/schemas/${schemaName}` } } }
+	};
+}
+function jsonResponse(schemaName) {
+	return {
+		description: schemaName,
+		content: { "application/json": { schema: { $ref: `#/components/schemas/${schemaName}` } } }
+	};
+}
+//#endregion
+export { WorkspaceGitActionResponseSchema as C, WorkspaceChangesResponseSchema as S, createOpenApiDocument as T, StreamThreadRunEventSchema as _, CreateThreadRequestSchema as a, ThreadDetailResponseSchema as b, ListThreadsResponseSchema as c, PairResponseSchema as d, RateLimitsResponseSchema as f, StatusResponseSchema as g, RunThreadRequestSchema as h, ContextWindowUsageSchema as i, ListWorkspaceDirectoriesResponseSchema as l, ResolveApprovalResponseSchema as m, CheckoutWorkspaceBranchRequestSchema as n, EncryptedPayloadSchema as o, ResolveApprovalRequestSchema as p, CommitPushWorkspaceRequestSchema as r, ListModelsResponseSchema as s, ChatMessageSchema as t, PairRequestSchema as u, SubmitThreadInputResponseSchema as v, apiPaths as w, ThreadSummarySchema as x, ThreadContextWindowResponseSchema as y };