@plimeor/harness 0.1.0 → 0.1.2

package/package.json

@@ -4,7 +4,7 @@
   "name": "@plimeor/harness",
   "type": "module",
   "types": "./src/index.ts",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "bugs": {
     "url": "https://github.com/plimeor/labs/issues"
   },

package/src/adapters/claude.ts

@@ -8,7 +8,7 @@ import type {
   StructuredOutputRequest,
   TextOutputRequest
 } from '../types'
-import { configDirectory, createExtensionFacet } from './extensions'
+import { configDirectory, createExtensionFacet, createJsonHooksDriver, createJsonMcpDriver } from './extensions'
 import { createBuiltInAdapter, planCommand, planTextCommand, unsupportedOutputMode } from './shared'
 
 const HARNESS_ID = 'claude'
@@ -25,44 +25,40 @@ export const claudeAdapter = createBuiltInAdapter({
       configDirectory: directory,
       context,
       harnessId: HARNESS_ID,
-      mcp: { configFile: `${directory}/mcp.json`, kind: 'claude-json' },
-      skillsDirectory: `${directory}/skills`,
-      hooks: {
-        kind: 'json-hooks',
-        settingsFile: `${directory}/settings.json`,
-        events: [
-          'SessionStart',
-          'Setup',
-          'UserPromptSubmit',
-          'UserPromptExpansion',
-          'PreToolUse',
-          'PermissionRequest',
-          'PermissionDenied',
-          'PostToolUse',
-          'PostToolUseFailure',
-          'PostToolBatch',
-          'Notification',
-          'MessageDisplay',
-          'SubagentStart',
-          'SubagentStop',
-          'TaskCreated',
-          'TaskCompleted',
-          'Stop',
-          'StopFailure',
-          'TeammateIdle',
-          'InstructionsLoaded',
-          'ConfigChange',
-          'CwdChanged',
-          'FileChanged',
-          'WorktreeCreate',
-          'WorktreeRemove',
-          'PreCompact',
-          'PostCompact',
-          'Elicitation',
-          'ElicitationResult',
-          'SessionEnd'
-        ]
-      }
+      hooks: createJsonHooksDriver(`${directory}/settings.json`, [
+        'SessionStart',
+        'Setup',
+        'UserPromptSubmit',
+        'UserPromptExpansion',
+        'PreToolUse',
+        'PermissionRequest',
+        'PermissionDenied',
+        'PostToolUse',
+        'PostToolUseFailure',
+        'PostToolBatch',
+        'Notification',
+        'MessageDisplay',
+        'SubagentStart',
+        'SubagentStop',
+        'TaskCreated',
+        'TaskCompleted',
+        'Stop',
+        'StopFailure',
+        'TeammateIdle',
+        'InstructionsLoaded',
+        'ConfigChange',
+        'CwdChanged',
+        'FileChanged',
+        'WorktreeCreate',
+        'WorktreeRemove',
+        'PreCompact',
+        'PostCompact',
+        'Elicitation',
+        'ElicitationResult',
+        'SessionEnd'
+      ]),
+      mcp: createJsonMcpDriver(`${directory}/mcp.json`),
+      skillsDirectory: `${directory}/skills`
     })
   },
   plan(request: RunRequest<RunOutputRequest>, command: string, cwd: string) {

package/src/adapters/codex-extensions.ts

@@ -0,0 +1,266 @@
+import { createHash } from 'node:crypto'
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises'
+import { basename, dirname, join } from 'node:path'
+
+import type { McpServerResource } from '../types'
+import type { McpExtensionDriver } from './extensions'
+import { mcpServerRecord } from './extensions'
+
+type CodexMcpProof = {
+  extensionId?: string
+  fingerprint: string
+}
+
+export function createCodexMcpDriver(configFile: string): McpExtensionDriver {
+  return {
+    configFile,
+    async canReclaimOnInstall({ extension, name }) {
+      const entry = codexMcpServerEntry(await readTextFile(configFile), name)
+      const proof = entry ? codexMcpServerProof(entry, name) : undefined
+      return extension.resources.mcpServers?.[name] !== undefined && proof?.extensionId === extension.id
+    },
+    async currentFingerprint(name: string) {
+      const entry = codexMcpServerEntry(await readTextFile(configFile), name)
+      return entry ? codexMcpServerProof(entry, name)?.fingerprint : undefined
+    },
+    async install({ extensionId, name, server }) {
+      const current = await readTextFile(configFile)
+      const entry = codexMcpEntry(extensionId, name, server)
+      const next = `${removeCodexMcpServerEntry(current, name).trimEnd()}\n\n${entry}\n`
+      await writeTextFile(configFile, next)
+      const proof = codexMcpServerProof(entry, name)
+      if (!proof) {
+        throw new Error(`Codex MCP server ${name} proof could not be generated.`)
+      }
+      return { fingerprint: proof.fingerprint, name, server: mcpServerRecord(server) }
+    },
+    async remove(name: string) {
+      const current = await readTextFile(configFile)
+      await writeTextFile(configFile, `${removeCodexMcpServerEntry(current, name).trimEnd()}\n`)
+    }
+  }
+}
+
+function codexMcpEntry(extensionId: string, name: string, server: McpServerResource): string {
+  const lines = [
+    `[mcp_servers.${tomlKey(name)}]`,
+    `command = ${tomlString(server.command)}`,
+    `args = ${tomlArray(server.args ?? [])}`
+  ]
+
+  const env = server.env ?? {}
+  if (Object.keys(env).length > 0) {
+    lines.push('', `[mcp_servers.${tomlKey(name)}.env]`)
+    for (const [key, value] of Object.entries(env)) {
+      lines.push(`${tomlKey(key)} = ${tomlString(value)}`)
+    }
+  }
+
+  lines.push(`# @plimeor/harness extension = ${extensionId}`)
+  return lines.join('\n')
+}
+
+function removeCodexMcpServerEntry(config: string, name: string): string {
+  const kept: string[] = []
+  let inOwnedTable = false
+  let inLegacyBlock = false
+
+  for (const line of config.split('\n')) {
+    if (line === codexLegacyBeginMarker(name)) {
+      inLegacyBlock = true
+      inOwnedTable = false
+      continue
+    }
+
+    if (line === codexLegacyEndMarker(name)) {
+      inLegacyBlock = false
+      inOwnedTable = false
+      continue
+    }
+
+    if (codexExtensionId(line) !== undefined && (inOwnedTable || inLegacyBlock)) {
+      inOwnedTable = false
+      continue
+    }
+
+    const tableName = tomlTableName(line)
+    if (tableName !== undefined) {
+      inOwnedTable = isCodexMcpServerTableName(tableName, name)
+    }
+
+    if (inOwnedTable) {
+      continue
+    }
+
+    kept.push(line)
+  }
+
+  return kept.join('\n')
+}
+
+function codexMcpServerEntry(config: string, name: string): string | undefined {
+  const lines = config.split('\n')
+  const legacyEntry: string[] = []
+  let inLegacyBlock = false
+
+  for (const line of lines) {
+    if (line === codexLegacyBeginMarker(name)) {
+      inLegacyBlock = true
+      legacyEntry.push(line)
+      continue
+    }
+
+    if (inLegacyBlock) {
+      legacyEntry.push(line)
+      if (line === codexLegacyEndMarker(name)) {
+        return legacyEntry.join('\n')
+      }
+    }
+  }
+
+  const entry: string[] = []
+  let inEntry = false
+
+  for (const line of lines) {
+    const tableName = tomlTableName(line)
+    if (tableName !== undefined) {
+      const isOwnedTable = isCodexMcpServerTableName(tableName, name)
+
+      if (!inEntry && isOwnedTable) {
+        inEntry = true
+        entry.push(line)
+        continue
+      }
+
+      if (inEntry && !isOwnedTable) {
+        break
+      }
+    }
+
+    if (inEntry) {
+      entry.push(line)
+      if (codexExtensionId(line) !== undefined) {
+        break
+      }
+    }
+  }
+
+  return entry.length > 0 ? entry.join('\n') : undefined
+}
+
+function codexMcpServerProof(entry: string, name: string): CodexMcpProof | undefined {
+  const proofLines: string[] = []
+  let extensionId: string | undefined
+  let inOwnedTable = false
+  let sawOwnedTable = false
+
+  for (const line of entry.split('\n')) {
+    if (line === codexLegacyBeginMarker(name) || line === codexLegacyEndMarker(name)) {
+      inOwnedTable = false
+      continue
+    }
+
+    const markerExtensionId = codexExtensionId(line)
+    if (markerExtensionId !== undefined) {
+      extensionId = markerExtensionId
+      proofLines.push(line)
+      inOwnedTable = false
+      continue
+    }
+
+    const tableName = tomlTableName(line)
+    if (tableName !== undefined) {
+      inOwnedTable = isCodexMcpServerTableName(tableName, name)
+      sawOwnedTable = sawOwnedTable || inOwnedTable
+    }
+
+    if (inOwnedTable) {
+      proofLines.push(line)
+    }
+  }
+
+  if (!sawOwnedTable) {
+    return undefined
+  }
+
+  return {
+    extensionId,
+    fingerprint: textFingerprint(proofLines.join('\n'))
+  }
+}
+
+function codexLegacyBeginMarker(name: string): string {
+  return `# @plimeor/harness begin mcpServers ${name}`
+}
+
+function codexLegacyEndMarker(name: string): string {
+  return `# @plimeor/harness end mcpServers ${name}`
+}
+
+function codexExtensionId(line: string): string | undefined {
+  return line.match(/^# @plimeor\/harness extension = (.*)$/)?.[1]
+}
+
+// code-lean: line-based scan for Codex MCP entries, upgrade when Codex TOML writes need arbitrary table edits.
+function tomlTableName(line: string): string | undefined {
+  return line.match(/^\s*\[(.*)]\s*(?:#.*)?$/)?.[1]
+}
+
+function isCodexMcpServerTableName(tableName: string, serverName: string): boolean {
+  const tableNames = new Set([`mcp_servers.${serverName}`, `mcp_servers.${tomlKey(serverName)}`])
+
+  for (const owned of tableNames) {
+    if (tableName === owned || tableName.startsWith(`${owned}.`)) {
+      return true
+    }
+  }
+
+  return false
+}
+
+function tomlKey(value: string): string {
+  return /^[A-Za-z0-9_-]+$/.test(value) ? value : tomlString(value)
+}
+
+function tomlArray(values: string[]): string {
+  return `[${values.map(tomlString).join(', ')}]`
+}
+
+function tomlString(value: string): string {
+  return JSON.stringify(value)
+}
+
+function textFingerprint(value: string): string {
+  return createHash('sha256').update(value).digest('hex')
+}
+
+async function readTextFile(path: string): Promise<string> {
+  try {
+    return await readFile(path, 'utf8')
+  } catch (error) {
+    if (isNotFound(error)) {
+      return ''
+    }
+    throw error
+  }
+}
+
+async function writeTextFile(path: string, text: string): Promise<void> {
+  await mkdir(dirname(path), { recursive: true })
+  await writeFileAtomically(path, text)
+}
+
+async function writeFileAtomically(path: string, text: string): Promise<void> {
+  const temporaryPath = join(dirname(path), `.${basename(path)}.${process.pid}.${Date.now()}.tmp`)
+  await writeFile(temporaryPath, text)
+  try {
+    await rename(temporaryPath, path)
+  } catch (error) {
+    await rm(temporaryPath, { force: true })
+    throw error
+  }
+}
+
+function isNotFound(error: unknown): boolean {
+  return error instanceof Error && 'code' in error && error.code === 'ENOENT'
+}

package/src/adapters/codex.ts

@@ -8,7 +8,8 @@ import type {
   StructuredOutputRequest,
   TextOutputRequest
 } from '../types'
-import { configDirectory, createExtensionFacet } from './extensions'
+import { createCodexMcpDriver } from './codex-extensions'
+import { configDirectory, createExtensionFacet, createJsonHooksDriver } from './extensions'
 import { createBuiltInAdapter, planCommand, planTextCommand, shellQuote, unsupportedOutputMode } from './shared'
 
 const HARNESS_ID = 'codex'
@@ -25,24 +26,20 @@ export const codexAdapter = createBuiltInAdapter({
       configDirectory: directory,
       context,
       harnessId: HARNESS_ID,
-      mcp: { configFile: `${directory}/config.toml`, kind: 'codex-toml' },
-      skillsDirectory: `${directory}/skills`,
-      hooks: {
-        kind: 'json-hooks',
-        settingsFile: `${directory}/hooks.json`,
-        events: [
-          'PermissionRequest',
-          'PostCompact',
-          'PostToolUse',
-          'PreCompact',
-          'PreToolUse',
-          'SessionStart',
-          'Stop',
-          'SubagentStart',
-          'SubagentStop',
-          'UserPromptSubmit'
-        ]
-      }
+      hooks: createJsonHooksDriver(`${directory}/hooks.json`, [
+        'PermissionRequest',
+        'PostCompact',
+        'PostToolUse',
+        'PreCompact',
+        'PreToolUse',
+        'SessionStart',
+        'Stop',
+        'SubagentStart',
+        'SubagentStop',
+        'UserPromptSubmit'
+      ]),
+      mcp: createCodexMcpDriver(`${directory}/config.toml`),
+      skillsDirectory: `${directory}/skills`
     })
   },
   plan(request: RunRequest<RunOutputRequest>, command: string, cwd: string) {