remote-codex 0.11.1 → 0.11.3

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/bin/remote-codex.mjs

@@ -9,6 +9,8 @@ const binDir = path.dirname(fileURLToPath(import.meta.url));
 const packageRoot = path.resolve(binDir, '..');
 const packageJsonPath = path.join(packageRoot, 'package.json');
 const serviceManagerPath = path.join(packageRoot, 'scripts', 'service-manager.mjs');
+const relayDistEntry = path.join(packageRoot, 'apps', 'relay-server', 'dist', 'index.js');
+const relaySourceEntry = path.join(packageRoot, 'apps', 'relay-server', 'src', 'index.ts');
 const sourceCheckout =
   fs.existsSync(path.join(packageRoot, 'pnpm-workspace.yaml')) &&
   fs.existsSync(path.join(packageRoot, 'scripts', 'service-restart.mjs'));
@@ -33,30 +35,74 @@ if (command === 'version') {
   process.exit(0);
 }
 
-if (!['start', 'stop', 'status'].includes(command)) {
+if (command === 'relay') {
+  runRelayServer();
+} else if (!['start', 'stop', 'status'].includes(command)) {
   printHelp();
   process.exit(command ? 1 : 0);
+} else {
+  const child = spawn(process.execPath, [serviceManagerPath, command], {
+    cwd: packageRoot,
+    env: process.env,
+    stdio: 'inherit',
+  });
+
+  child.on('exit', (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+
+    process.exit(code ?? 1);
+  });
+
+  child.on('error', (error) => {
+    console.error(`Failed to run remote-codex ${command}: ${error.message}`);
+    process.exit(1);
+  });
 }
 
-const child = spawn(process.execPath, [serviceManagerPath, command], {
-  cwd: packageRoot,
-  env: process.env,
-  stdio: 'inherit',
-});
+function runRelayServer() {
+  const relayEntry = fs.existsSync(relayDistEntry) ? relayDistEntry : relaySourceEntry;
+  let commandToRun = process.execPath;
+  let args = [relayEntry];
 
-child.on('exit', (code, signal) => {
-  if (signal) {
-    process.kill(process.pid, signal);
-    return;
+  if (!fs.existsSync(relayEntry)) {
+    console.error('Relay server build artifacts are missing. Run `pnpm build` before using `remote-codex relay`.');
+    console.error(`Missing: ${path.relative(packageRoot, relayDistEntry)}`);
+    process.exit(1);
   }
 
-  process.exit(code ?? 1);
-});
+  if (relayEntry === relaySourceEntry) {
+    const tsxEntry = path.join(packageRoot, 'node_modules', 'tsx', 'dist', 'cli.mjs');
+    if (!fs.existsSync(tsxEntry)) {
+      console.error('Relay server build artifacts are missing and tsx is not installed for source execution.');
+      console.error('Run `pnpm build` or install dependencies with `pnpm install`.');
+      process.exit(1);
+    }
+    args = [tsxEntry, relaySourceEntry];
+  }
 
-child.on('error', (error) => {
-  console.error(`Failed to run remote-codex ${command}: ${error.message}`);
-  process.exit(1);
-});
+  const relay = spawn(commandToRun, args, {
+    cwd: packageRoot,
+    env: process.env,
+    stdio: 'inherit',
+  });
+
+  relay.on('exit', (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+
+    process.exit(code ?? 1);
+  });
+
+  relay.on('error', (error) => {
+    console.error(`Failed to run remote-codex relay: ${error.message}`);
+    process.exit(1);
+  });
+}
 
 function normalizeCommand(value) {
   if (!value || value === '-h' || value === '--help') {
@@ -86,6 +132,7 @@ Usage:
   remote-codex start
   remote-codex status
   remote-codex stop
+  remote-codex relay
 
 Environment:
   SERVICE_HOST              Web listen host, default 127.0.0.1
@@ -93,5 +140,15 @@ Environment:
   SERVICE_API_HOST          API listen host, default 127.0.0.1
   SERVICE_API_PORT          API listen port, default ${defaultApiPort}
   REMOTE_CODEX_SERVICE_DIR  Service state and log directory, default ~/.remote-codex/service
+
+Relay:
+  REMOTE_CODEX_RELAY_SUPERVISOR_TOKEN       Legacy bootstrap token for supervisor tunnels
+  REMOTE_CODEX_ADMIN_USERNAME               Relay admin username
+  REMOTE_CODEX_ADMIN_PASSWORD               Relay admin password
+  REMOTE_CODEX_RELAY_DATA_DIR               Relay user/device store, default .local/relay-server
+  REMOTE_CODEX_RELAY_WEB_DIST_DIR           Web dist override, defaults to packaged supervisor-web/dist
+  REMOTE_CODEX_RELAY_REGISTRATION_ENABLED   true/false, default true
+  HOST                                      Relay listen host, default 0.0.0.0
+  PORT                                      Relay listen port, default 8788
 `);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remote-codex",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "description": "Local web supervisor for Codex workspaces and threads.",
   "license": "MIT",
   "type": "module",
@@ -12,6 +12,7 @@
     "scripts/service-manager.mjs",
     "scripts/run-web-service.mjs",
     "apps/supervisor-api/dist/",
+    "apps/relay-server/dist/",
     "apps/supervisor-web/dist/",
     "config/codex-model-pricing.json",
     "packages/agent-runtime/src/",
@@ -20,12 +21,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 +61,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';