Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

codex working ish

Theo Brownef733cb7e5f44
diff --git a/README.md b/README.md
index 514ff7354..85dbd6e24 100644
--- a/README.md
+++ b/README.md
@@ -1,16 +1,22 @@
-# Electron TODO Monorepo (Turborepo + Bun)
+# CodeThing (Electron + Vite + Bun)
-A long-lived Electron starter focused on:
+CodeThing is a desktop shell for coding agents. This first implementation is:
-1. Performance: Vite renderer, small typed IPC surface, serialized persistence writes.
-2. Maintainability: strict TypeScript, explicit package boundaries, isolated renderer.
-3. Modern best practices: Bun workspaces, Turborepo task graph, shared contracts.
+1. Codex-first: connects to `codex app-server` and streams turn/item events.
+2. Provider-ready: renderer speaks a provider abstraction so Claude Code can plug in later.
+3. Typed end-to-end: contracts validate payloads at preload/main boundaries.
## Workspace layout
-- `apps/desktop`: Electron main + preload process.
-- `apps/renderer`: React + Vite + Tailwind renderer UI.
-- `packages/contracts`: shared runtime-validated schemas and IPC/type contracts.
+- `/apps/desktop`: Electron main + preload process, includes provider and Codex session managers.
+- `/apps/renderer`: React + Vite UI for session control, conversation, and protocol event stream.
+- `/packages/contracts`: shared Zod schemas + TypeScript types for IPC and provider events.
+
+## Codex prerequisites
+
+- Install Codex CLI so `codex` is on your PATH.
+- Authenticate Codex before running CodeThing (for example via API key or ChatGPT auth supported by Codex).
+- CodeThing starts the server via `codex app-server` per session.
## Security and boundary model
@@ -25,18 +31,20 @@ A long-lived Electron starter focused on:
- `bun run dev`: starts contract build/watch, renderer dev server, and Electron process.
- `bun run build`: builds contracts, renderer, and desktop bundles through Turbo.
- `bun run typecheck`: strict TypeScript checks for all packages.
+- `bun run test`: runs workspace tests.
Optional:
- `ELECTRON_RENDERER_PORT=5180 bun run dev` if `5173` is already in use.
-## Notes for future native bindings
+## Provider architecture
-Add new main-process capabilities by extending `packages/contracts` first:
+The renderer now depends on `nativeApi.providers.*`:
-1. Add schema + types for payload/result.
-2. Add an IPC channel constant.
-3. Implement `ipcMain.handle` in `apps/desktop/src/main.ts`.
-4. Expose a typed preload wrapper in `apps/desktop/src/preload.ts`.
-5. Consume only via `window.nativeApi` in renderer.
+1. `startSession`
+2. `sendTurn`
+3. `interruptTurn`
+4. `stopSession`
+5. `listSessions`
+6. `onEvent`
-This keeps native concerns out of React and makes refactors low risk.
+Codex is the only implemented provider right now. `claudeCode` is reserved in contracts/UI but returns a not-implemented error in main-process dispatch.
diff --git a/apps/desktop/src/codexAppServerManager.ts b/apps/desktop/src/codexAppServerManager.ts
new file mode 100644
index 000000000..ba21e3402
--- /dev/null
+++ b/apps/desktop/src/codexAppServerManager.ts
@@ -0,0 +1,690 @@
+import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+import readline from "node:readline";
+
+import type {
+ ProviderEvent,
+ ProviderSendTurnInput,
+ ProviderSession,
+ ProviderSessionStartInput,
+ ProviderTurnStartResult,
+} from "@acme/contracts";
+
+type PendingRequestKey = string;
+
+interface PendingRequest {
+ method: string;
+ timeout: ReturnType<typeof setTimeout>;
+ resolve: (value: unknown) => void;
+ reject: (error: Error) => void;
+}
+
+interface CodexSessionContext {
+ session: ProviderSession;
+ child: ChildProcessWithoutNullStreams;
+ output: readline.Interface;
+ pending: Map<PendingRequestKey, PendingRequest>;
+ nextRequestId: number;
+ stopping: boolean;
+}
+
+interface JsonRpcError {
+ code?: number;
+ message?: string;
+}
+
+interface JsonRpcRequest {
+ id: string | number;
+ method: string;
+ params?: unknown;
+}
+
+interface JsonRpcResponse {
+ id: string | number;
+ result?: unknown;
+ error?: JsonRpcError;
+}
+
+interface JsonRpcNotification {
+ method: string;
+ params?: unknown;
+}
+
+export interface CodexAppServerManagerEvents {
+ event: [event: ProviderEvent];
+}
+
+export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEvents> {
+ private readonly sessions = new Map<string, CodexSessionContext>();
+
+ async startSession(
+ input: ProviderSessionStartInput,
+ ): Promise<ProviderSession> {
+ const sessionId = randomUUID();
+ const now = new Date().toISOString();
+
+ const session: ProviderSession = {
+ sessionId,
+ provider: "codex",
+ status: "connecting",
+ model: input.model,
+ cwd: input.cwd,
+ createdAt: now,
+ updatedAt: now,
+ };
+
+ const child = spawn("codex", ["app-server"], {
+ cwd: input.cwd,
+ env: process.env,
+ stdio: ["pipe", "pipe", "pipe"],
+ });
+ const output = readline.createInterface({ input: child.stdout });
+
+ const context: CodexSessionContext = {
+ session,
+ child,
+ output,
+ pending: new Map(),
+ nextRequestId: 1,
+ stopping: false,
+ };
+
+ this.sessions.set(sessionId, context);
+ this.attachProcessListeners(context);
+
+ this.emitLifecycleEvent(
+ context,
+ "session/connecting",
+ "Starting codex app-server",
+ );
+
+ try {
+ await this.sendRequest(context, "initialize", {
+ clientInfo: {
+ name: "codething_desktop",
+ title: "CodeThing Desktop",
+ version: "0.1.0",
+ },
+ capabilities: {
+ experimentalApi: false,
+ },
+ });
+
+ this.writeMessage(context, { method: "initialized" });
+
+ const threadStart = await this.sendRequest(context, "thread/start", {
+ model: input.model ?? null,
+ cwd: input.cwd ?? null,
+ approvalPolicy: input.approvalPolicy,
+ sandbox: input.sandboxMode,
+ experimentalRawEvents: false,
+ });
+
+ const threadId = this.readString(
+ this.readObject(threadStart)?.thread,
+ "id",
+ );
+ if (!threadId) {
+ throw new Error("thread/start response did not include a thread id.");
+ }
+
+ this.updateSession(context, {
+ status: "ready",
+ threadId,
+ });
+ this.emitLifecycleEvent(
+ context,
+ "session/ready",
+ `Connected to thread ${threadId}`,
+ );
+ return { ...context.session };
+ } catch (error) {
+ const message =
+ error instanceof Error
+ ? error.message
+ : "Failed to start Codex session.";
+ this.updateSession(context, {
+ status: "error",
+ lastError: message,
+ });
+ this.emitErrorEvent(context, "session/startFailed", message);
+ this.stopSession(sessionId);
+ throw new Error(message);
+ }
+ }
+
+ async sendTurn(
+ input: ProviderSendTurnInput,
+ ): Promise<ProviderTurnStartResult> {
+ const context = this.requireSession(input.sessionId);
+ if (!context.session.threadId) {
+ throw new Error("Session is missing a thread id.");
+ }
+
+ const response = await this.sendRequest(context, "turn/start", {
+ threadId: context.session.threadId,
+ input: [
+ {
+ type: "text",
+ text: input.input,
+ text_elements: [],
+ },
+ ],
+ });
+
+ const turn = this.readObject(this.readObject(response), "turn");
+ const turnId = this.readString(turn, "id");
+ if (!turnId) {
+ throw new Error("turn/start response did not include a turn id.");
+ }
+
+ this.updateSession(context, {
+ status: "running",
+ activeTurnId: turnId,
+ });
+
+ return {
+ threadId: context.session.threadId,
+ turnId,
+ };
+ }
+
+ async interruptTurn(sessionId: string, turnId?: string): Promise<void> {
+ const context = this.requireSession(sessionId);
+ const effectiveTurnId = turnId ?? context.session.activeTurnId;
+
+ if (!effectiveTurnId || !context.session.threadId) {
+ return;
+ }
+
+ await this.sendRequest(context, "turn/interrupt", {
+ threadId: context.session.threadId,
+ turnId: effectiveTurnId,
+ });
+ }
+
+ stopSession(sessionId: string): void {
+ const context = this.sessions.get(sessionId);
+ if (!context) {
+ return;
+ }
+
+ context.stopping = true;
+
+ for (const pending of context.pending.values()) {
+ clearTimeout(pending.timeout);
+ pending.reject(new Error("Session stopped before request completed."));
+ }
+ context.pending.clear();
+
+ context.output.close();
+
+ if (!context.child.killed) {
+ context.child.kill();
+ }
+
+ this.updateSession(context, {
+ status: "closed",
+ activeTurnId: undefined,
+ });
+ this.emitLifecycleEvent(context, "session/closed", "Session stopped");
+ this.sessions.delete(sessionId);
+ }
+
+ listSessions(): ProviderSession[] {
+ return Array.from(this.sessions.values(), ({ session }) => ({
+ ...session,
+ }));
+ }
+
+ hasSession(sessionId: string): boolean {
+ return this.sessions.has(sessionId);
+ }
+
+ stopAll(): void {
+ for (const sessionId of this.sessions.keys()) {
+ this.stopSession(sessionId);
+ }
+ }
+
+ private requireSession(sessionId: string): CodexSessionContext {
+ const context = this.sessions.get(sessionId);
+ if (!context) {
+ throw new Error(`Unknown session: ${sessionId}`);
+ }
+
+ if (context.session.status === "closed") {
+ throw new Error(`Session is closed: ${sessionId}`);
+ }
+
+ return context;
+ }
+
+ private attachProcessListeners(context: CodexSessionContext): void {
+ context.output.on("line", (line) => {
+ this.handleStdoutLine(context, line);
+ });
+
+ context.child.stderr.on("data", (chunk: Buffer) => {
+ const message = chunk.toString().trim();
+ if (!message) {
+ return;
+ }
+
+ this.emitErrorEvent(context, "process/stderr", message);
+ });
+
+ context.child.on("error", (error) => {
+ const message = error.message || "codex app-server process errored.";
+ this.updateSession(context, {
+ status: "error",
+ lastError: message,
+ });
+ this.emitErrorEvent(context, "process/error", message);
+ });
+
+ context.child.on("exit", (code, signal) => {
+ if (context.stopping) {
+ return;
+ }
+
+ const message = `codex app-server exited (code=${code ?? "null"}, signal=${signal ?? "null"}).`;
+ this.updateSession(context, {
+ status: "closed",
+ activeTurnId: undefined,
+ lastError: code === 0 ? context.session.lastError : message,
+ });
+ this.emitLifecycleEvent(context, "session/exited", message);
+ this.sessions.delete(context.session.sessionId);
+ });
+ }
+
+ private handleStdoutLine(context: CodexSessionContext, line: string): void {
+ let parsed: unknown;
+ try {
+ parsed = JSON.parse(line);
+ } catch {
+ this.emitErrorEvent(
+ context,
+ "protocol/parseError",
+ "Received invalid JSON from codex app-server.",
+ );
+ return;
+ }
+
+ if (!parsed || typeof parsed !== "object") {
+ this.emitErrorEvent(
+ context,
+ "protocol/invalidMessage",
+ "Received non-object protocol message.",
+ );
+ return;
+ }
+
+ if (this.isServerRequest(parsed)) {
+ this.handleServerRequest(context, parsed);
+ return;
+ }
+
+ if (this.isServerNotification(parsed)) {
+ this.handleServerNotification(context, parsed);
+ return;
+ }
+
+ if (this.isResponse(parsed)) {
+ this.handleResponse(context, parsed);
+ return;
+ }
+
+ this.emitErrorEvent(
+ context,
+ "protocol/unrecognizedMessage",
+ "Received protocol message in an unknown shape.",
+ );
+ }
+
+ private handleServerNotification(
+ context: CodexSessionContext,
+ notification: JsonRpcNotification,
+ ): void {
+ const route = this.readRouteFields(notification.params);
+ const textDelta =
+ notification.method === "item/agentMessage/delta"
+ ? this.readString(notification.params, "delta")
+ : undefined;
+
+ this.emitEvent({
+ id: randomUUID(),
+ kind: "notification",
+ provider: "codex",
+ sessionId: context.session.sessionId,
+ createdAt: new Date().toISOString(),
+ method: notification.method,
+ threadId: route.threadId,
+ turnId: route.turnId,
+ itemId: route.itemId,
+ textDelta,
+ payload: notification.params,
+ });
+
+ if (notification.method === "thread/started") {
+ const threadId = this.readString(
+ this.readObject(notification.params)?.thread,
+ "id",
+ );
+ if (threadId) {
+ this.updateSession(context, { threadId });
+ }
+ return;
+ }
+
+ if (notification.method === "turn/started") {
+ const turnId = this.readString(
+ this.readObject(notification.params)?.turn,
+ "id",
+ );
+ this.updateSession(context, {
+ status: "running",
+ activeTurnId: turnId,
+ });
+ return;
+ }
+
+ if (notification.method === "turn/completed") {
+ const turn = this.readObject(notification.params, "turn");
+ const status = this.readString(turn, "status");
+ const errorMessage = this.readString(
+ this.readObject(turn, "error"),
+ "message",
+ );
+ this.updateSession(context, {
+ status: status === "failed" ? "error" : "ready",
+ activeTurnId: undefined,
+ lastError: errorMessage ?? context.session.lastError,
+ });
+ return;
+ }
+
+ if (notification.method === "error") {
+ const message = this.readString(
+ this.readObject(notification.params)?.error,
+ "message",
+ );
+ const willRetry = this.readBoolean(notification.params, "willRetry");
+
+ this.updateSession(context, {
+ status: willRetry ? "running" : "error",
+ lastError: message ?? context.session.lastError,
+ });
+ }
+ }
+
+ private handleServerRequest(
+ context: CodexSessionContext,
+ request: JsonRpcRequest,
+ ): void {
+ const route = this.readRouteFields(request.params);
+ this.emitEvent({
+ id: randomUUID(),
+ kind: "request",
+ provider: "codex",
+ sessionId: context.session.sessionId,
+ createdAt: new Date().toISOString(),
+ method: request.method,
+ threadId: route.threadId,
+ turnId: route.turnId,
+ itemId: route.itemId,
+ payload: request.params,
+ });
+
+ if (request.method === "item/commandExecution/requestApproval") {
+ this.writeMessage(context, {
+ id: request.id,
+ result: { decision: "decline" },
+ });
+ return;
+ }
+
+ if (request.method === "item/fileChange/requestApproval") {
+ this.writeMessage(context, {
+ id: request.id,
+ result: { decision: "decline" },
+ });
+ return;
+ }
+
+ if (request.method === "item/tool/requestUserInput") {
+ this.writeMessage(context, {
+ id: request.id,
+ result: { answers: {} },
+ });
+ return;
+ }
+
+ this.writeMessage(context, {
+ id: request.id,
+ error: {
+ code: -32601,
+ message: `Unsupported server request: ${request.method}`,
+ },
+ });
+ }
+
+ private handleResponse(
+ context: CodexSessionContext,
+ response: JsonRpcResponse,
+ ): void {
+ const key = String(response.id);
+ const pending = context.pending.get(key);
+ if (!pending) {
+ return;
+ }
+
+ clearTimeout(pending.timeout);
+ context.pending.delete(key);
+
+ if (response.error?.message) {
+ pending.reject(
+ new Error(
+ `${pending.method} failed: ${String(response.error.message)}`,
+ ),
+ );
+ return;
+ }
+
+ pending.resolve(response.result);
+ }
+
+ private async sendRequest<TResponse>(
+ context: CodexSessionContext,
+ method: string,
+ params: unknown,
+ timeoutMs = 20_000,
+ ): Promise<TResponse> {
+ const id = context.nextRequestId;
+ context.nextRequestId += 1;
+
+ const result = await new Promise<unknown>((resolve, reject) => {
+ const timeout = setTimeout(() => {
+ context.pending.delete(String(id));
+ reject(new Error(`Timed out waiting for ${method}.`));
+ }, timeoutMs);
+
+ context.pending.set(String(id), {
+ method,
+ timeout,
+ resolve,
+ reject,
+ });
+ this.writeMessage(context, {
+ method,
+ id,
+ params,
+ });
+ });
+
+ return result as TResponse;
+ }
+
+ private writeMessage(context: CodexSessionContext, message: unknown): void {
+ const encoded = JSON.stringify(message);
+ if (!context.child.stdin.writable) {
+ throw new Error("Cannot write to codex app-server stdin.");
+ }
+
+ context.child.stdin.write(`${encoded}\n`);
+ }
+
+ private emitLifecycleEvent(
+ context: CodexSessionContext,
+ method: string,
+ message: string,
+ ): void {
+ this.emitEvent({
+ id: randomUUID(),
+ kind: "session",
+ provider: "codex",
+ sessionId: context.session.sessionId,
+ createdAt: new Date().toISOString(),
+ method,
+ message,
+ });
+ }
+
+ private emitErrorEvent(
+ context: CodexSessionContext,
+ method: string,
+ message: string,
+ ): void {
+ this.emitEvent({
+ id: randomUUID(),
+ kind: "error",
+ provider: "codex",
+ sessionId: context.session.sessionId,
+ createdAt: new Date().toISOString(),
+ method,
+ message,
+ });
+ }
+
+ private emitEvent(event: ProviderEvent): void {
+ this.emit("event", event);
+ }
+
+ private updateSession(
+ context: CodexSessionContext,
+ updates: Partial<ProviderSession>,
+ ): void {
+ context.session = {
+ ...context.session,
+ ...updates,
+ updatedAt: new Date().toISOString(),
+ };
+ }
+
+ private isServerRequest(value: unknown): value is JsonRpcRequest {
+ if (!value || typeof value !== "object") {
+ return false;
+ }
+
+ const candidate = value as Record<string, unknown>;
+ return (
+ typeof candidate.method === "string" &&
+ (typeof candidate.id === "string" || typeof candidate.id === "number")
+ );
+ }
+
+ private isServerNotification(value: unknown): value is JsonRpcNotification {
+ if (!value || typeof value !== "object") {
+ return false;
+ }
+
+ const candidate = value as Record<string, unknown>;
+ return typeof candidate.method === "string" && !("id" in candidate);
+ }
+
+ private isResponse(value: unknown): value is JsonRpcResponse {
+ if (!value || typeof value !== "object") {
+ return false;
+ }
+
+ const candidate = value as Record<string, unknown>;
+ const hasId =
+ typeof candidate.id === "string" || typeof candidate.id === "number";
+ const hasMethod = typeof candidate.method === "string";
+ return hasId && !hasMethod;
+ }
+
+ private readRouteFields(params: unknown): {
+ threadId?: string;
+ turnId?: string;
+ itemId?: string;
+ } {
+ const route: {
+ threadId?: string;
+ turnId?: string;
+ itemId?: string;
+ } = {};
+
+ const threadId =
+ this.readString(params, "threadId") ??
+ this.readString(this.readObject(params, "thread"), "id");
+ const turnId =
+ this.readString(params, "turnId") ??
+ this.readString(this.readObject(params, "turn"), "id");
+ const itemId =
+ this.readString(params, "itemId") ??
+ this.readString(this.readObject(params, "item"), "id");
+
+ if (threadId) {
+ route.threadId = threadId;
+ }
+
+ if (turnId) {
+ route.turnId = turnId;
+ }
+
+ if (itemId) {
+ route.itemId = itemId;
+ }
+
+ return route;
+ }
+
+ private readObject(
+ value: unknown,
+ key?: string,
+ ): Record<string, unknown> | undefined {
+ const target =
+ key === undefined
+ ? value
+ : value && typeof value === "object"
+ ? (value as Record<string, unknown>)[key]
+ : undefined;
+
+ if (!target || typeof target !== "object") {
+ return undefined;
+ }
+
+ return target as Record<string, unknown>;
+ }
+
+ private readString(value: unknown, key: string): string | undefined {
+ if (!value || typeof value !== "object") {
+ return undefined;
+ }
+
+ const candidate = (value as Record<string, unknown>)[key];
+ return typeof candidate === "string" ? candidate : undefined;
+ }
+
+ private readBoolean(value: unknown, key: string): boolean | undefined {
+ if (!value || typeof value !== "object") {
+ return undefined;
+ }
+
+ const candidate = (value as Record<string, unknown>)[key];
+ return typeof candidate === "boolean" ? candidate : undefined;
+ }
+}
diff --git a/apps/desktop/src/main.ts b/apps/desktop/src/main.ts
index 881ab29a7..9c4990a85 100644
--- a/apps/desktop/src/main.ts
+++ b/apps/desktop/src/main.ts
@@ -1,8 +1,8 @@
import { fixPath } from "./fixPath";
fixPath();
-import path from "node:path";
import { spawn } from "node:child_process";
+import path from "node:path";
import { BrowserWindow, app, ipcMain, session } from "electron";
import {
@@ -16,12 +16,14 @@ import {
todoIdSchema,
} from "@acme/contracts";
import { ProcessManager } from "./processManager";
+import { ProviderManager } from "./providerManager";
import { TodoStore } from "./todoStore";
const isDevelopment = Boolean(process.env.VITE_DEV_SERVER_URL);
let todoStore: TodoStore;
const processManager = new ProcessManager();
+const providerManager = new ProviderManager();
function createWindow(): BrowserWindow {
const window = new BrowserWindow({
@@ -94,6 +96,47 @@ function registerIpcHandlers(): void {
processManager.write(agentSessionIdSchema.parse(sessionId), String(data));
},
);
+
+ // Provider handlers
+ ipcMain.handle(
+ IPC_CHANNELS.providerSessionStart,
+ async (_event, payload: unknown) => {
+ return providerManager.startSession(
+ payload as Parameters<typeof providerManager.startSession>[0],
+ );
+ },
+ );
+
+ ipcMain.handle(
+ IPC_CHANNELS.providerTurnStart,
+ async (_event, payload: unknown) => {
+ return providerManager.sendTurn(
+ payload as Parameters<typeof providerManager.sendTurn>[0],
+ );
+ },
+ );
+
+ ipcMain.handle(
+ IPC_CHANNELS.providerTurnInterrupt,
+ async (_event, payload: unknown) => {
+ await providerManager.interruptTurn(
+ payload as Parameters<typeof providerManager.interruptTurn>[0],
+ );
+ },
+ );
+
+ ipcMain.handle(
+ IPC_CHANNELS.providerSessionStop,
+ async (_event, payload: unknown) => {
+ providerManager.stopSession(
+ payload as Parameters<typeof providerManager.stopSession>[0],
+ );
+ },
+ );
+
+ ipcMain.handle(IPC_CHANNELS.providerSessionList, async () => {
+ return providerManager.listSessions();
+ });
}
async function runTerminalCommand(
@@ -101,8 +144,8 @@ async function runTerminalCommand(
): Promise<TerminalCommandResult> {
const shellPath =
process.platform === "win32"
- ? process.env.ComSpec ?? "cmd.exe"
- : process.env.SHELL ?? "/bin/sh";
+ ? (process.env.ComSpec ?? "cmd.exe")
+ : (process.env.SHELL ?? "/bin/sh");
const args =
process.platform === "win32"
@@ -169,12 +212,20 @@ function setupEventForwarding(window: BrowserWindow): void {
}
};
+ const onProviderEvent = (event: unknown) => {
+ if (!window.isDestroyed()) {
+ window.webContents.send(IPC_CHANNELS.providerEvent, event);
+ }
+ };
+
processManager.on("output", onOutput);
processManager.on("exit", onExit);
+ providerManager.on("event", onProviderEvent);
window.on("closed", () => {
processManager.off("output", onOutput);
processManager.off("exit", onExit);
+ providerManager.off("event", onProviderEvent);
});
}
@@ -211,6 +262,7 @@ async function bootstrap(): Promise<void> {
app.on("before-quit", () => {
processManager.killAll();
+ providerManager.stopAll();
});
app.whenReady().then(() => {
diff --git a/apps/desktop/src/preload.ts b/apps/desktop/src/preload.ts
index b9207d85c..9c44b6ef9 100644
--- a/apps/desktop/src/preload.ts
+++ b/apps/desktop/src/preload.ts
@@ -31,6 +31,24 @@ const nativeApi: NativeApi = {
return () => ipcRenderer.removeListener(IPC_CHANNELS.agentExit, listener);
},
},
+ providers: {
+ startSession: (input) =>
+ ipcRenderer.invoke(IPC_CHANNELS.providerSessionStart, input),
+ sendTurn: (input) =>
+ ipcRenderer.invoke(IPC_CHANNELS.providerTurnStart, input),
+ interruptTurn: (input) =>
+ ipcRenderer.invoke(IPC_CHANNELS.providerTurnInterrupt, input),
+ stopSession: (input) =>
+ ipcRenderer.invoke(IPC_CHANNELS.providerSessionStop, input),
+ listSessions: () => ipcRenderer.invoke(IPC_CHANNELS.providerSessionList),
+ onEvent: (callback) => {
+ const listener = (_event: Electron.IpcRendererEvent, payload: unknown) =>
+ callback(payload as Parameters<typeof callback>[0]);
+ ipcRenderer.on(IPC_CHANNELS.providerEvent, listener);
+ return () =>
+ ipcRenderer.removeListener(IPC_CHANNELS.providerEvent, listener);
+ },
+ },
};
contextBridge.exposeInMainWorld("nativeApi", nativeApi);
diff --git a/apps/desktop/src/providerManager.ts b/apps/desktop/src/providerManager.ts
new file mode 100644
index 000000000..2a9f37bcb
--- /dev/null
+++ b/apps/desktop/src/providerManager.ts
@@ -0,0 +1,69 @@
+import { EventEmitter } from "node:events";
+
+import {
+ type ProviderEvent,
+ type ProviderInterruptTurnInput,
+ type ProviderSendTurnInput,
+ type ProviderSession,
+ type ProviderSessionStartInput,
+ type ProviderStopSessionInput,
+ type ProviderTurnStartResult,
+ providerInterruptTurnInputSchema,
+ providerSendTurnInputSchema,
+ providerSessionStartInputSchema,
+ providerStopSessionInputSchema,
+} from "@acme/contracts";
+import { CodexAppServerManager } from "./codexAppServerManager";
+
+export interface ProviderManagerEvents {
+ event: [event: ProviderEvent];
+}
+
+export class ProviderManager extends EventEmitter<ProviderManagerEvents> {
+ private readonly codex = new CodexAppServerManager();
+
+ constructor() {
+ super();
+ this.codex.on("event", (event) => this.emit("event", event));
+ }
+
+ async startSession(raw: ProviderSessionStartInput): Promise<ProviderSession> {
+ const input = providerSessionStartInputSchema.parse(raw);
+ if (input.provider !== "codex") {
+ throw new Error(`Provider '${input.provider}' is not implemented yet.`);
+ }
+
+ return this.codex.startSession(input);
+ }
+
+ async sendTurn(raw: ProviderSendTurnInput): Promise<ProviderTurnStartResult> {
+ const input = providerSendTurnInputSchema.parse(raw);
+ if (!this.codex.hasSession(input.sessionId)) {
+ throw new Error(`Unknown provider session: ${input.sessionId}`);
+ }
+
+ return this.codex.sendTurn(input);
+ }
+
+ async interruptTurn(raw: ProviderInterruptTurnInput): Promise<void> {
+ const input = providerInterruptTurnInputSchema.parse(raw);
+ if (!this.codex.hasSession(input.sessionId)) {
+ throw new Error(`Unknown provider session: ${input.sessionId}`);
+ }
+
+ await this.codex.interruptTurn(input.sessionId, input.turnId);
+ }
+
+ stopSession(raw: ProviderStopSessionInput): void {
+ const input = providerStopSessionInputSchema.parse(raw);
+ this.codex.stopSession(input.sessionId);
+ }
+
+ listSessions(): ProviderSession[] {
+ return this.codex.listSessions();
+ }
+
+ stopAll(): void {
+ this.codex.stopAll();
+ }
+}
diff --git a/apps/renderer/src/App.tsx b/apps/renderer/src/App.tsx
index 1774e2962..6654da9f8 100644
--- a/apps/renderer/src/App.tsx
+++ b/apps/renderer/src/App.tsx
@@ -1,12 +1,55 @@
-import { type FormEvent, useMemo, useState } from "react";
+import {
+ type FormEvent,
+ type MutableRefObject,
+ useEffect,
+ useMemo,
+ useRef,
+ useState,
+} from "react";
-import type { TerminalCommandResult } from "@acme/contracts";
+import type {
+ ProviderEvent,
+ ProviderKind,
+ ProviderSession,
+} from "@acme/contracts";
-interface TerminalEntry {
+type SessionPhase = "disconnected" | "connecting" | "ready" | "running";
+
+interface ChatMessage {
id: string;
- command: string;
- result: TerminalCommandResult;
+ role: "user" | "assistant";
+ text: string;
createdAt: string;
+ streaming: boolean;
+}
+
+const PROVIDER_OPTIONS: Array<{
+ value: ProviderKind;
+ label: string;
+ available: boolean;
+}> = [
+ { value: "codex", label: "Codex", available: true },
+ { value: "claudeCode", label: "Claude Code (soon)", available: false },
+];
+
+function readNativeApi() {
+ if (typeof window === "undefined") {
+ return undefined;
+ }
+
+ return window.nativeApi;
+}
+
+function asObject(value: unknown): Record<string, unknown> | undefined {
+ if (!value || typeof value !== "object") {
+ return undefined;
+ }
+
+ return value as Record<string, unknown>;
+}
+
+function asString(value: unknown): string | undefined {
+ return typeof value === "string" ? value : undefined;
}
function formatTimestamp(isoDate: string): string {
@@ -17,66 +60,364 @@ function formatTimestamp(isoDate: string): string {
}).format(new Date(isoDate));
}
-function readNativeApi() {
- if (typeof window === "undefined") {
- return undefined;
+function derivePhase(session: ProviderSession | null): SessionPhase {
+ if (!session || session.status === "closed") {
+ return "disconnected";
}
- return window.nativeApi;
+ if (session.status === "connecting") {
+ return "connecting";
+ }
+
+ if (session.status === "running") {
+ return "running";
+ }
+
+ return "ready";
+}
+
+function evolveSession(
+ previous: ProviderSession,
+ event: ProviderEvent,
+): ProviderSession {
+ const payload = asObject(event.payload);
+
+ if (event.method === "thread/started") {
+ const thread = asObject(payload?.thread);
+ return {
+ ...previous,
+ threadId: asString(thread?.id) ?? event.threadId ?? previous.threadId,
+ updatedAt: event.createdAt,
+ };
+ }
+
+ if (event.method === "turn/started") {
+ const turn = asObject(payload?.turn);
+ return {
+ ...previous,
+ status: "running",
+ activeTurnId: asString(turn?.id) ?? event.turnId ?? previous.activeTurnId,
+ updatedAt: event.createdAt,
+ };
+ }
+
+ if (event.method === "turn/completed") {
+ const turn = asObject(payload?.turn);
+ const status = asString(turn?.status);
+ const turnError = asObject(turn?.error);
+ return {
+ ...previous,
+ status: status === "failed" ? "error" : "ready",
+ activeTurnId: undefined,
+ lastError: asString(turnError?.message) ?? previous.lastError,
+ updatedAt: event.createdAt,
+ };
+ }
+
+ if (event.kind === "error") {
+ return {
+ ...previous,
+ status: "error",
+ lastError: event.message ?? previous.lastError,
+ updatedAt: event.createdAt,
+ };
+ }
+
+ if (event.method === "session/closed" || event.method === "session/exited") {
+ return {
+ ...previous,
+ status: "closed",
+ activeTurnId: undefined,
+ lastError: event.message ?? previous.lastError,
+ updatedAt: event.createdAt,
+ };
+ }
+
+ return {
+ ...previous,
+ updatedAt: event.createdAt,
+ };
+}
+
+function applyEventToMessages(
+ previous: ChatMessage[],
+ event: ProviderEvent,
+ activeAssistantItemRef: MutableRefObject<string | null>,
+): ChatMessage[] {
+ const payload = asObject(event.payload);
+
+ if (event.method === "item/started") {
+ const item = asObject(payload?.item);
+ if (asString(item?.type) !== "agentMessage") {
+ return previous;
+ }
+
+ const itemId = asString(item?.id);
+ if (!itemId) {
+ return previous;
+ }
+
+ activeAssistantItemRef.current = itemId;
+ const seedText = asString(item?.text) ?? "";
+ const filtered = previous.filter((entry) => entry.id !== itemId);
+ return [
+ ...filtered,
+ {
+ id: itemId,
+ role: "assistant",
+ text: seedText,
+ createdAt: event.createdAt,
+ streaming: true,
+ },
+ ];
+ }
+
+ if (event.method === "item/agentMessage/delta") {
+ const itemId = event.itemId ?? asString(payload?.itemId);
+ const delta = event.textDelta ?? asString(payload?.delta) ?? "";
+ if (!itemId || !delta) {
+ return previous;
+ }
+
+ const existingIndex = previous.findIndex((entry) => entry.id === itemId);
+ if (existingIndex === -1) {
+ activeAssistantItemRef.current = itemId;
+ return [
+ ...previous,
+ {
+ id: itemId,
+ role: "assistant",
+ text: delta,
+ createdAt: event.createdAt,
+ streaming: true,
+ },
+ ];
+ }
+
+ const updated = [...previous];
+ const existing = updated[existingIndex];
+ if (!existing) {
+ return previous;
+ }
+ updated[existingIndex] = {
+ ...existing,
+ text: `${existing.text}${delta}`,
+ streaming: true,
+ };
+ return updated;
+ }
+
+ if (event.method === "item/completed") {
+ const item = asObject(payload?.item);
+ if (asString(item?.type) !== "agentMessage") {
+ return previous;
+ }
+
+ const itemId = asString(item?.id);
+ if (!itemId) {
+ return previous;
+ }
+
+ const fullText = asString(item?.text);
+ const existingIndex = previous.findIndex((entry) => entry.id === itemId);
+ if (existingIndex === -1) {
+ return [
+ ...previous,
+ {
+ id: itemId,
+ role: "assistant",
+ text: fullText ?? "",
+ createdAt: event.createdAt,
+ streaming: false,
+ },
+ ];
+ }
+
+ const updated = [...previous];
+ const existing = updated[existingIndex];
+ if (!existing) {
+ return previous;
+ }
+ updated[existingIndex] = {
+ ...existing,
+ text: fullText ?? existing.text,
+ streaming: false,
+ };
+
+ if (activeAssistantItemRef.current === itemId) {
+ activeAssistantItemRef.current = null;
+ }
+
+ return updated;
+ }
+
+ if (event.method === "turn/completed") {
+ return previous.map((entry) => ({ ...entry, streaming: false }));
+ }
+
+ return previous;
}
export default function App() {
const api = useMemo(() => readNativeApi(), []);
- const [command, setCommand] = useState("");
- const [history, setHistory] = useState<TerminalEntry[]>([]);
- const [isRunning, setIsRunning] = useState(false);
+ const [provider, setProvider] = useState<ProviderKind>("codex");
+ const [cwd, setCwd] = useState("");
+ const [model, setModel] = useState("gpt-5.1-codex");
+ const [prompt, setPrompt] = useState("");
+ const [session, setSession] = useState<ProviderSession | null>(null);
+ const [messages, setMessages] = useState<ChatMessage[]>([]);
+ const [events, setEvents] = useState<ProviderEvent[]>([]);
+ const [isConnecting, setIsConnecting] = useState(false);
+ const [isSending, setIsSending] = useState(false);
const [error, setError] = useState<string | null>(null);
- const onSubmit = async (event: FormEvent<HTMLFormElement>) => {
+ const currentSessionIdRef = useRef<string | null>(null);
+ const activeAssistantItemRef = useRef<string | null>(null);
+
+ useEffect(() => {
+ currentSessionIdRef.current = session?.sessionId ?? null;
+ }, [session?.sessionId]);
+
+ useEffect(() => {
+ if (!api) {
+ return;
+ }
+
+ return api.providers.onEvent((event) => {
+ const currentSessionId = currentSessionIdRef.current;
+ if (!currentSessionId || currentSessionId !== event.sessionId) {
+ return;
+ }
+
+ setEvents((previous) => [event, ...previous].slice(0, 200));
+ setSession((previous) => {
+ if (!previous || previous.sessionId !== event.sessionId) {
+ return previous;
+ }
+ return evolveSession(previous, event);
+ });
+ setMessages((previous) =>
+ applyEventToMessages(previous, event, activeAssistantItemRef),
+ );
+
+ if (event.kind === "error" && event.message) {
+ setError(event.message);
+ }
+ });
+ }, [api]);
+
+ const phase = derivePhase(session);
+
+ const onConnect = async (event: FormEvent<HTMLFormElement>) => {
event.preventDefault();
+ if (!api || provider !== "codex" || isConnecting) {
+ return;
+ }
+
+ setError(null);
+ setIsConnecting(true);
+ try {
+ const nextSession = await api.providers.startSession({
+ provider,
+ cwd: cwd.trim() || undefined,
+ model: model.trim() || undefined,
+ });
+ currentSessionIdRef.current = nextSession.sessionId;
+ activeAssistantItemRef.current = null;
+ setSession(nextSession);
+ setMessages([]);
+ setEvents([]);
+ } catch (connectError) {
+ setError(
+ connectError instanceof Error
+ ? connectError.message
+ : "Unable to connect to Codex app-server.",
+ );
+ } finally {
+ setIsConnecting(false);
+ }
+ };
+
+ const onDisconnect = async () => {
+ if (!api || !session) {
+ return;
+ }
- if (!api || isRunning) {
+ await api.providers.stopSession({ sessionId: session.sessionId });
+ currentSessionIdRef.current = null;
+ setSession((previous) =>
+ previous
+ ? {
+ ...previous,
+ status: "closed",
+ activeTurnId: undefined,
+ updatedAt: new Date().toISOString(),
+ }
+ : previous,
+ );
+ };
+
+ const onSendPrompt = async (event: FormEvent<HTMLFormElement>) => {
+ event.preventDefault();
+ if (!api || !session || isSending) {
return;
}
- const trimmed = command.trim();
+ const trimmed = prompt.trim();
if (!trimmed) {
return;
}
setError(null);
- setIsRunning(true);
+ setMessages((previous) => [
+ ...previous,
+ {
+ id: crypto.randomUUID(),
+ role: "user",
+ text: trimmed,
+ createdAt: new Date().toISOString(),
+ streaming: false,
+ },
+ ]);
+ setPrompt("");
+ setIsSending(true);
try {
- const result = await api.terminal.run({ command: trimmed });
- setHistory((previous) => [
- ...previous,
- {
- id: crypto.randomUUID(),
- command: trimmed,
- result,
- createdAt: new Date().toISOString(),
- },
- ]);
- setCommand("");
- } catch (runError) {
- const message =
- runError instanceof Error
- ? runError.message
- : "Could not execute command.";
- setError(message);
+ await api.providers.sendTurn({
+ sessionId: session.sessionId,
+ input: trimmed,
+ });
+ } catch (sendError) {
+ setError(
+ sendError instanceof Error
+ ? sendError.message
+ : "Failed to start a Codex turn.",
+ );
} finally {
- setIsRunning(false);
+ setIsSending(false);
+ }
+ };
+
+ const onInterrupt = async () => {
+ if (!api || !session) {
+ return;
}
+
+ await api.providers.interruptTurn({
+ sessionId: session.sessionId,
+ turnId: session.activeTurnId,
+ });
};
if (!api) {
return (
- <main className="mx-auto flex min-h-screen w-full max-w-4xl items-center justify-center px-8">
- <section className="rounded-3xl border border-amber-200 bg-amber-50 px-6 py-5 text-amber-900 shadow-soft">
- <h1 className="text-lg font-semibold">Native bridge unavailable</h1>
- <p className="mt-2 text-sm">
- Launch this UI through Electron so the preload API is available.
+ <main className="mx-auto flex min-h-screen w-full max-w-3xl items-center justify-center px-6 py-10">
+ <section className="surface-card w-full rounded-3xl p-8">
+ <p className="label-chip">CodeThing</p>
+ <h1 className="mt-3 text-3xl">Native bridge unavailable</h1>
+ <p className="mt-3 text-sm text-amber-100/80">
+ Launch the renderer through Electron so `window.nativeApi` is
+ exposed by preload.
</p>
</section>
</main>
@@ -84,102 +425,192 @@ export default function App() {
}
return (
- <main className="mx-auto flex min-h-screen w-full max-w-5xl flex-col px-6 py-10 text-slate-900 sm:px-10">
- <header className="rounded-3xl border border-slate-800/80 bg-slate-900 p-7 text-slate-100 shadow-soft">
- <p className="text-xs uppercase tracking-[0.18em] text-emerald-300">
- Demo Terminal
- </p>
- <h1 className="mt-2 font-mono text-3xl font-semibold tracking-tight">
- Shell Command Runner
+ <main className="mx-auto min-h-screen w-full max-w-7xl px-4 py-6 text-[#f3f0e9] sm:px-8">
+ <header className="surface-card relative overflow-hidden rounded-3xl px-6 py-7 sm:px-8">
+ <div className="grain absolute inset-0 pointer-events-none" />
+ <p className="label-chip relative">CodeThing / Provider Shell</p>
+ <h1 className="relative mt-3 text-4xl tracking-tight sm:text-5xl">
+ Codex-first workspace
</h1>
- <p className="mt-3 text-sm text-slate-300">
- Runs one command at a time in your shell and prints stdout/stderr.
+ <p className="relative mt-3 max-w-3xl text-sm text-[#efe8d7]/82 sm:text-base">
+ Built on the Codex app-server protocol with a provider abstraction in
+ the IPC layer, so Claude Code can be added without reshaping the UI
+ contract.
</p>
- <form className="mt-6 flex gap-3" onSubmit={onSubmit}>
- <input
- value={command}
- onChange={(event) => setCommand(event.target.value)}
- placeholder="e.g. ls -la"
- className="h-11 flex-1 rounded-xl border border-emerald-500/50 bg-slate-950 px-4 font-mono text-sm text-emerald-100 outline-none ring-0 transition focus:border-emerald-300"
- maxLength={4000}
- />
- <button
- type="submit"
- className="h-11 rounded-xl bg-emerald-500 px-5 text-sm font-semibold text-slate-950 transition hover:bg-emerald-400 disabled:cursor-not-allowed disabled:bg-emerald-800 disabled:text-emerald-300"
- disabled={isRunning}
- >
- {isRunning ? "Running..." : "Run"}
- </button>
- <button
- type="button"
- className="h-11 rounded-xl border border-slate-600 px-5 text-sm font-medium text-slate-200 transition hover:border-slate-400 hover:text-white disabled:cursor-not-allowed disabled:opacity-50"
- disabled={history.length === 0 || isRunning}
- onClick={() => setHistory([])}
- >
- Clear
- </button>
+ <form
+ className="relative mt-6 grid gap-3 rounded-2xl border border-[#f6a40f]/30 bg-[#0f2034]/65 p-4 sm:grid-cols-6"
+ onSubmit={onConnect}
+ >
+ <label className="sm:col-span-2">
+ <span className="field-label">Provider</span>
+ <select
+ className="field-input"
+ value={provider}
+ onChange={(event) =>
+ setProvider(event.target.value as ProviderKind)
+ }
+ disabled={isConnecting || phase !== "disconnected"}
+ >
+ {PROVIDER_OPTIONS.map((option) => (
+ <option
+ key={option.value}
+ value={option.value}
+ disabled={!option.available}
+ >
+ {option.label}
+ </option>
+ ))}
+ </select>
+ </label>
+
+ <label className="sm:col-span-2">
+ <span className="field-label">Working directory</span>
+ <input
+ className="field-input font-mono text-xs sm:text-sm"
+ value={cwd}
+ onChange={(event) => setCwd(event.target.value)}
+ placeholder="/Users/theo/Code/Work/..."
+ disabled={isConnecting || phase !== "disconnected"}
+ />
+ </label>
+
+ <label className="sm:col-span-1">
+ <span className="field-label">Model</span>
+ <input
+ className="field-input font-mono text-xs sm:text-sm"
+ value={model}
+ onChange={(event) => setModel(event.target.value)}
+ placeholder="gpt-5.1-codex"
+ disabled={isConnecting || phase !== "disconnected"}
+ />
+ </label>
+
+ <div className="sm:col-span-1 flex items-end">
+ {phase === "disconnected" ? (
+ <button
+ type="submit"
+ className="action-button action-primary w-full"
+ disabled={provider !== "codex" || isConnecting}
+ >
+ {isConnecting ? "Connecting..." : "Connect"}
+ </button>
+ ) : (
+ <button
+ type="button"
+ className="action-button action-danger w-full"
+ onClick={() => void onDisconnect()}
+ >
+ Disconnect
+ </button>
+ )}
+ </div>
</form>
+
+ <div className="relative mt-4 flex flex-wrap gap-2 text-xs">
+ <span className="status-pill">
+ phase={phase} provider={session?.provider ?? "none"}
+ </span>
+ <span className="status-pill">
+ thread={session?.threadId ?? "none"}
+ </span>
+ <span className="status-pill">
+ turn={session?.activeTurnId ?? "none"}
+ </span>
+ </div>
</header>
{error ? (
- <div className="mt-6 rounded-xl border border-rose-200 bg-rose-50 px-4 py-3 text-sm text-rose-700">
+ <div className="mt-4 rounded-2xl border border-rose-300/35 bg-rose-900/35 px-4 py-3 text-sm text-rose-100">
{error}
</div>
) : null}
- <section className="mt-6 flex-1 space-y-4">
- {history.length === 0 ? (
- <div className="rounded-2xl border border-dashed border-slate-300 bg-slate-50 px-4 py-6 text-sm text-slate-500">
- No commands run yet.
+ <section className="mt-5 grid gap-4 lg:grid-cols-[2fr_1fr]">
+ <article className="surface-card rounded-3xl p-4 sm:p-5">
+ <h2 className="text-xl">Conversation</h2>
+ <div className="mt-4 max-h-[52vh] space-y-3 overflow-y-auto pr-1">
+ {messages.length === 0 ? (
+ <div className="rounded-2xl border border-dashed border-[#f6d79e]/30 bg-[#0d1827]/70 px-4 py-5 text-sm text-[#d8d0c3]/75">
+ No turns yet. Start a session, then send a prompt.
+ </div>
+ ) : null}
+
+ {messages.map((entry) => (
+ <div
+ key={entry.id}
+ className={`message-card ${
+ entry.role === "user" ? "message-user" : "message-assistant"
+ }`}
+ >
+ <header className="mb-2 flex items-center justify-between text-[11px] uppercase tracking-[0.12em] text-[#d8d0c3]/68">
+ <span>{entry.role === "user" ? "you" : "codex"}</span>
+ <span>{formatTimestamp(entry.createdAt)}</span>
+ </header>
+ <pre className="whitespace-pre-wrap break-words font-mono text-sm leading-6">
+ {entry.text || (entry.streaming ? "..." : "(empty response)")}
+ </pre>
+ </div>
+ ))}
</div>
- ) : null}
-
- {history.map((entry) => (
- <article
- key={entry.id}
- className="overflow-hidden rounded-2xl border border-slate-700 bg-slate-950 shadow-soft"
- >
- <header className="flex items-center justify-between border-b border-slate-800 px-4 py-3 font-mono text-xs text-slate-300">
- <p>$ {entry.command}</p>
- <p>{formatTimestamp(entry.createdAt)}</p>
- </header>
-
- <div className="space-y-3 px-4 py-4 font-mono text-sm">
- {entry.result.stdout ? (
- <div>
- <p className="mb-1 text-xs uppercase tracking-wide text-emerald-300">
- stdout
- </p>
- <pre className="whitespace-pre-wrap break-words text-emerald-100">
- {entry.result.stdout}
- </pre>
- </div>
- ) : null}
-
- {entry.result.stderr ? (
- <div>
- <p className="mb-1 text-xs uppercase tracking-wide text-rose-300">
- stderr
- </p>
- <pre className="whitespace-pre-wrap break-words text-rose-200">
- {entry.result.stderr}
- </pre>
- </div>
- ) : null}
-
- {!entry.result.stdout && !entry.result.stderr ? (
- <p className="text-slate-400">(no output)</p>
- ) : null}
+
+ <form className="mt-4 grid gap-3" onSubmit={onSendPrompt}>
+ <textarea
+ className="field-input min-h-28 resize-y font-mono text-sm leading-6"
+ value={prompt}
+ onChange={(event) => setPrompt(event.target.value)}
+ placeholder="Ask Codex to inspect, plan, or edit this project..."
+ disabled={phase === "disconnected" || isSending}
+ />
+ <div className="flex gap-2">
+ <button
+ type="submit"
+ className="action-button action-primary"
+ disabled={phase === "disconnected" || isSending}
+ >
+ {isSending ? "Starting turn..." : "Send"}
+ </button>
+ <button
+ type="button"
+ className="action-button action-muted"
+ disabled={phase !== "running"}
+ onClick={() => void onInterrupt()}
+ >
+ Interrupt
+ </button>
</div>
+ </form>
+ </article>
- <footer className="border-t border-slate-800 bg-slate-900/60 px-4 py-2 font-mono text-xs text-slate-400">
- exit={entry.result.code ?? "null"} signal=
- {entry.result.signal ?? "null"} timedOut=
- {entry.result.timedOut ? "yes" : "no"}
- </footer>
- </article>
- ))}
+ <aside className="surface-card rounded-3xl p-4 sm:p-5">
+ <h2 className="text-xl">Protocol stream</h2>
+ <p className="mt-2 text-xs text-[#d8d0c3]/76">
+ Live notifications from the app-server (latest first).
+ </p>
+ <div className="mt-4 max-h-[58vh] space-y-2 overflow-y-auto pr-1">
+ {events.length === 0 ? (
+ <p className="rounded-xl border border-dashed border-[#f6d79e]/30 bg-[#0d1827]/70 px-3 py-4 text-xs text-[#d8d0c3]/76">
+ Waiting for events...
+ </p>
+ ) : null}
+ {events.map((entry) => (
+ <div key={entry.id} className="event-card">
+ <p className="font-mono text-[11px] uppercase tracking-[0.12em] text-[#f8ca64]">
+ {entry.method}
+ </p>
+ {entry.message ? (
+ <p className="mt-1 text-xs text-[#efe8d7]/88">
+ {entry.message}
+ </p>
+ ) : null}
+ <p className="mt-2 text-[11px] text-[#d8d0c3]/66">
+ {formatTimestamp(entry.createdAt)}
+ {entry.turnId ? ` · ${entry.turnId}` : ""}
+ </p>
+ </div>
+ ))}
+ </div>
+ </aside>
</section>
</main>
);
diff --git a/apps/renderer/src/index.css b/apps/renderer/src/index.css
index 258af8d75..ceb67ea26 100644
--- a/apps/renderer/src/index.css
+++ b/apps/renderer/src/index.css
@@ -1,3 +1,4 @@
+@import url("https://fonts.googleapis.com/css2?family=Fraunces:opsz,[email protected],400;9..144,600;9..144,700&family=IBM+Plex+Mono:wght@400;500;600&display=swap");
@import "tailwindcss";
@theme {
@@ -5,14 +6,160 @@
}
:root {
- color-scheme: light;
+ color-scheme: dark;
}
body {
- font-family: "Iowan Old Style", "Georgia", serif;
+ font-family: "Fraunces", "Iowan Old Style", serif;
min-height: 100vh;
- background:
- radial-gradient(circle at top left, #d1fae5 0%, transparent 38%),
- radial-gradient(circle at 88% 20%, #fef3c7 0%, transparent 28%),
- linear-gradient(130deg, #f8fafc 0%, #eef6f2 50%, #f8fafc 100%);
+ color: #f3f0e9;
+ background: radial-gradient(circle at 8% 3%, #e69f15 0%, transparent 33%),
+ radial-gradient(circle at 92% 6%, #2d8ba8 0%, transparent 30%),
+ linear-gradient(160deg, #050913 0%, #091320 42%, #090f1a 100%);
+}
+
+pre,
+code,
+textarea,
+input,
+select {
+ font-family: "IBM Plex Mono", "SFMono-Regular", Consolas, monospace;
+}
+
+.surface-card {
+ border: 1px solid rgba(246, 215, 158, 0.24);
+ background: linear-gradient(
+ 140deg,
+ rgba(11, 24, 40, 0.9),
+ rgba(9, 16, 29, 0.84)
+ ), radial-gradient(circle at top, rgba(245, 166, 35, 0.15), transparent 45%);
+ box-shadow: 0 28px 70px -45px rgba(0, 0, 0, 0.85), inset 0 1px 0
+ rgba(255, 255, 255, 0.08);
+}
+
+.grain {
+ opacity: 0.18;
+ mix-blend-mode: soft-light;
+ background-image: linear-gradient(
+ 45deg,
+ rgba(255, 255, 255, 0.04) 25%,
+ transparent 25%,
+ transparent 50%,
+ rgba(255, 255, 255, 0.04) 50%,
+ rgba(255, 255, 255, 0.04) 75%,
+ transparent 75%,
+ transparent
+ );
+ background-size: 4px 4px;
+}
+
+.label-chip {
+ display: inline-flex;
+ border-radius: 9999px;
+ border: 1px solid rgba(246, 215, 158, 0.44);
+ background: rgba(23, 38, 56, 0.55);
+ padding: 0.28rem 0.72rem;
+ font-size: 0.67rem;
+ letter-spacing: 0.14em;
+ text-transform: uppercase;
+ color: #f8ca64;
+}
+
+.field-label {
+ display: block;
+ margin-bottom: 0.32rem;
+ font-size: 0.67rem;
+ letter-spacing: 0.14em;
+ text-transform: uppercase;
+ color: rgba(246, 233, 201, 0.82);
+}
+
+.field-input {
+ width: 100%;
+ border-radius: 0.8rem;
+ border: 1px solid rgba(246, 215, 158, 0.3);
+ background: rgba(5, 12, 22, 0.85);
+ padding: 0.65rem 0.75rem;
+ color: #f7f1e6;
+ transition: border-color 140ms ease, box-shadow 140ms ease;
+}
+
+.field-input:focus {
+ outline: none;
+ border-color: rgba(250, 206, 99, 0.75);
+ box-shadow: 0 0 0 2px rgba(250, 206, 99, 0.18);
+}
+
+.action-button {
+ border-radius: 0.8rem;
+ padding: 0.62rem 0.9rem;
+ font-size: 0.8rem;
+ font-weight: 600;
+ letter-spacing: 0.08em;
+ text-transform: uppercase;
+ transition: filter 140ms ease, transform 140ms ease;
+}
+
+.action-button:disabled {
+ cursor: not-allowed;
+ opacity: 0.45;
+}
+
+.action-button:not(:disabled):hover {
+ filter: brightness(1.06);
+ transform: translateY(-1px);
+}
+
+.action-primary {
+ border: 1px solid rgba(250, 206, 99, 0.6);
+ background: linear-gradient(140deg, #f8c861, #e59f0d);
+ color: #1f2530;
+}
+
+.action-danger {
+ border: 1px solid rgba(252, 148, 124, 0.44);
+ background: linear-gradient(140deg, #8f2c2b, #bf4738);
+ color: #fff3ef;
+}
+
+.action-muted {
+ border: 1px solid rgba(149, 181, 205, 0.4);
+ background: rgba(13, 31, 49, 0.85);
+ color: #dfecfb;
+}
+
+.status-pill {
+ border-radius: 9999px;
+ border: 1px solid rgba(246, 215, 158, 0.29);
+ background: rgba(9, 20, 33, 0.9);
+ padding: 0.27rem 0.64rem;
+ font-family: "IBM Plex Mono", "SFMono-Regular", Consolas, monospace;
+ color: rgba(248, 235, 206, 0.86);
+}
+
+.message-card {
+ border-radius: 1rem;
+ border: 1px solid rgba(246, 215, 158, 0.25);
+ background: rgba(8, 16, 27, 0.82);
+ padding: 0.9rem;
+}
+
+.message-user {
+ border-color: rgba(111, 198, 238, 0.38);
+ background: linear-gradient(
+ 160deg,
+ rgba(14, 44, 64, 0.92),
+ rgba(8, 21, 36, 0.92)
+ );
+}
+
+.message-assistant {
+ border-color: rgba(250, 206, 99, 0.34);
+}
+
+.event-card {
+ border-radius: 0.85rem;
+ border: 1px solid rgba(246, 215, 158, 0.2);
+ background: rgba(8, 16, 27, 0.76);
+ padding: 0.62rem 0.72rem;
}
diff --git a/packages/contracts/src/index.ts b/packages/contracts/src/index.ts
index 11ba98210..f996b088f 100644
--- a/packages/contracts/src/index.ts
+++ b/packages/contracts/src/index.ts
@@ -2,3 +2,4 @@ export * from "./todo";
export * from "./ipc";
export * from "./agent";
export * from "./terminal";
+export * from "./provider";
diff --git a/packages/contracts/src/ipc.ts b/packages/contracts/src/ipc.ts
index b6f28a0cc..ee8ab264e 100644
--- a/packages/contracts/src/ipc.ts
+++ b/packages/contracts/src/ipc.ts
@@ -1,4 +1,13 @@
import type { AgentConfig, AgentExit, OutputChunk } from "./agent";
+import type {
+ ProviderEvent,
+ ProviderInterruptTurnInput,
+ ProviderSendTurnInput,
+ ProviderSession,
+ ProviderSessionStartInput,
+ ProviderStopSessionInput,
+ ProviderTurnStartResult,
+} from "./provider";
import type { TerminalCommandInput, TerminalCommandResult } from "./terminal";
import type { NewTodoInput, Todo } from "./todo";
@@ -13,6 +22,12 @@ export const IPC_CHANNELS = {
agentWrite: "agent:write",
agentOutput: "agent:output",
agentExit: "agent:exit",
+ providerSessionStart: "provider:session:start",
+ providerTurnStart: "provider:turn:start",
+ providerTurnInterrupt: "provider:turn:interrupt",
+ providerSessionStop: "provider:session:stop",
+ providerSessionList: "provider:session:list",
+ providerEvent: "provider:event",
} as const;
export interface NativeApi {
@@ -32,4 +47,16 @@ export interface NativeApi {
onOutput: (callback: (chunk: OutputChunk) => void) => () => void;
onExit: (callback: (exit: AgentExit) => void) => () => void;
};
+ providers: {
+ startSession: (
+ input: ProviderSessionStartInput,
+ ) => Promise<ProviderSession>;
+ sendTurn: (
+ input: ProviderSendTurnInput,
+ ) => Promise<ProviderTurnStartResult>;
+ interruptTurn: (input: ProviderInterruptTurnInput) => Promise<void>;
+ stopSession: (input: ProviderStopSessionInput) => Promise<void>;
+ listSessions: () => Promise<ProviderSession[]>;
+ onEvent: (callback: (event: ProviderEvent) => void) => () => void;
+ };
}
diff --git a/packages/contracts/src/provider.test.ts b/packages/contracts/src/provider.test.ts
new file mode 100644
index 000000000..9dd4fd9c3
--- /dev/null
+++ b/packages/contracts/src/provider.test.ts
@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+
+import {
+ providerEventSchema,
+ providerSendTurnInputSchema,
+ providerSessionStartInputSchema,
+} from "./provider";
+
+describe("providerSessionStartInputSchema", () => {
+ it("defaults to codex with safe policies", () => {
+ const parsed = providerSessionStartInputSchema.parse({});
+ expect(parsed.provider).toBe("codex");
+ expect(parsed.approvalPolicy).toBe("never");
+ expect(parsed.sandboxMode).toBe("workspace-write");
+ });
+});
+
+describe("providerSendTurnInputSchema", () => {
+ it("trims input text", () => {
+ const parsed = providerSendTurnInputSchema.parse({
+ sessionId: "sess_1",
+ input: " summarize this repo ",
+ });
+ expect(parsed.input).toBe("summarize this repo");
+ });
+});
+
+describe("providerEventSchema", () => {
+ it("accepts notification events with routing metadata", () => {
+ const parsed = providerEventSchema.parse({
+ id: "evt_1",
+ kind: "notification",
+ provider: "codex",
+ sessionId: "sess_1",
+ createdAt: "2026-01-01T00:00:00.000Z",
+ method: "item/agentMessage/delta",
+ threadId: "thr_1",
+ turnId: "turn_1",
+ itemId: "item_1",
+ textDelta: "hi",
+ });
+ expect(parsed.method).toBe("item/agentMessage/delta");
+ });
+});
diff --git a/packages/contracts/src/provider.ts b/packages/contracts/src/provider.ts
new file mode 100644
index 000000000..6dcbf7b45
--- /dev/null
+++ b/packages/contracts/src/provider.ts
@@ -0,0 +1,109 @@
+import { z } from "zod";
+
+export const providerKindSchema = z.enum(["codex", "claudeCode"]);
+
+export const providerApprovalPolicySchema = z.enum([
+ "untrusted",
+ "on-failure",
+ "on-request",
+ "never",
+]);
+
+export const providerSandboxModeSchema = z.enum([
+ "read-only",
+ "workspace-write",
+ "danger-full-access",
+]);
+
+export const providerSessionStatusSchema = z.enum([
+ "connecting",
+ "ready",
+ "running",
+ "error",
+ "closed",
+]);
+
+export const providerSessionSchema = z.object({
+ sessionId: z.string().min(1),
+ provider: providerKindSchema,
+ status: providerSessionStatusSchema,
+ cwd: z.string().min(1).optional(),
+ model: z.string().min(1).optional(),
+ threadId: z.string().min(1).optional(),
+ activeTurnId: z.string().min(1).optional(),
+ createdAt: z.string().datetime(),
+ updatedAt: z.string().datetime(),
+ lastError: z.string().min(1).optional(),
+});
+
+export const providerSessionStartInputSchema = z.object({
+ provider: providerKindSchema.default("codex"),
+ cwd: z.string().min(1).optional(),
+ model: z.string().trim().min(1).optional(),
+ approvalPolicy: providerApprovalPolicySchema.default("never"),
+ sandboxMode: providerSandboxModeSchema.default("workspace-write"),
+});
+
+export const providerSendTurnInputSchema = z.object({
+ sessionId: z.string().min(1),
+ input: z.string().trim().min(1).max(120_000),
+});
+
+export const providerTurnStartResultSchema = z.object({
+ threadId: z.string().min(1),
+ turnId: z.string().min(1),
+});
+
+export const providerInterruptTurnInputSchema = z.object({
+ sessionId: z.string().min(1),
+ turnId: z.string().min(1).optional(),
+});
+
+export const providerStopSessionInputSchema = z.object({
+ sessionId: z.string().min(1),
+});
+
+export const providerEventKindSchema = z.enum([
+ "session",
+ "notification",
+ "request",
+ "error",
+]);
+
+export const providerEventSchema = z.object({
+ id: z.string().min(1),
+ kind: providerEventKindSchema,
+ provider: providerKindSchema,
+ sessionId: z.string().min(1),
+ createdAt: z.string().datetime(),
+ method: z.string().min(1),
+ message: z.string().min(1).optional(),
+ threadId: z.string().min(1).optional(),
+ turnId: z.string().min(1).optional(),
+ itemId: z.string().min(1).optional(),
+ textDelta: z.string().optional(),
+ payload: z.unknown().optional(),
+});
+
+export type ProviderKind = z.infer<typeof providerKindSchema>;
+export type ProviderApprovalPolicy = z.infer<
+ typeof providerApprovalPolicySchema
+>;
+export type ProviderSandboxMode = z.infer<typeof providerSandboxModeSchema>;
+export type ProviderSessionStatus = z.infer<typeof providerSessionStatusSchema>;
+export type ProviderSession = z.infer<typeof providerSessionSchema>;
+export type ProviderSessionStartInput = z.input<
+ typeof providerSessionStartInputSchema
+>;
+export type ProviderSendTurnInput = z.input<typeof providerSendTurnInputSchema>;
+export type ProviderTurnStartResult = z.infer<
+ typeof providerTurnStartResultSchema
+>;
+export type ProviderInterruptTurnInput = z.input<
+ typeof providerInterruptTurnInputSchema
+>;
+export type ProviderStopSessionInput = z.input<
+ typeof providerStopSessionInputSchema
+>;
+export type ProviderEventKind = z.infer<typeof providerEventKindSchema>;
+export type ProviderEvent = z.infer<typeof providerEventSchema>;