@canary-builds/dsh-connect 0.3.1

package/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+## 0.3.1 — 2026-09-06
+
+First packaged GitHub release.
+
+- Provide a prebuilt installable Profile Bundle and SHA-256 checksum.
+- Derive runtime version from package metadata to prevent release drift.
+- Validate packed contents and installed entry points in CI.
+- Add tag-driven GitHub releases, optional npm trusted publishing, and submission documentation.
+
+## 0.3.0 — DSH Connect
+
+- Rename the package, client module, Settings panel, HTTP route and CLI commands.
+- Establish `Canary-Builds/dhs-connect` as the source repository.
+- Discover Codex on PATH or through explicit configuration.
+- Make deployment-specific proxy exceptions opt-in.
+- Keep the existing `openai-codex` provider route and compatible sign-in location.
+- Preserve streaming, tool bridging, recovery and the automated test suite from the earlier local adapter.
+
+This is a development checkpoint, not a published npm release.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Canary Builds
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,105 @@
+# DSH Connect
+
+Connect DeepSeek Harness to ChatGPT models through the official Codex app-server.
+
+DSH Connect is a community Cordis plugin with a model-provider adapter and a web Settings panel. The first connector supports Codex/ChatGPT; it is not tied to a particular model. The provider ID is `openai-codex`.
+
+## Install
+
+Requires Node.js 22.19+ and an installed official Codex CLI. Tested with DSH 0.1.1-rc.2 and Codex 0.153.4 on Linux. Both upstream interfaces are evolving; other versions and operating systems need validation.
+
+Install the prebuilt [v0.3.1 release](https://github.com/Canary-Builds/dhs-connect/releases/tag/v0.3.1); no npm account or plugin build step is required:
+
+```sh
+dsh plugin --profile web add https://github.com/Canary-Builds/dhs-connect/releases/download/v0.3.1/canary-builds-dsh-connect-0.3.1.tgz
+```
+
+Use `--profile headless` instead for the CLI profile. Release assets include `SHA256SUMS` for checking downloaded packages. npm publication is separate; the scoped name is reserved in this source as `@canary-builds/dsh-connect`, but npm availability is not implied.
+
+Restart your running Harness instance after installation. Open **Settings → DSH Connect**, sign in with ChatGPT, and select a model from the normal model picker. Install only the profiles you use. A pnpm workspace-root profile may require its existing `ignoreWorkspaceRootCheck` setting or the package-manager workspace-root option.
+
+Remove the earlier `dsh-plugin-codex-astra` or `dsh-openai-oauth` adapter from a profile before installing this one: both claim the same `openai-codex` provider route. Keep your existing Codex sign-in directory to preserve authentication.
+
+## Features
+
+- Account model discovery merged with a curated fallback; unlisted model IDs can still be requested.
+- One catalog shared by Settings and the model picker, with refresh and connection diagnostics.
+- Text streaming, reasoning summaries, Harness dynamic tool calls and token accounting.
+- Request cancellation, RPC timeouts, process recovery and separate auxiliary calls.
+- Conversation reconstruction after restart, compaction or changed tool definitions.
+- No runtime npm dependencies or automatic binary downloads.
+
+Harness owns tool execution and permissions. The connector disables native Codex tools and delegation features, and does not silently substitute a different model.
+
+## Configuration
+
+By default DSH Connect finds `codex` on `PATH`, and uses `~/.deepseek-harness/codex` as its sign-in directory. Set `DSH_CODEX_HOME` to an existing Codex home if you want to reuse that login.
+
+Environment variables:
+
+| Variable | Purpose |
+| --- | --- |
+| `DSH_CODEX_BIN` | Absolute path to the official Codex executable; overrides discovery. |
+| `DSH_CODEX_HOME` | Codex sign-in and configuration directory. |
+| `DSH_CONNECT_CONFIG` | Override the configuration-file path. |
+| `DSH_CONNECT_NO_PROXY` | Optional domains to append to the Codex child's `NO_PROXY`. |
+
+Alternatively, create `$DSH_HOME/connect.json` (default `~/.dsh/connect.json`):
+
+```json
+{
+  "codexBin": "/absolute/path/to/codex",
+  "codexHome": "/absolute/path/to/codex-home"
+}
+```
+
+The optional `noProxy` field contains a comma-separated domain list. Proxy routing is inherited unchanged unless explicitly configured. Do not put credentials in this file; the official Codex executable manages authentication.
+
+For a browser on another machine, forward the callback port before signing in:
+
+```sh
+ssh -N -o ExitOnForwardFailure=yes -L 1455:127.0.0.1:1455 user@harness-host
+```
+
+Replace `user@harness-host` with your SSH destination. The bundled `dsh-connect-login` command also supports Codex's `--device-auth` option when available to your account. Run `dsh-connect-doctor` through your profile's executable environment for diagnostics.
+
+## Development
+
+```sh
+git clone https://github.com/Canary-Builds/dhs-connect.git
+cd dhs-connect
+```
+
+
+```sh
+npm test
+npm run test:package
+npm run doctor
+npm run test:live
+```
+
+No dependency installation is required for unit tests. `npm test` rebuilds the client and exercises transport failures, cancellation, model fallback, tool bridging, history recovery, Settings registration and request-origin checks. The build derives the client module ID from `package.json`; edit `src/client.js`, not `lib/client.js`.
+
+`test:live` uses your configured ChatGPT login and sends a few short requests. Set `DSH_CONNECT_TEST_MODEL` to choose the test model. `scripts/verify-web.mjs` checks a running DSH server's served module using its actual module loader and a React render check; it uses `DSH_WEB_URL` and optionally `DSH_RUNTIME_PACKAGE` for the host location.
+
+## Limits and security
+
+This version supports text and text tool results. Image attachments and per-turn temperature, stop sequences or output-token caps are not supported. A model's presence in the catalog does not guarantee account access.
+
+Matching continuations reuse an ephemeral Codex thread. When that state no longer matches the supplied DSH history, the connector rebuilds from a role-labeled JSON transcript. This adds prompt tokens and does not restore hidden reasoning or replay completed tool execution.
+
+Settings controls require loopback transport and same-origin requests and reject cross-site requests. Remote access requires a trusted deployment proxy; the plugin does not create public endpoints or add authentication to a proxy. Native stderr is not forwarded to Harness logs because it can include request data. Diagnostics filter common credential patterns.
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for changes, [RELEASING.md](RELEASING.md) for versioned releases and npm publishing, and [DIRECTORY.md](DIRECTORY.md) for a ready-to-copy directory submission.
+
+## Upstream references
+
+- [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)
+- [Codex app-server protocol](https://learn.chatgpt.com/docs/app-server)
+- [DSH contribution guidance](https://github.com/deepseek-ai/deepseek-harness/blob/master/CONTRIBUTING.md)
+
+The development history began with the community [dsh-openai-oauth](https://github.com/DGPisces/dsh-openai-oauth) integration. The connector implementation in this repository was subsequently rewritten. DSH Connect is independently maintained by Canary Builds and is not an official DeepSeek or OpenAI product.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

package/cordis.patch.yml

@@ -0,0 +1,10 @@
+[
+  {
+    "insert": [
+      {
+        "id": "llm-dsh-connect",
+        "name": "@canary-builds/dsh-connect"
+      }
+    ]
+  }
+]

package/lib/client.js

@@ -0,0 +1,99 @@
+// Generated by npm run build. Edit src/client.js.
+window.__ModuleLoader__.load({id:"@canary-builds/dsh-connect",factory:(require)=>{
+// Factory body compiled by scripts/build.mjs. No Node imports or browser bundler.
+const React = require('react');
+const h = React.createElement;
+const inject = ['slots'];
+const styles = {
+  root: { maxWidth: 820, display: 'flex', flexDirection: 'column', gap: 20, color: 'var(--dsw-alias-label-primary)' },
+  card: { padding: 20, border: '1px solid var(--dsw-alias-border-l2)', borderRadius: 12, background: 'var(--dsw-alias-bg-layer-3)' },
+  row: { display: 'flex', flexWrap: 'wrap', alignItems: 'center', gap: 12 },
+  muted: { color: 'var(--dsw-alias-label-secondary)', lineHeight: 1.6 },
+  button: { border: '1px solid var(--dsw-alias-border-l2)', borderRadius: 8, padding: '8px 14px', background: 'var(--dsw-alias-bg-layer-1)', color: 'inherit', cursor: 'pointer' },
+  table: { width: '100%', borderCollapse: 'collapse', textAlign: 'left', lineHeight: 2.1 },
+  code: { fontFamily: 'monospace', fontSize: 12, overflowWrap: 'anywhere' },
+  issue: { color: 'var(--dsw-alias-state-error-primary, #c44)', lineHeight: 1.5 },
+};
+async function request(path = '', method = 'GET', signal) {
+  const response = await fetch('/api/dsh-connect' + path, { method, credentials: 'same-origin', headers: { accept: 'application/json' }, signal });
+  const body = await response.json();
+  if (!response.ok) throw new Error(body.error || 'Codex connection is unavailable.');
+  return body;
+}
+function CodexSettings() {
+  const [state, setState] = React.useState(null);
+  const [busy, setBusy] = React.useState(false);
+  const [error, setError] = React.useState('');
+  const [waiting, setWaiting] = React.useState(false);
+  const [authUrl, setAuthUrl] = React.useState('');
+  const load = React.useCallback(async signal => {
+    const next = await request('', 'GET', signal);
+    setState(next);
+    if (next.authenticated) { setWaiting(false); setAuthUrl(''); }
+    return next;
+  }, []);
+  React.useEffect(() => {
+    const controller = new AbortController();
+    load(controller.signal).catch(e => { if (!controller.signal.aborted) setError(e.message); });
+    return () => controller.abort();
+  }, [load]);
+  React.useEffect(() => {
+    if (!waiting) return;
+    const controller = new AbortController();
+    let timer;
+    const poll = async () => {
+      try { const next = await load(controller.signal); if (next.authenticated) return; }
+      catch (e) { if (!controller.signal.aborted) setError(e.message); }
+      if (!controller.signal.aborted) timer = setTimeout(poll, 2000);
+    };
+    timer = setTimeout(poll, 2000);
+    const expiry = setTimeout(() => { setWaiting(false); setAuthUrl(''); setError('Sign-in timed out. Check the SSH tunnel and start again.'); }, 5 * 60_000);
+    return () => { controller.abort(); clearTimeout(timer); clearTimeout(expiry); };
+  }, [waiting, load]);
+  async function act(path) {
+    setBusy(true); setError('');
+    const popup = path === '/login' ? window.open('about:blank', '_blank') : null;
+    if (popup) popup.opener = null;
+    try {
+      const result = await request(path, 'POST');
+      if (path === '/login') {
+        setAuthUrl(result.authUrl); setWaiting(true);
+        if (popup) popup.location.href = result.authUrl;
+      } else { setState(path === '/refresh' ? result : await load()); }
+    } catch (e) { popup?.close(); setError(e.message); }
+    finally { setBusy(false); }
+  }
+  const button = (label, action, extra = {}) => h('button', { type: 'button', style: styles.button, disabled: busy, onClick: action, ...extra }, label);
+  return h('section', { style: styles.root },
+    h('div', null, h('h2', { style: { marginBottom: 8 } }, 'DSH Connect'), h('p', { style: styles.muted }, 'Your ChatGPT models, connected to DeepSeek Harness.')),
+    h('div', { style: styles.card },
+      h('div', { style: styles.row, role: 'status', 'aria-live': 'polite' },
+        h('strong', null, state ? state.authenticated ? 'Connected' : state.connectionIssue ? 'Connection unavailable' : 'Sign-in required' : 'Checking connection…'),
+        state?.planType ? h('span', { style: styles.muted }, state.planType) : null),
+      state ? h('p', { style: styles.muted }, `Plugin ${state.pluginVersion} · ${state.codexVersion}`) : null,
+      h('div', { style: styles.row },
+        state?.authenticated ? button('Sign out', () => act('/logout')) : button(waiting ? 'Waiting for sign-in…' : 'Sign in with ChatGPT', () => act('/login'), { disabled: busy || waiting }),
+        button('Refresh connection & models', () => act('/refresh')),
+        waiting ? button('Stop waiting', () => { setWaiting(false); setAuthUrl(''); }) : null),
+      authUrl ? h('p', null, h('a', { href: authUrl, target: '_blank', rel: 'noopener noreferrer' }, 'Continue sign-in')) : null,
+      error || state?.connectionIssue ? h('p', { style: styles.issue, role: 'alert' }, error || state.connectionIssue) : null),
+    !state?.authenticated ? h('div', { style: styles.card },
+      h('strong', null, 'Signing in from another computer'),
+      h('p', { style: styles.muted }, 'Keep this SSH tunnel open on the computer running your browser before signing in. It forwards the login callback to the agent VM.'),
+      h('code', { style: styles.code }, 'ssh -N -o ExitOnForwardFailure=yes -L 1455:127.0.0.1:1455 user@harness-host'),
+      h('p', { style: styles.muted }, 'For terminal sign-in on the server: dsh-connect-login --device-auth')) : null,
+    h('div', { style: styles.card },
+      h('h3', { style: { marginTop: 0 } }, 'Models'),
+      h('p', { style: styles.muted }, state ? `Source: ${state.modelSource}. Account access is checked when you send a message.` : 'Loading model catalog…'),
+      state?.discoveryIssue ? h('p', { style: styles.muted }, state.discoveryIssue) : null,
+      h('table', { style: styles.table }, h('thead', null, h('tr', null, h('th', null, 'Model'), h('th', null, 'Model ID'))), h('tbody', null,
+        ...(state?.models ?? []).map(model => h('tr', { key: model.id }, h('td', null, model.name), h('td', { style: styles.code }, model.id)))))),
+    h('p', { style: styles.muted }, 'Supports text, reasoning, and Harness tool calls. Image attachments are not supported by this provider yet.')
+  );
+}
+function apply(ctx) {
+  ctx.slots.inject('settings.section', () => ctx.slots.register({ name: 'settings.section', id: 'dsh-connect', label: () => 'DSH Connect', order: 11 }, CodexSettings));
+}
+
+return { inject, apply, CodexSettings };
+}});

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@canary-builds/dsh-connect",
+  "version": "0.3.1",
+  "description": "Connect DeepSeek Harness to ChatGPT models through the Codex app-server",
+  "license": "MIT",
+  "author": "Canary Builds",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Canary-Builds/dhs-connect.git"
+  },
+  "homepage": "https://github.com/Canary-Builds/dhs-connect#readme",
+  "bugs": {
+    "url": "https://github.com/Canary-Builds/dhs-connect/issues"
+  },
+  "keywords": [
+    "dsh-plugin",
+    "deepseek-harness",
+    "codex",
+    "connector"
+  ],
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "dsh-connect-login": "src/login.js",
+    "dsh-connect-doctor": "src/doctor.js"
+  },
+  "files": [
+    "src",
+    "lib",
+    "cordis.patch.yml",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "pretest": "node scripts/build.mjs",
+    "prepack": "node scripts/build.mjs",
+    "test": "node --test test/*.test.js",
+    "doctor": "node src/doctor.js",
+    "test:live": "node scripts/live-check.mjs",
+    "test:package": "node scripts/check-package.mjs"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-settings"
+      ],
+      "platform": "web"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/src/adapter.js

@@ -0,0 +1,206 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { AppServer } from './transport.js';
+import { ModelCatalog } from './models.js';
+import { CodexError } from './errors.js';
+import { PROVIDER } from './runtime.js';
+
+const hash = value => createHash('sha256').update(JSON.stringify(value)).digest('hex');
+const transcriptShape = messages => messages.map(m => ({ role: m.role, content: m.content }));
+const historyHash = messages => hash(transcriptShape(messages));
+const contentHash = content => hash(content.filter(b => !(b.type === 'text' || b.type === 'reasoning') || b.text));
+const keyOf = options => options.sessionId ? `${options.sessionId}:${options.purpose ?? 'conversation'}` : randomUUID();
+
+export function contentText(blocks) {
+  return blocks.map(block => {
+    if (block.type === 'text') return block.text;
+    if (block.type === 'reasoning') return '';
+    if (block.type === 'tool-call') return `[Tool call ${block.id}: ${block.name}] ${block.arguments}`;
+    if (block.type === 'tool-result') return `[${block.isError ? 'Failed tool result' : 'Tool result'} ${block.toolCallId}]\n${contentText(block.content)}`;
+    throw new CodexError(`DSH Connect currently accepts text and text tool results; unsupported content: ${block.type}.`, 'UNSUPPORTED_CONTENT');
+  }).filter(Boolean).join('\n');
+}
+export function inputFor(messages, rebuild = false) {
+  if (messages.length === 1 && messages[0].role === 'user' && !messages[0].content.some(b => b.type === 'tool-result')) return contentText(messages[0].content);
+  const transcript = messages.map(m => ({ role: m.role, source: m.source?.kind ?? m.role, content: contentText(m.content) }));
+  return (rebuild ? 'Harness conversation history follows as JSON. Continue from its last message. Tool results in this history have already been executed; do not repeat a tool merely to reconstruct history.\n' : 'New Harness messages follow as JSON, in order:\n') + JSON.stringify(transcript);
+}
+export function toolSpecs(tools = []) {
+  const names = new Set();
+  return tools.map(tool => {
+    if (typeof tool.name !== 'string' || !/^[A-Za-z0-9_-]{1,64}$/.test(tool.name) || names.has(tool.name)) throw new CodexError('Dynamic tool names must be unique and contain 1–64 letters, digits, underscores or hyphens.', 'INVALID_REQUEST');
+    names.add(tool.name);
+    if (!tool.parameters || tool.parameters.type !== 'object' || Array.isArray(tool.parameters)) throw new CodexError(`Tool ${tool.name} requires an object JSON Schema.`, 'INVALID_REQUEST');
+    return { type: 'function', name: tool.name, description: tool.description ?? '', inputSchema: tool.parameters };
+  });
+}
+function usageDelta(total, previous = {}) {
+  const diff = name => Math.max(0, (total[name] ?? 0) - (previous[name] ?? 0));
+  return { inputTokens: Math.max(0, diff('inputTokens') - diff('cachedInputTokens') - diff('cacheWriteInputTokens')), outputTokens: diff('outputTokens'), cacheReadTokens: diff('cachedInputTokens'), cacheWriteTokens: diff('cacheWriteInputTokens'), reasoningTokens: diff('reasoningOutputTokens') };
+}
+
+// Implements the host's public adapter interface without a duplicate DSH runtime.
+export class CodexAdapter {
+  sessions = new Map();
+  busy = new Set();
+  constructor(server = new AppServer(), catalog = new ModelCatalog(server), { idleTimeoutMs = 300_000, maxSessions = 128 } = {}) {
+    this.server = server;
+    this.catalog = catalog;
+    this.idleTimeoutMs = idleTimeoutMs;
+    this.maxSessions = maxSessions;
+  }
+  providerInfo() { return { id: PROVIDER, name: 'DSH Connect · ChatGPT' }; }
+  providerRetryPolicy() {}
+  listModels() { return this.catalog.list(); }
+  resolveModel(provider, model, signal) { return this.catalog.resolve(provider, model, signal); }
+  async prepareCall(provider, model, signal) { return { model: await this.resolveModel(provider, model, signal), stream: options => this.stream(options) }; }
+  async clear() {
+    const sessions = [...this.sessions.values()];
+    this.sessions.clear();
+    await Promise.all(sessions.map(s => this.server.release(s.threadId, s.turnId)));
+  }
+  reusable(s, options, signature) {
+    if (!s || s.generation !== this.server.generation || s.signature !== signature) return false;
+    const index = options.messages.findLastIndex(m => m.role === 'assistant');
+    const previous = options.messages[index];
+    const replay = previous?.source?.replayState?.response;
+    return index === s.inputCount && replay?.kind === 'dsh-connect' && replay.marker === s.marker && historyHash(options.messages.slice(0, index)) === s.inputHash && contentHash(previous.content) === s.outputHash;
+  }
+  async fresh(options, specs, signature, key) {
+    const old = this.sessions.get(key);
+    if (old) await this.server.release(old.threadId, old.turnId);
+    this.sessions.delete(key);
+    for (const [id, session] of this.sessions) {
+      if (!this.busy.has(id) && (Date.now() - session.touched > 30 * 60_000 || this.sessions.size >= this.maxSessions)) {
+        this.sessions.delete(id);
+        await this.server.release(session.threadId, session.turnId);
+      }
+    }
+    if (this.sessions.size >= this.maxSessions) throw new CodexError('All Codex sessions are busy; retry after a running turn finishes.', 'CODEX_BUSY');
+    const threadId = await this.server.startThread({
+      model: options.model, cwd: process.cwd(), approvalPolicy: 'never', sandbox: 'read-only', ephemeral: true,
+      baseInstructions: [options.system ?? '', 'You are the model inside DeepSeek Harness. Harness owns the conversation and tool execution. Use only the supplied dynamic tools, one at a time. Never use native Codex tools.'].filter(Boolean).join('\n\n'),
+      dynamicTools: specs,
+    }, options.signal);
+    const session = { threadId, generation: this.server.generation, signature, touched: Date.now(), pending: [], billed: {}, turnId: undefined };
+    this.sessions.set(key, session);
+    return session;
+  }
+  async *stream(options) {
+    options.signal?.throwIfAborted();
+    if (options.stop !== undefined || options.temperature !== undefined || options.maxTokens !== undefined) throw new CodexError('Codex app-server does not support stop, temperature, or maxTokens overrides.', 'UNSUPPORTED_OPTION');
+    if (!options.messages?.length) throw new CodexError('At least one conversation message is required.', 'INVALID_REQUEST');
+    for (const message of options.messages) contentText(message.content); // Validate nested content before starting anything.
+    const specs = toolSpecs(options.tools);
+    const signature = hash({ system: options.system, specs, model: options.model, effort: options.reasoningEffort, cwd: process.cwd() });
+    const key = keyOf(options);
+    if (this.busy.has(key)) throw new CodexError('A Codex response is already running for this Harness session.', 'CODEX_BUSY');
+    this.busy.add(key);
+    let session;
+    let finished = false;
+    try {
+      await this.server.start(options.signal);
+      const account = await this.server.account(options.signal);
+      if (account?.type !== 'chatgpt') throw new CodexError('Sign in with ChatGPT in Settings → DSH Connect, or run dsh-connect-login.', 'MISSING_CREDENTIAL');
+      session = this.sessions.get(key);
+      const reuse = this.reusable(session, options, signature);
+      if (!reuse) session = await this.fresh(options, specs, signature, key);
+      if (session.pending.length) {
+        const results = new Map(options.messages.flatMap(m => m.content).filter(b => b.type === 'tool-result').map(b => [b.toolCallId, b]));
+        for (const call of session.pending) {
+          const result = results.get(call.callId);
+          if (!result) throw new CodexError('Harness has not supplied the pending tool result.', 'INVALID_REQUEST');
+          this.server.respond(call.requestId, { contentItems: [{ type: 'inputText', text: contentText(result.content) || '(no output)' }], success: !result.isError });
+        }
+        session.pending = [];
+      } else {
+        const incoming = reuse ? options.messages.slice(session.inputCount + 1) : options.messages;
+        if (!incoming.length) throw new CodexError('No new Harness messages were supplied.', 'INVALID_REQUEST');
+        session.turnId = await this.server.startTurn(session.threadId, { model: options.model, ...(options.reasoningEffort ? { effort: options.reasoningEffort } : {}), input: [{ type: 'text', text: inputFor(incoming, !reuse) }] }, options.signal);
+        session.closedItems = new Set();
+      }
+      session.inputCount = options.messages.length;
+      session.inputHash = historyHash(options.messages);
+      const open = new Map();
+      const emitted = [];
+      let nextIndex = 0;
+      const end = block => { open.delete(block.key); session.closedItems.add(block.itemId); const content = { type: block.type, text: block.text }; emitted[block.index] = content; return { type: 'block-end', index: block.index, block: content }; };
+      const finish = kind => {
+        session.marker = randomUUID();
+        session.outputHash = contentHash(emitted.filter(Boolean));
+        session.touched = Date.now();
+        finished = true;
+        return { type: 'finish', reason: { kind }, replayState: { response: { kind: 'dsh-connect', version: 2, marker: session.marker } } };
+      };
+      while (true) {
+        const timeout = AbortSignal.timeout(this.idleTimeoutMs);
+        const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
+        let event;
+        try { event = await this.server.nextEvent(session.threadId, signal); }
+        catch (error) { if (!options.signal?.aborted && timeout.aborted) throw new CodexError('Codex stopped sending events. Retry to reconnect.', 'CODEX_TIMEOUT'); throw error; }
+        const { method, params } = event;
+        const eventTurn = params.turnId ?? params.turn?.id;
+        if (eventTurn && session.turnId && eventTurn !== session.turnId) continue;
+        if (method === 'thread/tokenUsage/updated') { session.usage = params.tokenUsage?.total; continue; }
+        if (method === 'error' && !params.willRetry) throw new CodexError(params.error?.message ?? 'Codex turn failed.');
+        const type = method === 'item/agentMessage/delta' ? 'text' : method === 'item/reasoning/summaryTextDelta' ? 'reasoning' : undefined;
+        if (type) {
+          const key = `${params.itemId}:${type}`;
+          let block = open.get(key);
+          if (!block) {
+            block = { key, itemId: params.itemId, index: nextIndex++, type, text: '' };
+            open.set(key, block);
+            yield { type: 'block-start', index: block.index, blockType: type };
+          }
+          const text = params.delta ?? '';
+          block.text += text;
+          yield { type: type === 'text' ? 'text-delta' : 'reasoning-delta', index: block.index, text };
+        }
+        if (method === 'item/completed') {
+          const item = params.item;
+          const blocks = [...open.values()].filter(b => b.itemId === item?.id);
+          // Some app-server paths send only the final item, with no deltas.
+          if (!blocks.length && item?.type === 'agentMessage' && item.text && !session.closedItems.has(item.id)) {
+            const block = { key: `${item.id}:text`, itemId: item.id, index: nextIndex++, type: 'text', text: item.text };
+            yield { type: 'block-start', index: block.index, blockType: 'text' };
+            yield { type: 'text-delta', index: block.index, text: item.text };
+            yield end(block);
+          }
+          for (const block of blocks) yield end(block);
+        }
+        if (method === 'item/tool/call') {
+          const { callId, tool, arguments: args } = params;
+          if (event.requestId === undefined || typeof callId !== 'string' || !specs.some(t => t.name === tool)) {
+            if (event.requestId !== undefined) this.server.respond(event.requestId, { success: false, contentItems: [{ type: 'inputText', text: 'Unknown or malformed Harness tool call.' }] });
+            throw new CodexError('Codex requested an unknown or malformed dynamic tool.', 'PROTOCOL_ERROR');
+          }
+          for (const block of [...open.values()]) yield end(block);
+          const index = nextIndex++;
+          const content = { type: 'tool-call', id: callId, name: tool, arguments: JSON.stringify(args ?? {}) };
+          session.pending = [{ requestId: event.requestId, callId }];
+          emitted[index] = content;
+          yield { type: 'block-start', index, blockType: 'tool-call' };
+          yield { type: 'tool-call-delta', index, id: callId, name: tool, argumentsDelta: content.arguments };
+          yield { type: 'block-end', index, block: content };
+          if (session.usage) { yield { type: 'usage', usage: usageDelta(session.usage, session.billed) }; session.billed = session.usage; }
+          yield finish('tool-calls');
+          return;
+        }
+        if (method === 'turn/completed') {
+          if (params.turn?.status === 'failed') throw new CodexError(params.turn.error?.message ?? 'Codex turn failed.');
+          if (params.turn?.status === 'interrupted') throw new CodexError('Codex turn was interrupted.', 'ABORTED');
+          for (const block of [...open.values()]) yield end(block);
+          if (session.usage) { yield { type: 'usage', usage: usageDelta(session.usage, session.billed) }; session.billed = session.usage; }
+          session.turnId = undefined;
+          yield finish('stop');
+          return;
+        }
+      }
+    } finally {
+      if (session && (!finished || !options.sessionId || options.purpose)) {
+        this.sessions.delete(key);
+        await this.server.release(session.threadId, session.turnId);
+      }
+      this.busy.delete(key);
+    }
+  }
+}

package/src/client.js

@@ -0,0 +1,94 @@
+// Factory body compiled by scripts/build.mjs. No Node imports or browser bundler.
+const React = require('react');
+const h = React.createElement;
+const inject = ['slots'];
+const styles = {
+  root: { maxWidth: 820, display: 'flex', flexDirection: 'column', gap: 20, color: 'var(--dsw-alias-label-primary)' },
+  card: { padding: 20, border: '1px solid var(--dsw-alias-border-l2)', borderRadius: 12, background: 'var(--dsw-alias-bg-layer-3)' },
+  row: { display: 'flex', flexWrap: 'wrap', alignItems: 'center', gap: 12 },
+  muted: { color: 'var(--dsw-alias-label-secondary)', lineHeight: 1.6 },
+  button: { border: '1px solid var(--dsw-alias-border-l2)', borderRadius: 8, padding: '8px 14px', background: 'var(--dsw-alias-bg-layer-1)', color: 'inherit', cursor: 'pointer' },
+  table: { width: '100%', borderCollapse: 'collapse', textAlign: 'left', lineHeight: 2.1 },
+  code: { fontFamily: 'monospace', fontSize: 12, overflowWrap: 'anywhere' },
+  issue: { color: 'var(--dsw-alias-state-error-primary, #c44)', lineHeight: 1.5 },
+};
+async function request(path = '', method = 'GET', signal) {
+  const response = await fetch('/api/dsh-connect' + path, { method, credentials: 'same-origin', headers: { accept: 'application/json' }, signal });
+  const body = await response.json();
+  if (!response.ok) throw new Error(body.error || 'Codex connection is unavailable.');
+  return body;
+}
+function CodexSettings() {
+  const [state, setState] = React.useState(null);
+  const [busy, setBusy] = React.useState(false);
+  const [error, setError] = React.useState('');
+  const [waiting, setWaiting] = React.useState(false);
+  const [authUrl, setAuthUrl] = React.useState('');
+  const load = React.useCallback(async signal => {
+    const next = await request('', 'GET', signal);
+    setState(next);
+    if (next.authenticated) { setWaiting(false); setAuthUrl(''); }
+    return next;
+  }, []);
+  React.useEffect(() => {
+    const controller = new AbortController();
+    load(controller.signal).catch(e => { if (!controller.signal.aborted) setError(e.message); });
+    return () => controller.abort();
+  }, [load]);
+  React.useEffect(() => {
+    if (!waiting) return;
+    const controller = new AbortController();
+    let timer;
+    const poll = async () => {
+      try { const next = await load(controller.signal); if (next.authenticated) return; }
+      catch (e) { if (!controller.signal.aborted) setError(e.message); }
+      if (!controller.signal.aborted) timer = setTimeout(poll, 2000);
+    };
+    timer = setTimeout(poll, 2000);
+    const expiry = setTimeout(() => { setWaiting(false); setAuthUrl(''); setError('Sign-in timed out. Check the SSH tunnel and start again.'); }, 5 * 60_000);
+    return () => { controller.abort(); clearTimeout(timer); clearTimeout(expiry); };
+  }, [waiting, load]);
+  async function act(path) {
+    setBusy(true); setError('');
+    const popup = path === '/login' ? window.open('about:blank', '_blank') : null;
+    if (popup) popup.opener = null;
+    try {
+      const result = await request(path, 'POST');
+      if (path === '/login') {
+        setAuthUrl(result.authUrl); setWaiting(true);
+        if (popup) popup.location.href = result.authUrl;
+      } else { setState(path === '/refresh' ? result : await load()); }
+    } catch (e) { popup?.close(); setError(e.message); }
+    finally { setBusy(false); }
+  }
+  const button = (label, action, extra = {}) => h('button', { type: 'button', style: styles.button, disabled: busy, onClick: action, ...extra }, label);
+  return h('section', { style: styles.root },
+    h('div', null, h('h2', { style: { marginBottom: 8 } }, 'DSH Connect'), h('p', { style: styles.muted }, 'Your ChatGPT models, connected to DeepSeek Harness.')),
+    h('div', { style: styles.card },
+      h('div', { style: styles.row, role: 'status', 'aria-live': 'polite' },
+        h('strong', null, state ? state.authenticated ? 'Connected' : state.connectionIssue ? 'Connection unavailable' : 'Sign-in required' : 'Checking connection…'),
+        state?.planType ? h('span', { style: styles.muted }, state.planType) : null),
+      state ? h('p', { style: styles.muted }, `Plugin ${state.pluginVersion} · ${state.codexVersion}`) : null,
+      h('div', { style: styles.row },
+        state?.authenticated ? button('Sign out', () => act('/logout')) : button(waiting ? 'Waiting for sign-in…' : 'Sign in with ChatGPT', () => act('/login'), { disabled: busy || waiting }),
+        button('Refresh connection & models', () => act('/refresh')),
+        waiting ? button('Stop waiting', () => { setWaiting(false); setAuthUrl(''); }) : null),
+      authUrl ? h('p', null, h('a', { href: authUrl, target: '_blank', rel: 'noopener noreferrer' }, 'Continue sign-in')) : null,
+      error || state?.connectionIssue ? h('p', { style: styles.issue, role: 'alert' }, error || state.connectionIssue) : null),
+    !state?.authenticated ? h('div', { style: styles.card },
+      h('strong', null, 'Signing in from another computer'),
+      h('p', { style: styles.muted }, 'Keep this SSH tunnel open on the computer running your browser before signing in. It forwards the login callback to the agent VM.'),
+      h('code', { style: styles.code }, 'ssh -N -o ExitOnForwardFailure=yes -L 1455:127.0.0.1:1455 user@harness-host'),
+      h('p', { style: styles.muted }, 'For terminal sign-in on the server: dsh-connect-login --device-auth')) : null,
+    h('div', { style: styles.card },
+      h('h3', { style: { marginTop: 0 } }, 'Models'),
+      h('p', { style: styles.muted }, state ? `Source: ${state.modelSource}. Account access is checked when you send a message.` : 'Loading model catalog…'),
+      state?.discoveryIssue ? h('p', { style: styles.muted }, state.discoveryIssue) : null,
+      h('table', { style: styles.table }, h('thead', null, h('tr', null, h('th', null, 'Model'), h('th', null, 'Model ID'))), h('tbody', null,
+        ...(state?.models ?? []).map(model => h('tr', { key: model.id }, h('td', null, model.name), h('td', { style: styles.code }, model.id)))))),
+    h('p', { style: styles.muted }, 'Supports text, reasoning, and Harness tool calls. Image attachments are not supported by this provider yet.')
+  );
+}
+function apply(ctx) {
+  ctx.slots.inject('settings.section', () => ctx.slots.register({ name: 'settings.section', id: 'dsh-connect', label: () => 'DSH Connect', order: 11 }, CodexSettings));
+}

package/src/doctor.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { AppServer } from './transport.js';
+import { ModelCatalog } from './models.js';
+import { CodexAdapter } from './adapter.js';
+import { createController } from './http.js';
+import { safeMessage } from './errors.js';
+const server = new AppServer();
+try {
+  const catalog = new ModelCatalog(server);
+  const controller = createController(server, catalog, new CodexAdapter(server, catalog));
+  const status = await controller.status(AbortSignal.timeout(60_000));
+  console.log(JSON.stringify(status, null, 2));
+  if (status.connectionIssue || !status.authenticated) process.exitCode = 1;
+} catch (error) { console.error(safeMessage(error)); process.exitCode = 1; }
+finally { server.close(); }

package/src/errors.js

@@ -0,0 +1,25 @@
+export function safeMessage(error) {
+  return String(error?.message ?? error ?? 'Codex failed')
+    .replace(/https?:\/\/[^\s"<>]*\?[^\s"<>]*/gi, '[URL query redacted]')
+    .replace(/\b(?:sk-|gh[pousr]_|tskey-|eyJ)[\w./+=-]+/g, '[redacted]')
+    .replace(/(?:bearer\s+)[^\s"']+/gi, 'Bearer [redacted]')
+    .replace(/(?:access_token|refresh_token|id_token|api_key|password)\s*["']?\s*[:=]\s*["']?[^\s,"'}]+/gi, '[credential redacted]')
+    .slice(0, 1000);
+}
+export class CodexError extends Error {
+  constructor(message, code = 'CODEX_ERROR') {
+    super(safeMessage(message));
+    this.name = 'CodexError';
+    this.code = code;
+    this.failure = { message: this.message, code };
+  }
+}
+export function abortable(promise, signal) {
+  if (!signal) return promise;
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const abort = () => reject(signal.reason);
+    signal.addEventListener('abort', abort, { once: true });
+    promise.then(resolve, reject).finally(() => signal.removeEventListener('abort', abort));
+  });
+}

package/src/http.js

@@ -0,0 +1,76 @@
+import { isIP } from 'node:net';
+import { promisify } from 'node:util';
+import { execFile } from 'node:child_process';
+import { runtime, VERSION } from './runtime.js';
+import { safeMessage } from './errors.js';
+
+export const API_PATH = '/api/dsh-connect';
+const isLoopback = host => host === '::1' || (isIP(host) === 4 && host.startsWith('127.'));
+export function trustedRequest(req) {
+  const remote = req.socket?.remoteAddress?.replace(/^::ffff:/, '');
+  if (!isLoopback(remote ?? '') || req.headers['sec-fetch-site'] === 'cross-site') return false;
+  try {
+    const host = new URL(`http://${req.headers.host}`);
+    const name = host.hostname.replace(/^\[|\]$/g, '');
+    if (name !== 'localhost' && !isLoopback(name)) return false;
+    return !req.headers.origin || new URL(req.headers.origin).origin === host.origin;
+  } catch { return false; }
+}
+export async function binaryVersion() {
+  const r = runtime();
+  const { stdout } = await promisify(execFile)(r.command, ['--version'], { env: r.env, timeout: 5000 });
+  return /^codex-cli [\w.+-]+/.exec(stdout)?.[0] ?? 'unknown';
+}
+export function createController(server, catalog, adapter, { version = binaryVersion } = {}) {
+  let versionPromise;
+  async function status(signal) {
+    let account;
+    let connectionIssue;
+    try { account = await server.account(signal); }
+    catch (error) { if (signal?.aborted) throw error; connectionIssue = safeMessage(error); }
+    const models = await catalog.list(signal);
+    versionPromise ??= version().catch(() => 'unavailable');
+    return {
+      pluginVersion: VERSION, codexVersion: await versionPromise, authenticated: account?.type === 'chatgpt',
+      planType: account?.type === 'chatgpt' ? account.planType ?? null : null,
+      models, modelSource: catalog.source, discoveryIssue: catalog.discoveryIssue ?? null,
+      connectionIssue: connectionIssue ?? null, activeSessions: adapter.sessions.size,
+      capabilities: ['Text streaming', 'Harness tool calls', 'Reasoning', 'Conversation recovery'],
+    };
+  }
+  const json = (res, code, body) => {
+    res.writeHead(code, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store', 'x-content-type-options': 'nosniff' });
+    res.end(JSON.stringify(body));
+  };
+  async function handler(req, res) {
+    if (!trustedRequest(req)) return json(res, 403, { error: 'Use the trusted Harness UI to manage Codex.' });
+    const controller = new AbortController();
+    const disconnected = () => { if (!res.writableEnded) controller.abort(); };
+    res.on('close', disconnected);
+    try {
+      const path = new URL(req.url ?? '/', 'http://localhost').pathname;
+      if (req.method === 'GET' && path === API_PATH) return json(res, 200, await status(controller.signal));
+      if (req.method === 'POST' && path === `${API_PATH}/refresh`) {
+        await catalog.refresh(controller.signal, true);
+        return json(res, 200, await status(controller.signal));
+      }
+      if (req.method === 'POST' && path === `${API_PATH}/login`) {
+        const login = await server.request('account/login/start', { type: 'chatgpt', useHostedLoginSuccessPage: true, appBrand: 'chatgpt' }, controller.signal);
+        const url = new URL(login.authUrl);
+        if (url.protocol !== 'https:' || url.hostname !== 'auth.openai.com') throw new Error('Codex returned an unexpected sign-in address.');
+        catalog.invalidate();
+        return json(res, 200, { authUrl: login.authUrl });
+      }
+      if (req.method === 'POST' && path === `${API_PATH}/logout`) {
+        await adapter.clear();
+        await server.request('account/logout', {}, controller.signal);
+        catalog.invalidate();
+        return json(res, 200, { ok: true });
+      }
+      return json(res, 404, { error: 'Unknown DSH Connect endpoint.' });
+    } catch (error) {
+      if (!res.destroyed) return json(res, 503, { error: safeMessage(error) });
+    } finally { res.off('close', disconnected); }
+  }
+  return { status, route: { kind: 'prefix', path: API_PATH, handler } };
+}

package/src/index.js

@@ -0,0 +1,20 @@
+import { AppServer } from './transport.js';
+import { ModelCatalog } from './models.js';
+import { CodexAdapter } from './adapter.js';
+import { createController } from './http.js';
+import { PROVIDER } from './runtime.js';
+
+export const name = 'llm-dsh-connect';
+export const inject = ['llm'];
+export function apply(ctx) {
+  const server = new AppServer();
+  const catalog = new ModelCatalog(server);
+  const adapter = new CodexAdapter(server, catalog);
+  const controller = createController(server, catalog, adapter);
+  ctx.llm.registerAdapter([PROVIDER], adapter);
+  ctx.effect(() => () => server.close(), 'dsh-connect.shutdown');
+  ctx.inject(['webServer'], web => {
+    web.effect(() => web.webServer.register(controller.route), 'dsh-connect.settings');
+  });
+}
+export default { name, inject, apply };

package/src/login.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { mkdir } from 'node:fs/promises';
+import { runtime } from './runtime.js';
+import { safeMessage } from './errors.js';
+
+try {
+  const launch = runtime();
+  await mkdir(launch.env.CODEX_HOME, { recursive: true, mode: 0o700 });
+  const args = process.argv.slice(2);
+  const child = spawn(launch.command, ['login', ...args], { env: launch.env, stdio: 'inherit' });
+  child.on('error', error => { console.error(safeMessage(error)); process.exitCode = 1; });
+  child.on('exit', code => { process.exitCode = code ?? 1; });
+} catch (error) { console.error(safeMessage(error)); process.exitCode = 1; }

package/src/models.js

@@ -0,0 +1,54 @@
+import { PROVIDER } from './runtime.js';
+import { CodexError } from './errors.js';
+
+const basic = ['low', 'medium', 'high', 'xhigh'];
+// Fallback metadata was checked against the operator's working Codex catalog.
+// Live account metadata wins; catalog membership never gates a model request.
+export const CURATED = [
+  ['gpt-6-astra', 'GPT-6 Astra', [...basic, 'max']],
+  ['gpt-5.6-sol', 'GPT-5.6 Sol', [...basic, 'max']],
+  ['gpt-5.6-terra', 'GPT-5.6 Terra', [...basic, 'max']],
+  ['gpt-5.6-luna', 'GPT-5.6 Luna', [...basic, 'max']],
+  ['gpt-5.5', 'GPT-5.5', basic],
+  ['gpt-5.2', 'GPT-5.2', basic],
+].map(([id, name, efforts]) => ({ id, model: id, displayName: name, supportedReasoningEfforts: efforts.map(reasoningEffort => ({ reasoningEffort })), defaultReasoningEffort: 'medium' }));
+
+export class ModelCatalog {
+  live = [];
+  expires = 0;
+  source = 'curated';
+  discoveryIssue;
+  constructor(server, { ttlMs = 60_000 } = {}) { this.server = server; this.ttlMs = ttlMs; }
+  invalidate() { this.expires = 0; this.live = []; this.source = 'curated'; }
+  async refresh(signal, force = false) {
+    if (!force && this.expires > Date.now()) return;
+    try {
+      const live = await this.server.models(signal);
+      this.live = live.filter(m => typeof (m.model ?? m.id) === 'string' && !m.hidden);
+      this.discoveryIssue = this.live.length ? undefined : 'Account discovery returned no models; curated models remain available.';
+      this.source = this.live.length ? 'account + curated' : 'curated';
+    } catch (error) {
+      if (signal?.aborted) throw error;
+      this.discoveryIssue = 'Account model discovery is unavailable; using the saved and curated list.';
+      this.source = this.live.length ? 'cached + curated' : 'curated';
+    }
+    this.expires = Date.now() + this.ttlMs;
+  }
+  entries() {
+    const merged = new Map(CURATED.map(m => [m.model, m]));
+    for (const m of this.live) merged.set(m.model ?? m.id, { ...merged.get(m.model ?? m.id), ...m });
+    return [...merged.values()];
+  }
+  info(m) {
+    return { provider: PROVIDER, id: m.model ?? m.id, name: m.displayName ?? m.model ?? m.id, inputModalities: ['text'] };
+  }
+  async list(signal) { await this.refresh(signal); return this.entries().map(m => this.info(m)); }
+  async resolve(provider, id, signal) {
+    signal?.throwIfAborted();
+    if (provider !== PROVIDER || typeof id !== 'string' || !id.trim()) throw new CodexError('A valid Codex provider and model ID are required.', 'INVALID_REQUEST');
+    await this.refresh(signal);
+    const m = this.entries().find(m => m.model === id || m.id === id) ?? { id };
+    const efforts = (m.supportedReasoningEfforts ?? []).filter(e => typeof e.reasoningEffort === 'string').map(e => ({ id: e.reasoningEffort, name: e.reasoningEffort, ...(e.description ? { description: e.description } : {}) }));
+    return { ...this.info(m), id, ...(efforts.length ? { reasoning: { efforts, ...(efforts.some(e => e.id === m.defaultReasoningEffort) ? { defaultEffort: m.defaultReasoningEffort } : {}) } } : {}) };
+  }
+}

package/src/runtime.js

@@ -0,0 +1,44 @@
+import { accessSync, constants, existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { delimiter, join, resolve } from 'node:path';
+import { CodexError } from './errors.js';
+
+export const VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+export const PROVIDER = 'openai-codex';
+export function configuration(env = process.env) {
+  const file = env.DSH_CONNECT_CONFIG || join(env.DSH_HOME || join(homedir(), '.dsh'), 'connect.json');
+  if (!existsSync(file)) return {};
+  try {
+    const config = JSON.parse(readFileSync(file, 'utf8'));
+    if (!config || Array.isArray(config) || typeof config !== 'object') throw new Error();
+    for (const key of Object.keys(config)) {
+      if (!['codexBin', 'codexHome', 'noProxy'].includes(key) || typeof config[key] !== 'string') throw new Error();
+    }
+    return config;
+  } catch { throw new CodexError('Invalid DSH Connect configuration. Expected an object containing codexBin, codexHome or noProxy strings.', 'INVALID_CONFIG'); }
+}
+export function codexHome(env = process.env, config = configuration(env)) {
+  const configured = env.DSH_CODEX_HOME?.trim() || config.codexHome;
+  return configured ? resolve(configured) : join(homedir(), '.deepseek-harness', 'codex');
+}
+export function runtime(env = process.env) {
+  const config = configuration(env);
+  const explicit = env.DSH_CODEX_BIN?.trim() || config.codexBin;
+  const candidates = explicit ? [resolve(explicit)] : (env.PATH || '').split(delimiter).filter(Boolean).map(dir => join(dir, process.platform === 'win32' ? 'codex.exe' : 'codex'));
+  const command = candidates.find(path => { try { accessSync(path, constants.X_OK); return true; } catch { return false; } });
+  if (!command) throw new CodexError('Codex executable not found. Install the official Codex CLI or set DSH_CODEX_BIN to its executable path.', 'CODEX_BINARY_MISSING');
+  const childEnv = { ...env, CODEX_HOME: codexHome(env, config) };
+  const extraNoProxy = env.DSH_CONNECT_NO_PROXY ?? config.noProxy;
+  if (extraNoProxy) {
+    const noProxy = [...new Set([env.NO_PROXY, env.no_proxy, extraNoProxy].filter(Boolean).flatMap(s => s.split(',')).map(s => s.trim()).filter(Boolean))].join(',');
+    childEnv.NO_PROXY = noProxy;
+    childEnv.no_proxy = noProxy;
+  }
+  return { command, env: childEnv };
+}
+// Harness owns tool execution, its permission checks, and agent delegation.
+export const CODEX_ARGS = [
+  ...['shell_tool', 'goals', 'apps', 'browser_use', 'computer_use', 'hooks', 'image_generation', 'in_app_browser', 'multi_agent', 'plugins', 'skill_search', 'tool_suggest', 'unified_exec', 'workspace_dependencies']
+    .flatMap(feature => ['-c', `features.${feature}=false`]),
+  '-c', 'web_search="disabled"', '-c', 'agents.enabled=false', '-c', 'tools.view_image=false', '-c', 'project_doc_max_bytes=0',
+];

package/src/transport.js

@@ -0,0 +1,191 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { mkdir } from 'node:fs/promises';
+import { abortable, CodexError } from './errors.js';
+import { runtime, CODEX_ARGS, VERSION } from './runtime.js';
+
+export class EventQueue {
+  values = [];
+  waiters = [];
+  error;
+  push(value) {
+    if (this.error) return;
+    if (this.waiters.length) this.waiters.shift().resolve(value);
+    else if (this.values.length >= 4096) this.fail(new CodexError('Codex event queue overflowed; retry the turn.', 'PROTOCOL_ERROR'));
+    else this.values.push(value);
+  }
+  fail(error) {
+    this.error = error;
+    this.values = [];
+    for (const waiter of this.waiters.splice(0)) waiter.reject(error);
+  }
+  take(signal) {
+    signal?.throwIfAborted();
+    if (this.error) return Promise.reject(this.error);
+    if (this.values.length) return Promise.resolve(this.values.shift());
+    return new Promise((resolve, reject) => {
+      const finish = (fn, value) => {
+        signal?.removeEventListener('abort', abort);
+        this.waiters = this.waiters.filter(entry => entry !== waiter);
+        fn(value);
+      };
+      const waiter = { resolve: value => finish(resolve, value), reject: error => finish(reject, error) };
+      const abort = () => waiter.reject(signal.reason);
+      this.waiters.push(waiter);
+      signal?.addEventListener('abort', abort, { once: true });
+    });
+  }
+}
+
+export class AppServer {
+  child;
+  starting;
+  generation = 0;
+  nextId = 1;
+  pending = new Map();
+  queues = new Map();
+  retired = new Set();
+  lastFailure;
+  stderrBytes = 0;
+  constructor({ launch, requestTimeoutMs = 30_000 } = {}) {
+    this.launch = launch ?? (() => { const r = runtime(); return { ...r, args: [...CODEX_ARGS, 'app-server', '--stdio'], cwd: r.env.CODEX_HOME }; });
+    this.requestTimeoutMs = requestTimeoutMs;
+  }
+  async start(signal) {
+    if (!this.starting) {
+      const start = this.boot();
+      this.starting = start;
+      start.catch(() => { if (this.starting === start) this.starting = undefined; });
+    }
+    return abortable(this.starting, signal);
+  }
+  async boot() {
+    const launch = this.launch();
+    if (launch.cwd) await mkdir(launch.cwd, { recursive: true, mode: 0o700 });
+    const child = spawn(launch.command, launch.args, { cwd: launch.cwd, env: launch.env, stdio: ['pipe', 'pipe', 'pipe'] });
+    this.child = child;
+    this.generation++;
+    this.retired.clear();
+    this.queues.clear();
+    this.stderrBytes = 0;
+    const lines = createInterface({ input: child.stdout });
+    lines.on('line', line => {
+      if (this.child !== child) return;
+      try { this.receive(JSON.parse(line)); }
+      catch { this.fail(child, new CodexError('Codex sent malformed protocol data. Retry to start a fresh process.', 'PROTOCOL_ERROR')); }
+    });
+    // Native stderr can contain request data or credentials. Never relay it to DSH logs.
+    child.stderr.on('data', chunk => { this.stderrBytes += chunk.length; });
+    child.on('error', () => this.fail(child, new CodexError('Could not start the managed Codex executable.', 'CODEX_START_FAILED')));
+    child.stdin.on('error', () => this.fail(child, new CodexError('Codex input pipe closed.', 'CODEX_DISCONNECTED')));
+    child.on('exit', (code, signal) => this.fail(child, new CodexError(`Codex exited (${signal ?? code ?? 'unknown'}). Retry to reconnect.`, 'CODEX_DISCONNECTED')));
+    try {
+      await this.rpc('initialize', { clientInfo: { name: 'dsh_connect', title: 'DSH Connect', version: VERSION }, capabilities: { experimentalApi: true } });
+      this.send({ method: 'initialized', params: {} });
+      this.lastFailure = undefined;
+    } catch (error) { this.fail(child, error); throw error; }
+  }
+  fail(child, error) {
+    if (this.child !== child) return;
+    this.child = undefined;
+    this.starting = undefined;
+    this.lastFailure = error.message;
+    for (const pending of [...this.pending.values()]) pending.reject(error);
+    for (const queue of this.queues.values()) queue.fail(error);
+    child.kill();
+    const timer = setTimeout(() => { if (child.exitCode === null && child.signalCode === null) child.kill('SIGKILL'); }, 2000);
+    timer.unref();
+  }
+  send(message) {
+    if (!this.child || !this.child.stdin.writable) throw new CodexError('Codex is disconnected.', 'CODEX_DISCONNECTED');
+    this.child.stdin.write(JSON.stringify(message) + '\n');
+  }
+  rpc(method, params, signal, timeoutMs = this.requestTimeoutMs) {
+    signal?.throwIfAborted();
+    return new Promise((resolve, reject) => {
+      const id = this.nextId++;
+      const finish = (fn, value) => {
+        clearTimeout(timer);
+        signal?.removeEventListener('abort', abort);
+        this.pending.delete(id);
+        fn(value);
+      };
+      const abort = () => finish(reject, signal.reason);
+      const timer = setTimeout(() => finish(reject, new CodexError(`Codex ${method} timed out.`, 'CODEX_TIMEOUT')), timeoutMs);
+      this.pending.set(id, { resolve: value => finish(resolve, value), reject: error => finish(reject, error) });
+      signal?.addEventListener('abort', abort, { once: true });
+      try { this.send({ id, method, params }); }
+      catch (error) { finish(reject, error); }
+    });
+  }
+  async request(method, params = {}, signal, timeoutMs) {
+    await this.start(signal);
+    return this.rpc(method, params, signal, timeoutMs);
+  }
+  receive(message) {
+    if (!message || typeof message !== 'object') throw new Error('Invalid message');
+    if (!message.method && message.id !== undefined) {
+      const pending = this.pending.get(message.id);
+      if (message.error) pending?.reject(new CodexError(message.error.message ?? 'Codex rejected the request.', 'CODEX_RPC_ERROR'));
+      else pending?.resolve(message.result);
+      return;
+    }
+    const { method, params = {}, id } = message;
+    if (typeof method !== 'string') return;
+    if (id !== undefined && method !== 'item/tool/call') {
+      this.send({ id, error: { code: -32601, message: 'This provider supports Harness dynamic tools only.' } });
+      return;
+    }
+    const threadId = params.threadId;
+    if (typeof threadId !== 'string') return;
+    if (this.retired.has(threadId)) {
+      if (id !== undefined) this.respond(id, { contentItems: [{ type: 'inputText', text: 'Turn was cancelled.' }], success: false });
+      return;
+    }
+    this.queue(threadId).push({ method, params, requestId: id });
+  }
+  queue(id) {
+    if (!this.queues.has(id)) this.queues.set(id, new EventQueue());
+    return this.queues.get(id);
+  }
+  nextEvent(id, signal) { return this.queue(id).take(signal); }
+  respond(id, result) { this.send({ id, result }); }
+  async account(signal) { return (await this.request('account/read', { refreshToken: false }, signal)).account; }
+  async models(signal) {
+    const models = [];
+    let cursor;
+    const seen = new Set();
+    do {
+      const result = await this.request('model/list', { limit: 100, ...(cursor ? { cursor } : {}) }, signal);
+      models.push(...(result.data ?? []));
+      cursor = result.nextCursor;
+      if (cursor && seen.has(cursor)) throw new CodexError('Codex model pagination repeated a cursor.', 'PROTOCOL_ERROR');
+      seen.add(cursor);
+    } while (cursor);
+    return models;
+  }
+  async startThread(params, signal) {
+    const result = await this.request('thread/start', params, signal);
+    if (typeof result.thread?.id !== 'string') throw new CodexError('Codex returned no thread ID.', 'PROTOCOL_ERROR');
+    this.queue(result.thread.id);
+    return result.thread.id;
+  }
+  async startTurn(threadId, params, signal) {
+    const result = await this.request('turn/start', { threadId, ...params }, signal);
+    if (typeof result.turn?.id !== 'string') throw new CodexError('Codex returned no turn ID.', 'PROTOCOL_ERROR');
+    return result.turn.id;
+  }
+  interrupt(threadId, turnId) { return this.request('turn/interrupt', { threadId, turnId }, undefined, 5000); }
+  async release(threadId, turnId) {
+    this.retired.add(threadId);
+    if (this.retired.size > 1024) this.retired.delete(this.retired.values().next().value);
+    this.queues.get(threadId)?.fail(new CodexError('Thread was released.', 'ABORTED'));
+    this.queues.delete(threadId);
+    if (!this.child) return;
+    if (turnId) await this.interrupt(threadId, turnId).catch(() => {});
+    await this.request('thread/unsubscribe', { threadId }, undefined, 5000).catch(() => {});
+  }
+  close() {
+    if (this.child) this.fail(this.child, new CodexError('Codex provider stopped.', 'CODEX_DISCONNECTED'));
+  }
+}