remote-codex 0.11.1 → 0.11.2

package/bin/remote-codex-plugin-mcp.mjs

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+
+const MOLECULE_ARTIFACT_TYPE = 'chemistry.molecule3d';
+const XYZ_VIEWER_PLUGIN_ID = 'remote-codex.xyz-viewer';
+
+function isFiniteNumberToken(value) {
+  return typeof value === 'string' && value.trim() !== '' && Number.isFinite(Number(value));
+}
+
+function looksLikeXyzMolecule(content) {
+  const lines = content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const atomCount = Number(lines[0]);
+  if (!Number.isInteger(atomCount) || atomCount <= 0 || atomCount > 100000) {
+    return false;
+  }
+
+  const atomLines = lines.slice(2);
+  if (atomLines.length < atomCount) {
+    return false;
+  }
+
+  return atomLines.slice(0, atomCount).every((line) => {
+    const parts = line.split(/\s+/);
+    return (
+      parts.length >= 4 &&
+      /^([A-Za-z][A-Za-z]?|\d+)$/.test(parts[0] ?? '') &&
+      isFiniteNumberToken(parts[1]) &&
+      isFiniteNumberToken(parts[2]) &&
+      isFiniteNumberToken(parts[3])
+    );
+  });
+}
+
+function looksLikePdbMolecule(content) {
+  return content.split(/\r?\n/).some((line) => /^(ATOM|HETATM)\s+/i.test(line));
+}
+
+function looksLikeCifMolecule(content) {
+  return /\bdata_[^\s]*/i.test(content) && /_atom_site\./i.test(content);
+}
+
+function looksLikeMoleculeStructure(content, format) {
+  switch (format) {
+    case 'xyz':
+    case 'extxyz':
+      return looksLikeXyzMolecule(content);
+    case 'pdb':
+      return looksLikePdbMolecule(content);
+    case 'cif':
+      return looksLikeCifMolecule(content);
+    default:
+      return false;
+  }
+}
+
+function pluginEnabled(pluginId) {
+  const enabledIds = process.env.REMOTE_CODEX_ENABLED_PLUGIN_IDS;
+  if (!enabledIds) {
+    return true;
+  }
+  return enabledIds.split(',').map((entry) => entry.trim()).filter(Boolean).includes(pluginId);
+}
+
+const server = new McpServer({
+  name: 'remote-codex-plugin-mcp',
+  title: 'Remote Codex Plugin MCP',
+  version: '0.1.0',
+});
+
+if (pluginEnabled(XYZ_VIEWER_PLUGIN_ID)) {
+  server.registerTool(
+    'remote_codex_render_molecule',
+    {
+      title: 'Render 3D Molecule',
+      description:
+        'Create a Remote Codex 3D molecule artifact from valid xyz, extxyz, cif, or pdb content. Use this when the user asks for a renderable molecular structure. Do not invent coordinates unless the user explicitly asks you to generate an example.',
+      inputSchema: {
+        title: z.string().trim().min(1).describe('Short display title for the molecule.'),
+        format: z.enum(['xyz', 'extxyz', 'cif', 'pdb']).describe('Molecular source format.'),
+        content: z.string().trim().min(1).describe('Raw molecule source text in the selected format.'),
+        summaryText: z.string().trim().optional().describe('Optional short summary shown in the timeline.'),
+        sourceDescription: z.string().trim().optional().describe('Optional note about where the coordinates came from.'),
+      },
+    },
+    async ({ title, format, content, summaryText, sourceDescription }) => {
+      if (!looksLikeMoleculeStructure(content, format)) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: 'text',
+              text: `Unable to create molecule artifact: content does not look like valid ${format} data.`,
+            },
+          ],
+        };
+      }
+
+      const artifact = {
+        type: 'remote-codex.artifact',
+        artifactType: MOLECULE_ARTIFACT_TYPE,
+        title,
+        summaryText: summaryText ?? sourceDescription ?? `${format.toUpperCase()} molecule`,
+        payload: {
+          format,
+          content: [content],
+          name: title,
+          sourceDescription: sourceDescription ?? null,
+        },
+      };
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: [
+              `Created a 3D molecule artifact for ${title}.`,
+              '',
+              '```remote-codex-artifact',
+              JSON.stringify(artifact, null, 2),
+              '```',
+            ].join('\n'),
+          },
+        ],
+        structuredContent: {
+          pluginId: XYZ_VIEWER_PLUGIN_ID,
+          artifactType: MOLECULE_ARTIFACT_TYPE,
+          title,
+          format,
+        },
+      };
+    },
+  );
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  await server.connect(new StdioServerTransport());
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remote-codex",
-  "version": "0.11.1",
+  "version": "0.11.2",
   "description": "Local web supervisor for Codex workspaces and threads.",
   "license": "MIT",
   "type": "module",
@@ -20,12 +20,16 @@
     "packages/opencode/src/",
     "packages/db/src/",
     "packages/db/migrations/*.sql",
+    "packages/plugin-terminal/package.json",
+    "packages/plugin-terminal/plugin.json",
+    "packages/plugin-terminal/src/",
     "packages/shared/src/",
     "README.md"
   ],
   "packageManager": "pnpm@10.11.1",
   "pnpm": {
     "onlyBuiltDependencies": [
+      "@homebridge/node-pty-prebuilt-multiarch",
       "better-sqlite3",
       "esbuild"
     ]
@@ -56,6 +60,7 @@
   "dependencies": {
     "@fastify/multipart": "^9.0.3",
     "@fastify/websocket": "^11.0.2",
+    "@homebridge/node-pty-prebuilt-multiarch": "^0.13.1",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "better-sqlite3": "^12.10.0",
     "fastify": "^5.2.1",

package/packages/agent-runtime/src/types.ts

@@ -259,6 +259,7 @@ export interface StartAgentTurnInput {
   sandboxMode?: 'read-only' | 'workspace-write' | 'danger-full-access' | null;
   workspacePath?: string | null;
   performanceMode?: 'standard' | 'fast' | null;
+  developerInstructions?: string | null;
   hidden?: boolean;
   displayTurnId?: string | null;
 }

package/packages/agent-runtime/src/unavailable-runtime.ts

@@ -14,12 +14,7 @@ import type {
   AgentRuntime,
   AgentRuntimeManagementSchema,
   AgentRuntimeStatus,
-  InterruptAgentTurnInput,
-  ReadAgentSessionOptions,
-  ResumeAgentSessionInput,
-  StartAgentSessionInput,
   StartAgentSessionResult,
-  StartAgentTurnInput,
 } from './types';
 import { AgentRuntimeError } from './types';
 
@@ -136,26 +131,23 @@ export class UnavailableRuntimeAdapter extends EventEmitter implements AgentRunt
     return [];
   }
 
-  async readSession(
-    _providerSessionId: string,
-    _options?: ReadAgentSessionOptions,
-  ): Promise<AgentSessionDetail> {
+  async readSession(): Promise<AgentSessionDetail> {
     throw this.unavailableError();
   }
 
-  async startSession(_input: StartAgentSessionInput): Promise<StartAgentSessionResult> {
+  async startSession(): Promise<StartAgentSessionResult> {
     throw this.unavailableError();
   }
 
-  async resumeSession(_input: ResumeAgentSessionInput): Promise<StartAgentSessionResult> {
+  async resumeSession(): Promise<StartAgentSessionResult> {
     throw this.unavailableError();
   }
 
-  async startTurn(_input: StartAgentTurnInput): Promise<AgentTurn> {
+  async startTurn(): Promise<AgentTurn> {
     throw this.unavailableError();
   }
 
-  async interruptTurn(_input: InterruptAgentTurnInput): Promise<AgentTurn | null> {
+  async interruptTurn(): Promise<AgentTurn | null> {
     throw this.unavailableError();
   }
 

package/packages/claude/src/runtimeAdapter.ts

@@ -44,7 +44,6 @@ import {
   hiddenInitPrompt,
   isHiddenContinuationMessage,
   isHiddenInitMessage,
-  messageContentText,
   partialReasoningDelta,
   partialTextDelta,
   resultForToolUse,
@@ -172,11 +171,11 @@ interface ClaudeQueryOptions {
   allowDangerouslySkipPermissions?: boolean;
   pathToClaudeCodeExecutable?: string;
 }
-interface GetSessionInfoOptions {}
+type GetSessionInfoOptions = Record<string, never>;
 interface GetSessionMessagesOptions {
   includeSystemMessages?: boolean;
 }
-interface ListSessionsOptions {}
+type ListSessionsOptions = Record<string, never>;
 interface McpServerStatus {
   name: string;
   status: string;
@@ -1471,8 +1470,9 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
 
   mapProviderRequest(
     request: AgentProviderRequest,
-    _options: { approvalMode: 'yolo' | 'guarded' },
+    options: { approvalMode: 'yolo' | 'guarded' },
   ): AgentProviderRequestMapping | null {
+    void options;
     return mapClaudeAskUserQuestionRequest(request);
   }
 
@@ -1483,7 +1483,9 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
     return buildClaudeProviderRequestResponse(pending, input);
   }
 
-  respondToProviderRequest(_id: string | number, _result: unknown) {
+  respondToProviderRequest(id: string | number, result: unknown) {
+    void id;
+    void result;
     // Claude Code's built-in AskUserQuestion arrives as transcripted tool use in
     // this SDK mode. The supervisor records the user's answer locally so the
     // interaction matches other backends, but there is no live JSON-RPC request

package/packages/codex/src/appServerManager.ts

@@ -463,13 +463,13 @@ export class CodexAppServerManager extends EventEmitter {
         input.serviceTier === undefined ? undefined : input.serviceTier,
       effort: input.effort ?? null,
       sandboxPolicy: input.sandboxPolicy ?? null,
-      collaborationMode: input.collaborationMode
+      collaborationMode: input.collaborationMode || input.developerInstructions
         ? {
-            mode: input.collaborationMode,
+            mode: input.collaborationMode ?? 'default',
             settings: {
               model: input.model ?? '',
               reasoning_effort: input.effort ?? null,
-              developer_instructions: null
+              developer_instructions: input.developerInstructions ?? null
             }
           }
         : null

package/packages/codex/src/historyItems.test.ts

@@ -30,9 +30,7 @@ describe('codex history item persistence policy', () => {
       text: 'Streaming draft',
     });
 
-    expect(shouldPersistRuntimeFinalHistoryItem(transientMessage, [transientMessage])).toBe(
-      false,
-    );
+    expect(shouldPersistRuntimeFinalHistoryItem(transientMessage)).toBe(false);
   });
 
   it('hides transient streamed assistant text once a final assistant message exists', () => {
@@ -54,7 +52,7 @@ describe('codex history item persistence policy', () => {
         error: null,
         items: [transientMessage, finalMessage],
       }).items,
-    ).toEqual([finalMessage]);
+    ).toEqual([{ ...finalMessage, transcriptOrder: 0 }]);
   });
 
   it('maps Codex collab agent tool calls to dedicated agent tool call items', () => {

package/packages/codex/src/historyItems.ts

@@ -435,7 +435,6 @@ export function shouldPersistFinalHistoryItem(item: ThreadHistoryItemDto) {
 
 export function shouldPersistRuntimeFinalHistoryItem(
   item: ThreadHistoryItemDto,
-  allItems: ThreadHistoryItemDto[],
 ) {
   if (item.kind === 'agentMessage' && isTransientAgentHistoryItem(item)) {
     return false;
@@ -485,18 +484,7 @@ function historyItemSequence(item: ThreadHistoryItemDto) {
 }
 
 export function sortHistoryItemsBySequence<T extends ThreadHistoryItemDto>(items: T[]): T[] {
-  if (!items.some(hasHistoryItemSequence)) {
-    return items;
-  }
-
-  return items
-    .map((item, index) => ({ item, index }))
-    .sort((left, right) => {
-      const sequenceDelta =
-        historyItemSequence(left.item) - historyItemSequence(right.item);
-      return sequenceDelta === 0 ? left.index - right.index : sequenceDelta;
-    })
-    .map((entry) => entry.item);
+  return sortTurnItemsByRecordedSequence(items) as T[];
 }
 
 function sortTurnItemsByRecordedSequence(items: ThreadHistoryItemDto[]) {
@@ -636,12 +624,15 @@ function copyPersistedSequence(
   item: ThreadHistoryItemDto,
   persistedItem: ThreadHistoryItemDto,
 ) {
-  if (!hasHistoryItemSequence(persistedItem)) {
-    return item;
+  let nextItem = item;
+  if (hasHistoryItemSequence(persistedItem)) {
+    const sequence = historyItemSequence(persistedItem);
+    if (nextItem.sequence !== sequence) {
+      nextItem = { ...nextItem, sequence };
+    }
   }
 
-  const sequence = historyItemSequence(persistedItem);
-  return item.sequence === sequence ? item : { ...item, sequence };
+  return nextItem;
 }
 
 function shouldAppendPersistedMissingItem(
@@ -1336,7 +1327,11 @@ export function agentTurnToThreadTurnDto(
     startedAt: turn.startedAt ?? parseUuidV7Timestamp(turn.providerTurnId),
     status: turn.status,
     error: turn.error?.message ?? null,
-    items: visibleRuntimeTurnItems(turn.items),
+    items: visibleRuntimeTurnItems(turn.items).map((item, transcriptIndex) =>
+      item.transcriptOrder === transcriptIndex
+        ? item
+        : { ...item, transcriptOrder: transcriptIndex },
+    ),
   };
 
   return deferredDetails ? deferLargeHistoryItemDetails(baseTurn, deferredDetails) : baseTurn;

package/packages/codex/src/runtime-errors.ts

@@ -27,11 +27,6 @@ export function unwrapCodexJsonRpcError(error: unknown): JsonRpcClientError | nu
   return null;
 }
 
-function isCodexRemoteError(error: unknown) {
-  const codexError = unwrapCodexJsonRpcError(error);
-  return codexError?.code === 'remote_error' ? codexError : null;
-}
-
 export function isCodexRuntimeRequestError(error: unknown) {
   return Boolean(unwrapCodexJsonRpcError(error)) || isRuntimeRequestError(error);
 }

package/packages/codex/src/runtimeAdapter.ts

@@ -667,6 +667,9 @@ export class CodexRuntimeAdapter extends EventEmitter implements AgentRuntime {
     if (input.collaborationMode !== undefined) {
       turnInput.collaborationMode = input.collaborationMode;
     }
+    if (input.developerInstructions !== undefined) {
+      turnInput.developerInstructions = input.developerInstructions;
+    }
     const sandboxPolicy = buildSandboxPolicy(input.sandboxMode, input.workspacePath);
     if (sandboxPolicy !== undefined) {
       turnInput.sandboxPolicy = sandboxPolicy;

package/packages/codex/src/types.ts

@@ -322,6 +322,7 @@ export interface TurnStartInput {
   collaborationMode?: CollaborationModeKind | null;
   sandboxPolicy?: SandboxPolicy | null;
   serviceTier?: ServiceTier | null;
+  developerInstructions?: string | null;
 }
 
 export interface TurnSteerInput {

package/packages/db/migrations/0018_shell_session_label.sql

@@ -0,0 +1 @@
+ALTER TABLE shell_sessions ADD COLUMN label TEXT;

package/packages/db/src/repositories.ts

@@ -124,12 +124,14 @@ export interface UpsertThreadGoalRecordInput {
 export interface CreateShellSessionRecordInput {
   workspaceId: string;
   threadId: string | null;
+  label?: string | null;
   tmuxSessionName: string;
   cwd: string;
   status: string;
 }
 
 export interface UpdateShellSessionRecordInput {
+  label?: string | null;
   tmuxSessionName?: string;
   cwd?: string;
   status?: string;
@@ -809,6 +811,15 @@ export function getShellSessionRecordByThreadId(db: DatabaseClient, threadId: st
   return db.select().from(shellSessions).where(eq(shellSessions.threadId, threadId)).get();
 }
 
+export function listShellSessionRecordsByThreadId(db: DatabaseClient, threadId: string) {
+  return db
+    .select()
+    .from(shellSessions)
+    .where(eq(shellSessions.threadId, threadId))
+    .orderBy(desc(shellSessions.lastActivityAt), desc(shellSessions.createdAt))
+    .all();
+}
+
 export function createShellSessionRecord(
   db: DatabaseClient,
   input: CreateShellSessionRecordInput,
@@ -818,6 +829,7 @@ export function createShellSessionRecord(
     id: randomUUID(),
     workspaceId: input.workspaceId,
     threadId: input.threadId,
+    label: input.label ?? null,
     tmuxSessionName: input.tmuxSessionName,
     cwd: input.cwd,
     status: input.status,

package/packages/db/src/schema.ts

@@ -51,6 +51,7 @@ export const shellSessions = sqliteTable('shell_sessions', {
   id: text('id').primaryKey(),
   workspaceId: text('workspace_id').notNull(),
   threadId: text('thread_id'),
+  label: text('label'),
   tmuxSessionName: text('tmux_session_name'),
   cwd: text('cwd').notNull(),
   status: text('status'),

package/packages/opencode/src/historyItems.ts

@@ -266,23 +266,6 @@ function fileChangeStatsFromMetadata(metadata: unknown) {
   };
 }
 
-function todoSummary(input: unknown, output: string | null) {
-  const todos = isRecord(input) && Array.isArray(input.todos)
-    ? input.todos
-    : null;
-  if (!todos) {
-    return output ?? toolSummary(input);
-  }
-  const counts = new Map<string, number>();
-  todos.forEach((todo) => {
-    const status = isRecord(todo) ? stringValue(todo.status) ?? 'unknown' : 'unknown';
-    counts.set(status, (counts.get(status) ?? 0) + 1);
-  });
-  return Array.from(counts.entries())
-    .map(([status, count]) => `${count} ${status}`)
-    .join(', ');
-}
-
 function todoRecordsFromValue(value: unknown): unknown[] | null {
   if (Array.isArray(value)) {
     return value;

package/packages/plugin-terminal/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@remote-codex/plugin-terminal",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "lint": "eslint src --ext .ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "devDependencies": {
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.3"
+  }
+}

package/packages/plugin-terminal/plugin.json

@@ -0,0 +1,25 @@
+{
+  "id": "remote-codex.terminal",
+  "name": "Terminal",
+  "version": "0.1.0",
+  "description": "Built-in durable terminal panel backed by the supervisor PTY host.",
+  "remoteCodex": "^0.11.0",
+  "capabilities": {
+    "artifactTypes": [],
+    "timelineRenderers": [],
+    "threadPanels": [
+      {
+        "id": "terminal",
+        "label": "Terminal",
+        "kind": "terminal",
+        "artifactTypes": []
+      }
+    ],
+    "frontend": {
+      "entry": "./dist/index.js"
+    },
+    "backend": {
+      "entry": "./dist/backend.js"
+    }
+  }
+}

package/packages/plugin-terminal/src/index.ts

@@ -0,0 +1,2 @@
+export { TERMINAL_PLUGIN_ID, terminalPluginManifest } from './manifest';
+export type { TerminalPluginManifest } from './manifest';

package/packages/plugin-terminal/src/manifest.ts

@@ -0,0 +1,51 @@
+export const TERMINAL_PLUGIN_ID = 'remote-codex.terminal';
+
+export interface TerminalPluginManifest {
+  id: typeof TERMINAL_PLUGIN_ID;
+  name: string;
+  version: string;
+  description: string;
+  remoteCodex: string;
+  capabilities: {
+    artifactTypes: [];
+    timelineRenderers: [];
+    threadPanels: Array<{
+      id: 'terminal';
+      label: string;
+      kind: 'terminal';
+      artifactTypes: [];
+    }>;
+    frontend: {
+      entry: string;
+    };
+    backend: {
+      entry: string;
+    };
+  };
+}
+
+export const terminalPluginManifest: TerminalPluginManifest = {
+  id: TERMINAL_PLUGIN_ID,
+  name: 'Terminal',
+  version: '0.1.0',
+  description: 'Built-in durable terminal panel backed by the supervisor PTY host.',
+  remoteCodex: '^0.11.0',
+  capabilities: {
+    artifactTypes: [],
+    timelineRenderers: [],
+    threadPanels: [
+      {
+        id: 'terminal',
+        label: 'Terminal',
+        kind: 'terminal',
+        artifactTypes: [],
+      },
+    ],
+    frontend: {
+      entry: './dist/index.js',
+    },
+    backend: {
+      entry: './dist/backend.js',
+    },
+  },
+};

package/packages/shared/src/index.ts

@@ -290,6 +290,40 @@ export interface WorkspaceTreeDto {
   nodes: WorkspaceTreeNodeDto[];
 }
 
+export interface ThreadWorkspaceTreeNodeDto {
+  name: string;
+  path: string;
+  kind: 'file' | 'directory';
+  size?: number;
+  children?: ThreadWorkspaceTreeNodeDto[];
+}
+
+export interface ThreadWorkspaceFilePreviewDto {
+  path: string;
+  name: string;
+  content: string;
+  language: string;
+  size: number;
+  truncated: boolean;
+  nextOffset: number;
+}
+
+export type ThreadWorkspaceUploadResultDto =
+  | {
+      kind: 'file';
+      file: {
+        path: string;
+        name: string;
+        size: number;
+      };
+    }
+  | {
+      kind: 'archive';
+      archiveName: string;
+      extractedCount: number;
+      paths: string[];
+    };
+
 export type ApprovalMode = 'yolo' | 'guarded';
 export type ReasoningEffortDto = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
 export type CollaborationModeDto = 'default' | 'plan';
@@ -421,13 +455,29 @@ export interface PluginArtifactTypeDto {
 export interface PluginThreadPanelDto {
   id: string;
   label: string;
+  kind?: 'artifact' | 'terminal' | string;
   artifactTypes: string[];
 }
 
+export interface PluginModelHintDto {
+  id: string;
+  text: string;
+}
+
+export interface PluginMcpServerDto {
+  id: string;
+  name: string;
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
 export interface PluginCapabilitiesDto {
   artifactTypes: PluginArtifactTypeDto[];
   timelineRenderers: string[];
   threadPanels: PluginThreadPanelDto[];
+  modelHints?: PluginModelHintDto[];
+  mcpServers?: PluginMcpServerDto[];
   frontend?: {
     entry?: string;
     style?: string;
@@ -812,7 +862,9 @@ export interface ShellSessionDto {
   id: string;
   threadId: string;
   workspaceId: string;
+  label: string | null;
   tmuxSessionName: string;
+  backend: 'pty' | 'tmux' | string;
   cwd: string;
   status: Exclude<ShellStatusDto, 'not_created' | 'workspace_missing'>;
   attachedViewerId: string | null;
@@ -827,11 +879,18 @@ export interface ThreadShellStateDto {
   workspacePathStatus: 'present' | 'missing';
   state: ShellStatusDto;
   shell: ShellSessionDto | null;
+  shells: ShellSessionDto[];
+  activeShellId: string | null;
 }
 
 export interface ShellCreateInput {
   cols?: number;
   rows?: number;
+  label?: string;
+}
+
+export interface UpdateShellInput {
+  label?: string | null;
 }
 
 export interface ShellAttachInput {