remote-codex 0.1.10 → 0.11.0

package/packages/shared/src/agent-providers.ts

@@ -0,0 +1,56 @@
+export const agentBackendIds = ['codex', 'claude', 'opencode'] as const;
+
+export type AgentBackendIdDto = (typeof agentBackendIds)[number];
+
+export const defaultAgentBackendId: AgentBackendIdDto = 'codex';
+
+export interface AgentBackendMetadata {
+  displayName: string;
+  description: string;
+  defaultTransport: 'stdio' | 'sdk' | 'none';
+  homeEnvVar: string;
+  commandEnvVar: string;
+  defaultHomeDir: string;
+  defaultCommand: string;
+}
+
+export const agentBackendMetadata: Record<AgentBackendIdDto, AgentBackendMetadata> = {
+  codex: {
+    displayName: 'Codex',
+    description: 'Local Codex app-server runtime.',
+    defaultTransport: 'stdio',
+    homeEnvVar: 'CODEX_HOME',
+    commandEnvVar: 'CODEX_COMMAND',
+    defaultHomeDir: '.codex',
+    defaultCommand: 'codex',
+  },
+  claude: {
+    displayName: 'Claude Code',
+    description: 'Local Claude Code Agent SDK runtime.',
+    defaultTransport: 'sdk',
+    homeEnvVar: 'CLAUDE_HOME',
+    commandEnvVar: 'CLAUDE_COMMAND',
+    defaultHomeDir: '.claude',
+    defaultCommand: 'claude',
+  },
+  opencode: {
+    displayName: 'OpenCode',
+    description: 'Local OpenCode runtime.',
+    defaultTransport: 'sdk',
+    homeEnvVar: 'OPENCODE_HOME',
+    commandEnvVar: 'OPENCODE_COMMAND',
+    defaultHomeDir: '.opencode',
+    defaultCommand: 'opencode',
+  },
+};
+
+export function isAgentBackendId(value: unknown): value is AgentBackendIdDto {
+  return (
+    typeof value === 'string' &&
+    agentBackendIds.includes(value as AgentBackendIdDto)
+  );
+}
+
+export function normalizeAgentBackendId(value: unknown): AgentBackendIdDto | null {
+  return isAgentBackendId(value) ? value : null;
+}

package/packages/shared/src/index.ts

@@ -1,3 +1,19 @@
+import type {
+  AgentBackendIdDto,
+} from './agent-providers';
+
+export {
+  agentBackendIds,
+  agentBackendMetadata,
+  defaultAgentBackendId,
+  isAgentBackendId,
+  normalizeAgentBackendId,
+} from './agent-providers';
+export type {
+  AgentBackendIdDto,
+  AgentBackendMetadata,
+} from './agent-providers';
+
 export type ApiErrorCode =
   | 'bad_request'
   | 'not_found'
@@ -14,6 +30,26 @@ export interface ApiErrorShape {
   details?: Record<string, unknown>;
 }
 
+const AUTO_THREAD_TITLE_MAX_CHARS = 15;
+
+function normalizeAutoThreadTitleWhitespace(value: string) {
+  return value.replace(/\s+/g, ' ').trim();
+}
+
+export function truncateAutoThreadTitle(value: string) {
+  const normalized = normalizeAutoThreadTitleWhitespace(value);
+  if (!normalized) {
+    return '';
+  }
+
+  const characters = Array.from(normalized);
+  if (characters.length <= AUTO_THREAD_TITLE_MAX_CHARS) {
+    return normalized;
+  }
+
+  return `${characters.slice(0, AUTO_THREAD_TITLE_MAX_CHARS).join('')}...`;
+}
+
 export interface RuntimeConfigDto {
   appName: string;
   appVersion: string;
@@ -23,8 +59,6 @@ export interface RuntimeConfigDto {
   environment: string;
 }
 
-export type AgentBackendIdDto = 'codex' | 'claude';
-
 export interface AgentRuntimeStatusDto {
   state: 'starting' | 'ready' | 'degraded' | 'stopped' | 'failed';
   transport: 'stdio' | 'sdk' | 'none';
@@ -85,6 +119,18 @@ export interface AgentBackendDto {
   status: AgentRuntimeStatusDto;
   capabilities: AgentProviderCapabilitiesDto;
   managementSchema: AgentBackendManagementSchemaDto;
+  installation: AgentBackendInstallationDto;
+}
+
+export interface AgentBackendInstallationDto {
+  packageName: string | null;
+  installed: boolean;
+  installedVersion: string | null;
+  latestVersion: string | null;
+  installCommand: string | null;
+  updateCommand: string | null;
+  busy: boolean;
+  lastError: string | null;
 }
 
 export interface AgentBackendConfigFileSchemaDto {
@@ -133,8 +179,9 @@ export interface ModelOptionDto {
   description: string;
   isDefault: boolean;
   hidden: boolean;
+  supportsPerformanceMode?: boolean;
   supportedReasoningEfforts: ReasoningEffortOptionDto[];
-  defaultReasoningEffort: ReasoningEffortDto;
+  defaultReasoningEffort: ReasoningEffortDto | null;
 }
 
 export interface VersionDto {
@@ -318,6 +365,7 @@ export interface ThreadHistoryItemDto {
   detailText?: string | null;
   hasDeferredDetail?: boolean | null;
   sequence?: number | null;
+  sourceTurnId?: string | null;
   status?: string | null;
   assetPath?: string | null;
   changedFiles?: number | null;
@@ -795,40 +843,127 @@ export interface RespondThreadActionRequestInput {
   answers: Record<string, ThreadActionRequestAnswerDto>;
 }
 
-export interface ThreadEventEnvelope {
-  type:
-    | 'thread.updated'
-    | 'thread.context.updated'
-    | 'thread.goal.updated'
-    | 'thread.goal.cleared'
-    | 'thread.turn.token.updated'
-    | 'thread.turn.started'
-    | 'thread.item.started'
-    | 'thread.item.completed'
-    | 'thread.plan.updated'
-    | 'thread.request.created'
-    | 'thread.request.resolved'
-    | 'thread.output.delta'
-    | 'thread.turn.completed'
-    | 'thread.turn.failed';
-  threadId: string;
-  timestamp: string;
-  payload: Record<string, unknown>;
-}
-
-export interface ShellEventEnvelope {
-  type:
-    | 'shell.connected'
-    | 'shell.status'
-    | 'shell.output'
-    | 'shell.detached'
-    | 'shell.exited'
-    | 'shell.error';
-  shellId: string;
-  timestamp: string;
-  payload: Record<string, unknown>;
+export interface ThreadEventPayloadMap {
+  'thread.updated': {
+    status?: ThreadStatusDto | string | null;
+    title?: string | null;
+    reason?: string;
+    turnId?: string;
+    model?: string | null;
+    reasoningEffort?: ReasoningEffortDto | string | null;
+    fastMode?: boolean;
+    collaborationMode?: CollaborationModeDto | string | null;
+    sandboxMode?: SandboxModeDto | string | null;
+  };
+  'thread.context.updated': {
+    contextUsage: ThreadContextUsageDto;
+  };
+  'thread.goal.updated': {
+    turnId?: string | null;
+    goal: ThreadGoalDto | null;
+    goalHistory: ThreadGoalDto[];
+  };
+  'thread.goal.cleared': {
+    goalHistory: ThreadGoalDto[];
+  };
+  'thread.turn.token.updated': {
+    turnId: string;
+    tokenUsage: ThreadTurnTokenUsageDto;
+    priceEstimate: ThreadTurnPriceEstimateDto | null;
+  };
+  'thread.turn.started': {
+    turnId: string;
+  };
+  'thread.item.started': {
+    turnId: string;
+    item: ThreadHistoryItemDto;
+  };
+  'thread.item.completed': {
+    turnId: string;
+    item: ThreadHistoryItemDto;
+  };
+  'thread.plan.updated': {
+    turnId: string;
+    explanation: string | null;
+    plan: ThreadLivePlanDto['plan'];
+  };
+  'thread.request.created': {
+    request: ThreadActionRequestDto;
+  };
+  'thread.request.resolved': {
+    requestId: string;
+  };
+  'thread.output.delta': {
+    turnId: string;
+    itemId: string;
+    sequence: number;
+    delta: string;
+  };
+  'thread.turn.completed': {
+    turnId: string;
+    status: ThreadTurnDto['status'];
+    error: string | null;
+  };
+  'thread.turn.failed': {
+    turnId: string;
+    error: string | null;
+    willRetry?: boolean;
+  };
+}
+
+export type ThreadEventEnvelope = {
+  [Type in keyof ThreadEventPayloadMap]: {
+    type: Type;
+    threadId: string;
+    timestamp: string;
+    payload: ThreadEventPayloadMap[Type];
+  };
+}[keyof ThreadEventPayloadMap];
+
+export interface ShellEventPayloadMap {
+  'shell.connected': {
+    viewerId: string;
+  };
+  'shell.status': {
+    threadId: string;
+    state: ShellStatusDto;
+    viewerId?: string;
+  };
+  'shell.output': {
+    data: string;
+    replace?: boolean;
+    cursorX?: number;
+    cursorY?: number;
+    paneHeight?: number;
+    cwdBaseName?: string;
+    envPrefix?: string;
+    isCommandRunning?: boolean;
+  };
+  'shell.detached': {
+    threadId: string;
+    state: Extract<ShellStatusDto, 'detached'>;
+    viewerId: string;
+    reason?: string;
+  };
+  'shell.exited': {
+    threadId: string;
+    state: Extract<ShellStatusDto, 'exited' | 'not_found'>;
+  };
+  'shell.error': {
+    code: string;
+    message: string;
+  };
 }
 
+export type ShellEventEnvelope = {
+  [Type in keyof ShellEventPayloadMap]: {
+    type: Type;
+    shellId: string;
+    timestamp: string;
+    payload: ShellEventPayloadMap[Type];
+  };
+}[keyof ShellEventPayloadMap];
+
 export interface SupervisorConnectedEnvelope {
   type: 'supervisor.connected';
   timestamp: string;