remote-codex 0.1.6 → 0.1.8

package/packages/codex/src/types.ts

@@ -0,0 +1,403 @@
+export type JsonRpcId = number;
+
+export interface JsonRpcRequest<TParams = unknown> {
+  jsonrpc: '2.0';
+  id: JsonRpcId;
+  method: string;
+  params?: TParams;
+}
+
+export interface JsonRpcSuccess<TResult = unknown> {
+  jsonrpc?: '2.0';
+  id: JsonRpcId;
+  result: TResult;
+}
+
+export interface JsonRpcFailure {
+  jsonrpc?: '2.0';
+  id: JsonRpcId;
+  error: {
+    code: number;
+    message: string;
+    data?: unknown;
+  };
+}
+
+export interface JsonRpcNotification<TParams = unknown> {
+  jsonrpc?: '2.0';
+  method: string;
+  params: TParams;
+}
+
+export interface CodexClientInfo {
+  name: string;
+  title: string;
+  version: string;
+}
+
+export interface AppServerStatusSnapshot {
+  state: 'starting' | 'ready' | 'degraded' | 'stopped' | 'failed';
+  transport: 'stdio';
+  lastStartedAt: string | null;
+  lastError: string | null;
+  restartCount: number;
+}
+
+export interface CodexModelRecord {
+  id: string;
+  model: string;
+  displayName: string;
+  description: string;
+  hidden: boolean;
+  isDefault: boolean;
+  supportedReasoningEfforts: Array<{
+    reasoningEffort: ReasoningEffort;
+    description: string;
+  }>;
+  defaultReasoningEffort: ReasoningEffort;
+}
+
+export type ReasoningEffort =
+  | 'none'
+  | 'minimal'
+  | 'low'
+  | 'medium'
+  | 'high'
+  | 'xhigh';
+
+export type CollaborationModeKind = 'default' | 'plan';
+export type SandboxMode = 'read-only' | 'workspace-write' | 'danger-full-access';
+export type ServiceTier = 'fast' | 'flex';
+export type SkillScope = 'user' | 'repo' | 'system' | 'admin';
+export type McpAuthStatus = 'unsupported' | 'notLoggedIn' | 'bearerToken' | 'oAuth';
+export type ThreadGoalStatus = 'active' | 'paused' | 'budgetLimited' | 'complete';
+export type NetworkAccess = 'restricted' | 'enabled';
+export type ReadOnlyAccess =
+  | {
+      type: 'restricted';
+      includePlatformDefaults: boolean;
+      readableRoots: string[];
+    }
+  | {
+      type: 'fullAccess';
+    };
+export type SandboxPolicy =
+  | {
+      type: 'dangerFullAccess';
+    }
+  | {
+      type: 'readOnly';
+      access: ReadOnlyAccess;
+      networkAccess: boolean;
+    }
+  | {
+      type: 'externalSandbox';
+      networkAccess: NetworkAccess;
+    }
+  | {
+      type: 'workspaceWrite';
+      writableRoots: string[];
+      readOnlyAccess: ReadOnlyAccess;
+      networkAccess: boolean;
+      excludeTmpdirEnvVar: boolean;
+      excludeSlashTmp: boolean;
+    };
+
+export type CodexThreadStatus =
+  | { type: 'notLoaded' }
+  | { type: 'idle' }
+  | { type: 'systemError' }
+  | { type: 'active'; activeFlags: string[] };
+
+export type CodexTurnStatus = 'completed' | 'interrupted' | 'failed' | 'inProgress';
+
+export interface CodexTurnItem {
+  type: string;
+  id: string;
+  text?: string;
+  phase?: string | null;
+  content?: Array<{ type: string; text?: string }>;
+  summary?: string[];
+  command?: string;
+  aggregatedOutput?: string | null;
+  query?: string;
+  queries?: string[];
+  action?: unknown;
+  result?: unknown;
+  sources?: unknown;
+  status?: string | null;
+  changes?: unknown[];
+  [key: string]: unknown;
+}
+
+export interface CodexTurnRecord {
+  id: string;
+  status: CodexTurnStatus;
+  error: { message?: string } | null;
+  items: CodexTurnItem[];
+}
+
+export interface CodexThreadRecord {
+  id: string;
+  preview: string;
+  createdAt: number;
+  updatedAt: number;
+  status: CodexThreadStatus;
+  cwd: string;
+  name: string | null;
+  turns: CodexTurnRecord[];
+}
+
+export interface CodexSkillRecord {
+  name: string;
+  description: string;
+  shortDescription: string | null;
+  interface: {
+    displayName: string | null;
+    shortDescription: string | null;
+    brandColor: string | null;
+    defaultPrompt: string | null;
+  } | null;
+  path: string;
+  scope: SkillScope;
+  enabled: boolean;
+}
+
+export interface CodexSkillErrorRecord {
+  path: string;
+  message: string;
+}
+
+export interface CodexSkillsListEntry {
+  cwd: string;
+  skills: CodexSkillRecord[];
+  errors: CodexSkillErrorRecord[];
+}
+
+export interface CodexMcpToolRecord {
+  name: string;
+  title: string | null;
+  description: string | null;
+}
+
+export interface CodexMcpServerRecord {
+  name: string;
+  authStatus: McpAuthStatus;
+  tools: CodexMcpToolRecord[];
+  resourceCount: number;
+  resourceTemplateCount: number;
+}
+
+export type CodexHookEventName =
+  | 'preToolUse'
+  | 'permissionRequest'
+  | 'postToolUse'
+  | 'preCompact'
+  | 'postCompact'
+  | 'sessionStart'
+  | 'userPromptSubmit'
+  | 'stop';
+export type CodexHookHandlerType = 'command' | 'prompt' | 'agent';
+export type CodexHookSource =
+  | 'system'
+  | 'user'
+  | 'project'
+  | 'mdm'
+  | 'sessionFlags'
+  | 'plugin'
+  | 'cloudRequirements'
+  | 'legacyManagedConfigFile'
+  | 'legacyManagedConfigMdm'
+  | 'unknown';
+export type CodexHookTrustStatus = 'managed' | 'untrusted' | 'trusted' | 'modified';
+export type CodexHookRunStatus = 'running' | 'completed' | 'failed' | 'blocked' | 'stopped';
+export type CodexHookExecutionMode = 'sync' | 'async';
+export type CodexHookScope = 'thread' | 'turn';
+export type CodexHookOutputEntryKind = 'warning' | 'stop' | 'feedback' | 'context' | 'error';
+
+export interface CodexHookRecord {
+  key: string;
+  eventName: CodexHookEventName;
+  handlerType: CodexHookHandlerType;
+  matcher: string | null;
+  command: string | null;
+  timeoutSec: number;
+  statusMessage: string | null;
+  sourcePath: string;
+  source: CodexHookSource;
+  pluginId: string | null;
+  displayOrder: number;
+  enabled: boolean;
+  isManaged: boolean;
+  currentHash: string;
+  trustStatus: CodexHookTrustStatus;
+}
+
+export interface CodexHookErrorRecord {
+  path: string;
+  message: string;
+}
+
+export interface CodexHooksListEntry {
+  cwd: string;
+  hooks: CodexHookRecord[];
+  warnings: string[];
+  errors: CodexHookErrorRecord[];
+}
+
+export interface CodexHookTrustInput {
+  key: string;
+  trustedHash: string | null;
+}
+
+export interface CodexHookOutputEntry {
+  kind: CodexHookOutputEntryKind;
+  text: string;
+}
+
+export interface CodexHookRunSummary {
+  id: string;
+  eventName: CodexHookEventName;
+  handlerType: CodexHookHandlerType;
+  executionMode: CodexHookExecutionMode;
+  scope: CodexHookScope;
+  sourcePath: string;
+  source: CodexHookSource;
+  displayOrder: number;
+  status: CodexHookRunStatus;
+  statusMessage: string | null;
+  startedAt: number;
+  completedAt: number | null;
+  durationMs: number | null;
+  entries: CodexHookOutputEntry[];
+  stdout?: string | null;
+  stderr?: string | null;
+  output?: string | null;
+  text?: string | null;
+  systemMessage?: string | null;
+  stopReason?: string | null;
+  reason?: string | null;
+}
+
+export interface CodexThreadGoalRecord {
+  threadId: string;
+  objective: string;
+  status: ThreadGoalStatus;
+  tokenBudget: number | null;
+  tokensUsed: number;
+  timeUsedSeconds: number;
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface ThreadStartInput {
+  cwd: string;
+  model: string;
+  approvalPolicy: 'never' | 'on-request';
+  sandbox?: SandboxMode | null;
+  serviceTier?: ServiceTier | null;
+}
+
+export interface ThreadResumeInput {
+  threadId: string;
+  model?: string | null;
+  sandbox?: SandboxMode | null;
+  serviceTier?: ServiceTier | null;
+}
+
+export interface ThreadForkInput {
+  threadId: string;
+}
+
+export interface ThreadRollbackInput {
+  threadId: string;
+  count: number;
+}
+
+export interface TurnStartInput {
+  threadId: string;
+  prompt: string;
+  model?: string | null;
+  effort?: ReasoningEffort | null;
+  collaborationMode?: CollaborationModeKind | null;
+  sandboxPolicy?: SandboxPolicy | null;
+  serviceTier?: ServiceTier | null;
+}
+
+export interface TurnSteerInput {
+  threadId: string;
+  turnId: string;
+  prompt: string;
+}
+
+export interface ThreadCompactInput {
+  threadId: string;
+}
+
+export interface ThreadGoalSetInput {
+  threadId: string;
+  objective?: string | null;
+  status?: ThreadGoalStatus | null;
+  tokenBudget?: number | null;
+}
+
+export interface CodexServerRequest {
+  method: string;
+  id: number;
+  params: Record<string, unknown>;
+}
+
+export interface CodexTurnStartedEvent {
+  threadId: string;
+  turnId: string;
+}
+
+export interface CodexOutputDeltaEvent {
+  threadId: string;
+  turnId: string;
+  itemId: string;
+  delta: string;
+}
+
+export interface CodexTokenUsageBreakdown {
+  totalTokens: number;
+  inputTokens: number;
+  cachedInputTokens: number;
+  outputTokens: number;
+  reasoningOutputTokens: number;
+}
+
+export interface CodexThreadTokenUsageEvent {
+  threadId: string;
+  turnId: string;
+  tokenUsage: {
+    total: CodexTokenUsageBreakdown;
+    last: CodexTokenUsageBreakdown;
+    modelContextWindow: number | null;
+  };
+}
+
+export interface CodexErrorEvent {
+  threadId: string;
+  turnId: string;
+  message: string;
+  willRetry: boolean;
+}
+
+export type CodexServerEvent =
+  | { method: 'thread/started'; params: { thread: CodexThreadRecord } }
+  | { method: 'thread/status/changed'; params: { threadId: string; status: CodexThreadStatus } }
+  | { method: 'thread/name/updated'; params: { threadId: string; threadName?: string } }
+  | { method: 'thread/goal/updated'; params: { threadId: string; turnId: string | null; goal: CodexThreadGoalRecord } }
+  | { method: 'thread/goal/cleared'; params: { threadId: string } }
+  | { method: 'thread/tokenUsage/updated'; params: CodexThreadTokenUsageEvent }
+  | { method: 'turn/started'; params: { threadId: string; turn: CodexTurnRecord } }
+  | { method: 'hook/started'; params: { threadId: string; turnId: string | null; run: CodexHookRunSummary } }
+  | { method: 'hook/completed'; params: { threadId: string; turnId: string | null; run: CodexHookRunSummary } }
+  | { method: 'item/started'; params: { threadId: string; turnId: string; item: CodexTurnItem } }
+  | { method: 'item/completed'; params: { threadId: string; turnId: string; item: CodexTurnItem } }
+  | { method: 'turn/plan/updated'; params: { threadId: string; turnId: string; explanation: string | null; plan: Array<{ step: string; status: string }> } }
+  | { method: 'turn/completed'; params: { threadId: string; turn: CodexTurnRecord } }
+  | { method: 'item/agentMessage/delta'; params: CodexOutputDeltaEvent }
+  | { method: 'error'; params: { error: { message?: string }; willRetry: boolean; threadId: string; turnId: string } }
+  | { method: string; params: Record<string, unknown> };

package/packages/db/migrations/0015_agent_provider_fields.sql

@@ -0,0 +1,14 @@
+ALTER TABLE threads
+  ADD COLUMN provider TEXT NOT NULL DEFAULT 'codex';
+
+ALTER TABLE threads
+  ADD COLUMN provider_session_id TEXT;
+
+ALTER TABLE threads
+  ADD COLUMN provider_turn_id TEXT;
+
+UPDATE threads
+SET provider = 'codex',
+    provider_session_id = codex_thread_id,
+    provider_turn_id = codex_turn_id
+WHERE provider_session_id IS NULL;

package/packages/db/migrations/0016_remove_codex_thread_goal_id.sql

@@ -0,0 +1,46 @@
+CREATE TABLE `thread_goals_new` (
+  `id` text PRIMARY KEY NOT NULL,
+  `thread_id` text NOT NULL,
+  `provider_session_id` text NOT NULL,
+  `objective` text NOT NULL,
+  `status` text NOT NULL,
+  `token_budget` integer,
+  `tokens_used` integer DEFAULT 0 NOT NULL,
+  `time_used_seconds` integer DEFAULT 0 NOT NULL,
+  `started_at` text NOT NULL,
+  `completed_at` text,
+  `created_at` text NOT NULL,
+  `updated_at` text NOT NULL
+);
+
+INSERT INTO `thread_goals_new` (
+  `id`,
+  `thread_id`,
+  `provider_session_id`,
+  `objective`,
+  `status`,
+  `token_budget`,
+  `tokens_used`,
+  `time_used_seconds`,
+  `started_at`,
+  `completed_at`,
+  `created_at`,
+  `updated_at`
+)
+SELECT
+  `id`,
+  `thread_id`,
+  `codex_thread_id`,
+  `objective`,
+  `status`,
+  `token_budget`,
+  `tokens_used`,
+  `time_used_seconds`,
+  `started_at`,
+  `completed_at`,
+  `created_at`,
+  `updated_at`
+FROM `thread_goals`;
+
+DROP TABLE `thread_goals`;
+ALTER TABLE `thread_goals_new` RENAME TO `thread_goals`;

package/packages/db/migrations/0017_remove_codex_thread_columns.sql

@@ -0,0 +1,85 @@
+CREATE TABLE `threads_new` (
+  `id` text PRIMARY KEY NOT NULL,
+  `workspace_id` text NOT NULL,
+  `provider` text DEFAULT 'codex' NOT NULL,
+  `provider_session_id` text,
+  `provider_turn_id` text,
+  `source` text DEFAULT 'supervisor' NOT NULL,
+  `title` text NOT NULL,
+  `model` text,
+  `reasoning_effort` text,
+  `fast_mode` integer DEFAULT false NOT NULL,
+  `fast_base_model` text,
+  `fast_base_reasoning_effort` text,
+  `collaboration_mode` text DEFAULT 'default' NOT NULL,
+  `approval_mode` text,
+  `sandbox_mode` text,
+  `status` text,
+  `summary_text` text,
+  `last_error` text,
+  `created_at` text NOT NULL,
+  `updated_at` text NOT NULL,
+  `last_turn_started_at` text,
+  `last_turn_completed_at` text,
+  `last_viewed_at` text,
+  `is_pinned` integer DEFAULT false NOT NULL,
+  `is_connected` integer DEFAULT true NOT NULL
+);
+
+INSERT INTO `threads_new` (
+  `id`,
+  `workspace_id`,
+  `provider`,
+  `provider_session_id`,
+  `provider_turn_id`,
+  `source`,
+  `title`,
+  `model`,
+  `reasoning_effort`,
+  `fast_mode`,
+  `fast_base_model`,
+  `fast_base_reasoning_effort`,
+  `collaboration_mode`,
+  `approval_mode`,
+  `sandbox_mode`,
+  `status`,
+  `summary_text`,
+  `last_error`,
+  `created_at`,
+  `updated_at`,
+  `last_turn_started_at`,
+  `last_turn_completed_at`,
+  `last_viewed_at`,
+  `is_pinned`,
+  `is_connected`
+)
+SELECT
+  `id`,
+  `workspace_id`,
+  COALESCE(`provider`, 'codex'),
+  COALESCE(`provider_session_id`, `codex_thread_id`),
+  COALESCE(`provider_turn_id`, `codex_turn_id`),
+  `source`,
+  `title`,
+  `model`,
+  `reasoning_effort`,
+  `fast_mode`,
+  `fast_base_model`,
+  `fast_base_reasoning_effort`,
+  `collaboration_mode`,
+  `approval_mode`,
+  `sandbox_mode`,
+  `status`,
+  `summary_text`,
+  `last_error`,
+  `created_at`,
+  `updated_at`,
+  `last_turn_started_at`,
+  `last_turn_completed_at`,
+  `last_viewed_at`,
+  `is_pinned`,
+  `is_connected`
+FROM `threads`;
+
+DROP TABLE `threads`;
+ALTER TABLE `threads_new` RENAME TO `threads`;

package/packages/db/src/client.ts

@@ -0,0 +1,53 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import Database from 'better-sqlite3';
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+
+import * as schema from './schema';
+
+export type DatabaseClient = ReturnType<typeof drizzle<typeof schema>>;
+export type SqliteDatabase = Database.Database;
+
+export interface DatabaseContext {
+  sqlite: SqliteDatabase;
+  db: DatabaseClient;
+}
+
+function resolvePlatform(): string {
+  if (process.platform === 'darwin') {
+    return 'macos';
+  }
+
+  if (process.platform === 'linux') {
+    return os.release().toLowerCase().includes('microsoft') ? 'wsl-ubuntu' : 'linux';
+  }
+
+  return process.platform;
+}
+
+export function createDatabase(databaseUrl: string): DatabaseContext {
+  fs.mkdirSync(path.dirname(databaseUrl), { recursive: true });
+
+  const sqlite = new Database(databaseUrl);
+  sqlite.pragma('journal_mode = WAL');
+
+  return {
+    sqlite,
+    db: drizzle(sqlite, { schema })
+  };
+}
+
+export function getDefaultHostRecord() {
+  const now = new Date().toISOString();
+
+  return {
+    id: 'local-host',
+    hostname: os.hostname(),
+    platform: resolvePlatform(),
+    tailscaleName: null as string | null,
+    createdAt: now,
+    lastSeenAt: now
+  };
+}

package/packages/db/src/index.ts

@@ -0,0 +1,5 @@
+export * from './client';
+export * from './migrate';
+export * from './repositories';
+export * from './schema';
+export * from './seed';

package/packages/db/src/migrate.test.ts

@@ -0,0 +1,36 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { getMigrationsDir } from './migrate';
+
+describe('migrations', () => {
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it('prefers the active workspace migrations over an installed package root', async () => {
+    const installedRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'remote-codex-installed-root-'));
+    await fs.mkdir(path.join(installedRoot, 'packages', 'db', 'migrations'), { recursive: true });
+    vi.stubEnv('REMOTE_CODEX_PACKAGE_ROOT', installedRoot);
+
+    const workspaceDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remote-codex-workspace-root-'));
+    await fs.writeFile(path.join(workspaceDir, 'pnpm-workspace.yaml'), 'packages: []\n');
+    await fs.mkdir(path.join(workspaceDir, 'packages', 'db', 'migrations'), { recursive: true });
+
+    expect(getMigrationsDir(workspaceDir)).toBe(
+      path.join(workspaceDir, 'packages', 'db', 'migrations'),
+    );
+  });
+
+  it('resolves migrations from the installed package root outside a workspace', async () => {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remote-codex-package-root-'));
+    await fs.mkdir(path.join(tempDir, 'packages', 'db', 'migrations'), { recursive: true });
+    const outsideWorkspace = await fs.mkdtemp(path.join(os.tmpdir(), 'remote-codex-no-workspace-'));
+    vi.stubEnv('REMOTE_CODEX_PACKAGE_ROOT', tempDir);
+
+    expect(getMigrationsDir(outsideWorkspace)).toBe(path.join(tempDir, 'packages', 'db', 'migrations'));
+  });
+});