@harness-mix/cli 0.1.4 → 0.1.5

package/src/main/native/codex-accounts.js

@@ -0,0 +1,260 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { randomUUID } = require('node:crypto');
+const { CodexAppServer } = require('../adapters/codex-app-server');
+
+const OFFICIAL_ACCOUNT_ID = 'official-codex';
+const ACCOUNT_ID = /^[A-Za-z0-9._~-]{1,256}$/;
+const PLAN_TYPES = new Set(['free', 'go', 'plus', 'pro', 'prolite', 'team', 'self_serve_business_prolite', 'self_serve_business_usage_based', 'business', 'ent26', 'enterprise_cbp_automation', 'enterprise_cbp_usage_based', 'enterprise', 'edu', 'edu_plus', 'edu_pro', 'unknown']);
+
+function isoFromUnixSeconds(value) {
+  return Number.isSafeInteger(value) && value >= 0 ? new Date(value * 1000).toISOString() : undefined;
+}
+
+function rateLimitView(result) {
+  const snapshot = result?.rateLimits;
+  const primary = snapshot?.primary;
+  const secondary = snapshot?.secondary;
+  const usage = {};
+  if (typeof primary?.usedPercent === 'number' && primary.usedPercent >= 0 && primary.usedPercent <= 100) {
+    usage.planFiveHourUsedPercent = primary.usedPercent;
+    if (Number.isSafeInteger(primary.resetsAt) && primary.resetsAt >= 0) usage.planFiveHourResetsAtUnix = primary.resetsAt;
+  }
+  if (typeof secondary?.usedPercent === 'number' && secondary.usedPercent >= 0 && secondary.usedPercent <= 100) {
+    usage.planSevenDayUsedPercent = secondary.usedPercent;
+    if (Number.isSafeInteger(secondary.resetsAt) && secondary.resetsAt >= 0) usage.planSevenDayResetsAtUnix = secondary.resetsAt;
+  }
+  let accountCredits;
+  if (typeof primary?.usedPercent === 'number' && primary.usedPercent >= 0 && primary.usedPercent <= 100) {
+    accountCredits = {
+      usedPercent: primary.usedPercent,
+      periodType: primary.windowDurationMins === 300 ? 'five_hour' : 'unknown',
+      ...(isoFromUnixSeconds(primary.resetsAt) ? { resetsAt: isoFromUnixSeconds(primary.resetsAt) } : {}),
+    };
+    if (typeof secondary?.usedPercent === 'number' && secondary.usedPercent >= 0 && secondary.usedPercent <= 100) {
+      accountCredits.productUsage = [{
+        product: secondary.windowDurationMins === 10080 ? '7-day window' : (snapshot.limitName || 'Secondary limit'),
+        usagePercent: secondary.usedPercent,
+        ...(isoFromUnixSeconds(secondary.resetsAt) ? { resetsAt: isoFromUnixSeconds(secondary.resetsAt) } : {}),
+      }];
+    }
+    const reset = result?.rateLimitResetCredits;
+    if (Number.isSafeInteger(reset?.availableCount) && reset.availableCount > 0) {
+      const expiresAt = Array.isArray(reset.credits)
+        ? reset.credits.map(credit => isoFromUnixSeconds(credit?.expiresAt)).filter(Boolean).slice(0, 32)
+        : [];
+      accountCredits.resetCredits = {
+        availableCount: reset.availableCount,
+        ...(expiresAt.length ? { nextExpiresAt: expiresAt[0], expiresAt } : {}),
+      };
+    }
+  }
+  return { usage: Object.keys(usage).length ? usage : null, ...(accountCredits ? { accountCredits } : {}) };
+}
+
+function accountIdentity(account) {
+  const email = account?.type === 'chatgpt' && typeof account.email === 'string' && account.email.trim()
+    ? account.email.trim() : undefined;
+  const planType = account?.type === 'chatgpt' && PLAN_TYPES.has(account.planType) ? account.planType : undefined;
+  return { email, planType, authenticated: !!account };
+}
+
+class CodexAccountManager {
+  constructor({ dataDirectory, requestOfficial, emit, acquireServer = CodexAppServer.acquire }) {
+    this.root = path.resolve(dataDirectory, 'codex-accounts');
+    this.profilesRoot = path.join(this.root, 'profiles');
+    this.registryFile = path.join(this.root, 'accounts.json');
+    this.requestOfficial = requestOfficial;
+    this.emit = emit;
+    this.acquireServer = acquireServer;
+    this.logins = new Map();
+    this.registry = this.#load();
+  }
+
+  #load() {
+    try {
+      const value = JSON.parse(fs.readFileSync(this.registryFile, 'utf8'));
+      const seen = new Set();
+      const accounts = (Array.isArray(value.accounts) ? value.accounts : []).filter(entry => {
+        if (!entry || !ACCOUNT_ID.test(entry.accountId) || typeof entry.label !== 'string' || !entry.label.trim() || entry.accountId === OFFICIAL_ACCOUNT_ID || seen.has(entry.accountId)) return false;
+        seen.add(entry.accountId);
+        entry.label = entry.label.trim().slice(0, 256);
+        return true;
+      }).slice(0, 127);
+      const activeAccountId = value.activeAccountId === OFFICIAL_ACCOUNT_ID || accounts.some(entry => entry.accountId === value.activeAccountId)
+        ? value.activeAccountId : OFFICIAL_ACCOUNT_ID;
+      return { version: 1, activeAccountId, accounts };
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+      return { version: 1, activeAccountId: OFFICIAL_ACCOUNT_ID, accounts: [] };
+    }
+  }
+
+  #save() {
+    fs.mkdirSync(this.root, { recursive: true });
+    const temp = `${this.registryFile}.${process.pid}.tmp`;
+    fs.writeFileSync(temp, JSON.stringify(this.registry, null, 2));
+    fs.renameSync(temp, this.registryFile);
+  }
+
+  #entry(accountId) {
+    if (accountId === OFFICIAL_ACCOUNT_ID) return { accountId, label: 'Codex 官方账号', codexHome: process.env.CODEX_HOME || path.join(os.homedir(), '.codex'), native: true };
+    const entry = this.registry.accounts.find(candidate => candidate.accountId === accountId);
+    if (!entry) throw new Error('Unknown Codex account');
+    const codexHome = path.resolve(this.profilesRoot, entry.accountId);
+    if (!codexHome.startsWith(`${path.resolve(this.profilesRoot)}${path.sep}`)) throw new Error('Invalid Codex account directory');
+    return { ...entry, codexHome, native: false };
+  }
+
+  async #request(entry, method, params) {
+    if (entry.native) {
+      if (!this.requestOfficial) throw new Error('Official Codex account service is unavailable');
+      return this.requestOfficial(method, params);
+    }
+    const server = await this.acquireServer(undefined, entry.codexHome);
+    try { return await server.request(method, params); }
+    finally { server.release(); }
+  }
+
+  async #summary(entry, refreshToken = false) {
+    let raw = null;
+    try { raw = await this.#request(entry, 'account/read', { refreshToken }); }
+    catch { /* A signed-out profile is still a useful selectable Account slot. */ }
+    const identity = accountIdentity(raw?.account);
+    return {
+      accountId: entry.accountId,
+      label: identity.email || entry.label,
+      ...(identity.email ? { email: identity.email } : {}),
+      ...(identity.planType ? { planType: identity.planType } : {}),
+      codexHome: entry.codexHome,
+      active: this.registry.activeAccountId === entry.accountId,
+      isDefault: entry.native,
+      authenticated: identity.authenticated,
+      management: entry.native ? 'native' : 'isolated',
+    };
+  }
+
+  async list(refresh = false) {
+    const entries = [this.#entry(OFFICIAL_ACCOUNT_ID), ...this.registry.accounts.map(entry => this.#entry(entry.accountId))];
+    return { accounts: await Promise.all(entries.map(entry => this.#summary(entry, refresh))) };
+  }
+
+  async create(label) {
+    if (this.registry.accounts.length >= 127) throw new Error('Codex Account limit reached (128 including the official account)');
+    const accountId = `account-${randomUUID().slice(0, 8)}`;
+    const entry = { accountId, label: typeof label === 'string' && label.trim() ? label.trim().slice(0, 256) : `Codex 账号 ${this.registry.accounts.length + 2}`, createdAt: Date.now() };
+    fs.mkdirSync(path.join(this.profilesRoot, accountId), { recursive: true });
+    this.registry.accounts.push(entry);
+    this.#save();
+    return { account: await this.#summary(this.#entry(accountId)) };
+  }
+
+  async activate(accountId) {
+    const entry = this.#entry(accountId);
+    this.registry.activeAccountId = entry.accountId;
+    this.#save();
+    return { account: await this.#summary(entry) };
+  }
+
+  async delete(accountId) {
+    const entry = this.#entry(accountId);
+    if (entry.native) throw new Error('The official Codex account cannot be deleted');
+    if ([...this.logins.values()].some(login => login.accountId === accountId)) throw new Error('Cancel account sign-in before deleting it');
+    const resolved = path.resolve(entry.codexHome);
+    const root = path.resolve(this.profilesRoot);
+    if (!resolved.startsWith(`${root}${path.sep}`)) throw new Error('Refusing to delete an account outside the managed profile directory');
+    fs.rmSync(resolved, { recursive: true, force: true });
+    this.registry.accounts = this.registry.accounts.filter(candidate => candidate.accountId !== accountId);
+    if (this.registry.activeAccountId === accountId) this.registry.activeAccountId = OFFICIAL_ACCOUNT_ID;
+    this.#save();
+    return { deletedAccountId: accountId };
+  }
+
+  async startLogin(accountId) {
+    const entry = this.#entry(accountId);
+    if (entry.native) {
+      const result = await this.#request(entry, 'account/login/start', { type: 'chatgptDeviceCode' });
+      return { accountId, loginId: result.loginId, verificationUrl: result.verificationUrl, userCode: result.userCode };
+    }
+    const server = await this.acquireServer(undefined, entry.codexHome);
+    let unwatch;
+    try {
+      unwatch = server.onNotification(message => {
+        if (message?.method !== 'account/login/completed') return;
+        const pending = this.logins.get(message.params?.loginId);
+        if (!pending || pending.server !== server) return;
+        this.logins.delete(message.params.loginId);
+        pending.unwatch?.();
+        pending.server.release();
+        this.emit?.({ method: 'codexhost/account/login/completed', params: {
+          accountId: pending.accountId,
+          loginId: message.params.loginId,
+          success: message.params.success === true,
+          error: typeof message.params.error === 'string' ? message.params.error : null,
+        } });
+      });
+      const result = await server.request('account/login/start', { type: 'chatgptDeviceCode' });
+      this.logins.set(result.loginId, { accountId, server, unwatch });
+      return { accountId, loginId: result.loginId, verificationUrl: result.verificationUrl, userCode: result.userCode };
+    } catch (error) {
+      unwatch?.();
+      server.release();
+      throw error;
+    }
+  }
+
+  async cancelLogin(loginId) {
+    const pending = this.logins.get(loginId);
+    if (!pending) {
+      if (!this.requestOfficial) return { cancelled: false };
+      const result = await this.requestOfficial('account/login/cancel', { loginId });
+      return { cancelled: ['canceled', 'cancelled'].includes(result?.status) };
+    }
+    const result = await pending.server.request('account/login/cancel', { loginId });
+    this.logins.delete(loginId);
+    pending.unwatch?.();
+    pending.server.release();
+    return { cancelled: ['canceled', 'cancelled'].includes(result?.status) };
+  }
+
+  async usage(accountId) {
+    const entry = this.#entry(accountId);
+    return { accountId, ...rateLimitView(await this.#request(entry, 'account/rateLimits/read', {})) };
+  }
+
+  async consumeReset(accountId, idempotencyKey) {
+    const entry = this.#entry(accountId);
+    const result = await this.#request(entry, 'account/rateLimitResetCredit/consume', { idempotencyKey: idempotencyKey || randomUUID() });
+    const refreshed = rateLimitView(await this.#request(entry, 'account/rateLimits/read', {}));
+    return { accountId, outcome: result.outcome, ...(refreshed.accountCredits ? { accountCredits: refreshed.accountCredits } : {}) };
+  }
+
+  signedOutOfficial() {
+    const entry = this.#entry(OFFICIAL_ACCOUNT_ID);
+    return {
+      account: {
+        accountId: entry.accountId,
+        label: entry.label,
+        codexHome: entry.codexHome,
+        active: this.registry.activeAccountId === entry.accountId,
+        isDefault: true,
+        authenticated: false,
+        management: 'native',
+      },
+    };
+  }
+
+  executionContext(accountId) {
+    const entry = this.#entry(accountId);
+    if (entry.native) throw new Error('The official account stays on the native Codex route');
+    return { accountId: entry.accountId, codexHome: entry.codexHome };
+  }
+
+  close() {
+    for (const pending of this.logins.values()) { pending.unwatch?.(); pending.server.release(); }
+    this.logins.clear();
+  }
+}
+
+module.exports = { CodexAccountManager, OFFICIAL_ACCOUNT_ID, rateLimitView };

package/src/main/native/host.js

@@ -148,6 +148,6 @@ async function runNativeHost() {
   official.on('error', error => { console.error(error); void close(); });
   official.on('exit', () => { void close(); });
   await ready;
-  console.error('[Harness Mix] native protocol -> local HostRuntime -> local ProtocolCore');
+  console.error('[Harness Mix] official Codex passthrough + external Harness routes via HostRuntime/ProtocolCore');
 }
 module.exports = { runNativeHost };

package/src/main/native/launcher.js

@@ -120,7 +120,7 @@ async function launch(args = []) {
   const paths = nativePaths();
   for (const file of Object.values(paths)) if (!fs.existsSync(file)) throw new Error(`Missing ${file}; run npm run build:native`);
   if (flags.has('--check')) {
-    console.log(`platform=${process.platform}\narchitecture=${process.arch}\ndesktop_version=${installation.version}\ndesktop_compatibility=${compatibility.state}\ndesktop_evidence=${compatibility.evidence?.level || 'none'}\nexecutable_codex_cli=${installation.stock}\nlauncher=${paths.cli}\nshim=${paths.shim}\nruntime=${paths.runtime}\nrenderer=${paths.renderer}\ncore=src/main/protocol-core`);
+    console.log(`platform=${process.platform}\narchitecture=${process.arch}\ndesktop_version=${installation.version}\ndesktop_compatibility=${compatibility.state}\ndesktop_evidence=${compatibility.evidence?.level || 'none'}\nexecutable_codex_cli=${installation.stock}\ncodex_mode=official-passthrough\ncodex_managed_route=codex-harness\nlauncher=${paths.cli}\nshim=${paths.shim}\nruntime=${paths.runtime}\nrenderer=${paths.renderer}\ncore=src/main/protocol-core`);
     return;
   }
   const skipUpdate = flags.has('--no-update') || process.env.HARNESS_MIX_AUTO_UPDATE === '0';
@@ -151,7 +151,7 @@ async function launch(args = []) {
     CODEXHOST_DATA_DIR: env.CODEXHOST_DATA_DIR, HARNESS_MIX_NODE_PATH: process.execPath,
     CODEXHOST_DEFAULT_AGENT: 'codex' };
   const block = Buffer.from(Object.entries(overrides).map(([k, v]) => `${k}=${v}`).join('\0') + '\0\0', 'utf16le').toString('base64');
-  console.log('[Harness Mix] Restarting Codex Desktop with the local Shim and ProtocolCore.');
+  console.log('[Harness Mix] Restarting Codex Desktop: official Codex passthrough + Harness Mix routes.');
   stopDesktopProcesses(installation);
   await new Promise(resolve => setTimeout(resolve, 1000));
   sweepLeftovers(root, dataDir);

package/src/main/native/protocol.js

@@ -20,7 +20,8 @@ const {
   compareVersions,
   readState,
 } = require('./update-state');
-const { nativeEnvironment } = require('./config');
+const { nativeEnvironment } = require('./config');
+const { CodexAccountManager } = require('./codex-accounts');
 
 const REPO_ROOT = path.resolve(__dirname, '../../..');
 const PACKAGE_JSON_PATH = path.join(REPO_ROOT, 'package.json');
@@ -31,9 +32,8 @@ const modelRef = model => ({ id: Buffer.from(JSON.stringify({ id: model.id, prov
 const routeModel = harnessId => ['pi', 'claude-code', 'deepseek-harness', 'antigravity', 'omp', 'opencode', 'grok'].includes(harnessId)
   ? `codexhost/${harnessId}-native`
   : `codexhost/plugin-v1@${Buffer.from(JSON.stringify({ harnessId })).toString('hex')}`;
-const terminal = status => ['completed', 'cancelled', 'error', 'failed'].includes(status);
-const turnStatus = status => ({ cancelled: 'interrupted', error: 'failed', failed: 'failed', completed: 'completed' }[status] || 'inProgress');
-
+const terminal = status => ['completed', 'cancelled', 'error', 'failed'].includes(status);
+const turnStatus = status => ({ cancelled: 'interrupted', error: 'failed', failed: 'failed', completed: 'completed' }[status] || 'inProgress');
 const HARNESS_INSTALL_COMMANDS = {
   qoder: { win32: 'npm install -g @qoder-ai/qodercli', default: 'npm install -g @qoder-ai/qodercli' },
   codex: { win32: 'npm install -g @openai/codex', default: 'npm install -g @openai/codex' },
@@ -189,10 +189,15 @@ function projectItem(item) {
 }
 
 class NativeProtocol {
-  constructor(runtime, emit, requestOfficial = null) {
+  constructor(runtime, emit, requestOfficial = null) {
     this.runtime = runtime;
     this.emit = emit;
-    this.requestOfficial = requestOfficial;
+    this.requestOfficial = requestOfficial;
+    this.codexAccounts = new CodexAccountManager({
+      dataDirectory: nativeEnvironment().CODEXHOST_DATA_DIR,
+      requestOfficial,
+      emit,
+    });
     this.approvals = new Map();
     this.published = new Map();
     this.steering = new Map();      // threadId -> in-flight steer promise
@@ -317,13 +322,34 @@ class NativeProtocol {
     if (!model) throw new Error('Selected model is no longer in the native catalog');
     return model;
   }
-  async request(method, params = {}) {
+  async request(method, params = {}) {
+    if (method === 'codexhost/integrations/catalog') return this.runtime.integrations.catalog();
+    if (method === 'codexhost/integrations/list') return this.runtime.integrations.list(params);
+    if (method === 'codexhost/integrations/mcp/save') return this.runtime.integrations.save(params);
+    if (method === 'codexhost/integrations/mcp/remove') return this.runtime.integrations.remove(params);
+    if (method === 'codexhost/integrations/skill/change') return this.runtime.integrations.skillChange(params);
     if (method === 'codexhost/harness/session-import/sources') return this.runtime.history.sources();
     if (method === 'codexhost/harness/session-import/list') return this.runtime.history.list(params);
     if (method === 'codexhost/harness/session-import/import') return this.runtime.history.import(params);
     if (method === 'codexhost/collaboration/agents') return [...this.runtime.adapters.values()].map(a => ({ id: externalId(a.manifest.id), name: a.manifest.name, available: !!this.runtime.status[a.manifest.id]?.available, lead: a.manifest.capabilities?.collaborationTools === true }));
     const thread = this.thread(params.threadId);
-    if (method === 'harness-mix/runtime/inspect') return { owner: 'harness-mix', runtime: 'src/main/host/runtime.js', core: 'src/main/protocol-core/protocol-core.js', threads: this.runtime.threads.length };
+    if (method === 'harness-mix/runtime/inspect') return {
+      owner: 'harness-mix',
+      runtime: 'src/main/host/runtime.js',
+      core: 'src/main/protocol-core/protocol-core.js',
+      threads: this.runtime.threads.length,
+      codex: {
+        mode: 'official-passthrough',
+        // `codex` remains owned by the stock app-server. Only the explicit
+        // `codex-harness` route creates a HostRuntime-managed Codex worker.
+        managedRoute: 'codex-harness',
+      },
+    };
+    if (method === 'harness-mix/runtime/version') {
+      let version = '0.0.0';
+      try { version = JSON.parse(fs.readFileSync(PACKAGE_JSON_PATH, 'utf8')).version || version; } catch {}
+      return { version };
+    }
     // Updates
     if (method === 'codexhost/update/check') {
       const dataDir = nativeEnvironment().CODEXHOST_DATA_DIR;
@@ -429,8 +455,22 @@ class NativeProtocol {
       return { status: null };
     }
 
-    // No additional managed accounts: native Codex keeps its own signed-in account.
-    if (method === 'codexhost/account/list' || method === 'codexhost/account/refresh') return { accounts: [] };
+    // Each extra Account is an isolated native CODEX_HOME. Harness Mix stores
+    // only the profile label/path; auth.json and token refresh remain owned by Codex.
+    if (method === 'codexhost/account/list') return this.codexAccounts.list(false);
+    if (method === 'codexhost/account/refresh') return this.codexAccounts.list(true);
+    if (method === 'codexhost/account/create') return this.codexAccounts.create(params.label);
+    if (method === 'codexhost/account/delete') return this.codexAccounts.delete(params.accountId);
+    if (method === 'codexhost/account/activate') return this.codexAccounts.activate(params.accountId);
+    if (method === 'codexhost/account/usage/inspect') return this.codexAccounts.usage(params.accountId);
+    if (method === 'codexhost/account/login/start') return this.codexAccounts.startLogin(params.accountId);
+    if (method === 'codexhost/account/login/cancel') return this.codexAccounts.cancelLogin(params.loginId);
+    if (method === 'codexhost/account/logout') {
+      if (!this.requestOfficial) throw new Error('Official Codex logout is unavailable');
+      await this.requestOfficial('account/logout', undefined);
+      return this.codexAccounts.signedOutOfficial();
+    }
+    if (method === 'codexhost/account/rate-limit-reset/consume') return this.codexAccounts.consumeReset(params.accountId, params.idempotencyKey);
     if (method === 'codexhost/harness/account/login') {
       const extId = params.harnessId;
       const meta = HARNESS_AUTH_INFO[extId] || HARNESS_AUTH_INFO[ALIASES[extId]];
@@ -569,17 +609,24 @@ class NativeProtocol {
         ...(usage ? { usage: projectUsage(usage) } : {}),
         ...(credits ? { accountCredits: credits } : {}) };
     }
-    if (method === 'thread/start') {
-      const route = decodeRoute(params.model);
-      if (!route) return undefined;
-      const id = ALIASES[route.harnessId] || route.harnessId;
-      if (!this.runtime.adapters.has(id)) throw new Error(`Unsupported Harness: ${id}`);
+    if (method === 'thread/start') {
+      const route = decodeRoute(params.model);
+      const accountContext = typeof params.__codexhostAccountId === 'string'
+        ? this.codexAccounts.executionContext(params.__codexhostAccountId) : null;
+      if (!route && !accountContext) return undefined;
+      const effectiveRoute = route || { harnessId: 'codex-harness', ...(typeof params.model === 'string' ? { model: { id: params.model } } : {}) };
+      const id = ALIASES[effectiveRoute.harnessId] || effectiveRoute.harnessId;
+      if (!this.runtime.adapters.has(id)) throw new Error(`Unsupported Harness: ${id}`);
       if (params.ephemeral && params.threadSource) throw new Error('Ephemeral background thread is not supported');
-      const isWorktree = params.worktree === true || params.options?.worktree === true;
-      const created = await this.runtime.createThread({ harnessId: id, cwd: params.cwd, ephemeral: params.ephemeral === true,
+      const isWorktree = params.worktree === true || params.options?.worktree === true;
+      const selectedModel = accountContext && typeof params.model === 'string'
+        ? (await this.runtime.describe(id)).models.find(model => model.id === params.model)
+        : await this.resolveModel(id, effectiveRoute.model);
+      const created = await this.runtime.createThread({ harnessId: id, cwd: params.cwd, ephemeral: params.ephemeral === true,
         worktree: isWorktree,
         options: {
-          model: await this.resolveModel(id, route.model), thinking: route.thinkingOptionId, permissionMode: route.permissionModeId,
+          model: selectedModel, thinking: effectiveRoute.thinkingOptionId, permissionMode: effectiveRoute.permissionModeId,
+          ...(accountContext || {}),
           ...(isWorktree ? { worktree: true } : {}),
         } });
       if (created.error) throw new Error(created.error);
@@ -696,10 +743,14 @@ class NativeProtocol {
       return this.configuration(thread);
     }
     // 原地切换 Harness：会话历史保留，下条消息携带一次性上下文信封（/switch 指令的 RPC 等价物）
-    if (method === 'codexhost/thread/harness/switch') {
-      await this.runtime.switchHarness(thread.id, ALIASES[params.harnessId] || params.harnessId, { note: typeof params.note === 'string' ? params.note : undefined });
-      return { threadId: thread.id };
-    }
+    if (method === 'codexhost/thread/harness/switch') {
+      await this.runtime.switchHarness(thread.id, ALIASES[params.harnessId] || params.harnessId, {
+        note: typeof params.note === 'string' ? params.note : undefined,
+        intent: params.intent,
+        includes: params.includes,
+      });
+      return { threadId: thread.id, checkpointId: thread.pendingHandoff.checkpointId };
+    }
     if (method === 'thread/fork' || method === 'codexhost/thread/fork') {
       if (params.ephemeral || params.threadSource || params.excludeTurns) {
         throw new Error('Ephemeral fork is not supported');
@@ -831,6 +882,6 @@ class NativeProtocol {
     this.approvals.delete(message.id);
     return true;
   }
-  close() { this.unsubscribe(); this.unsubscribeRuntime(); }
+  close() { this.codexAccounts.close(); this.unsubscribe(); this.unsubscribeRuntime(); }
 }
 module.exports = { NativeProtocol, decodeRoute, projectItem, externalId, routeModel };

package/src/main/native/redact.js

@@ -8,7 +8,7 @@ const PATTERNS = [
   /xox[abpsr]-[A-Za-z0-9-]{10,}/g,
   /eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g, // JWT
 ];
-const SECRET_KEY = /(token|secret|password|passwd|api[_-]?key|authorization|credential|cookie)/i;
+const SECRET_KEY = /(token|secret|password|passwd|api[_-]?key|authorization|credential|cookie|userCode|loginId|verificationUrl)/i;
 const REDACTED = '[redacted]';
 
 function redactText(value) {

package/src/main/native/rs/crates/shim/src/main.rs

@@ -1,8 +1,8 @@
 // Harness Mix executable bridge, built from this source by build-native.cjs.
 // Rust port of the original shim.cs: identical routing and stdio contract.
 //
-// - `... app-server ...`  -> node scripts/native-host.cjs (Harness Mix kernel)
-// - anything else         -> stock codex.exe passthrough
+// - a plain `app-server` invocation -> node scripts/native-host.cjs
+// - management subcommands and every other invocation -> stock Codex passthrough
 use std::env;
 use std::fs;
 use std::io::{self, Write};
@@ -103,12 +103,97 @@ fn rotate_log(dir: &Path) {
     let _ = fs::rename(&base, dir.join("shim-invocations.log.1"));
 }
 
-fn setting(env_name: &str, file: &Path) -> io::Result<String> {
-    match env::var(env_name) {
-        Ok(value) if !value.is_empty() => Ok(value),
-        _ => read_trimmed(file),
-    }
-}
+fn setting(env_name: &str, file: &Path) -> io::Result<String> {
+    match env::var(env_name) {
+        Ok(value) if !value.is_empty() => Ok(value),
+        _ => read_trimmed(file),
+    }
+}
+
+// Locate the real Codex subcommand without mistaking a prompt or config value
+// for one. Unknown global options deliberately fall back to the stock CLI, so
+// native Codex remains usable when a newer CLI adds syntax unknown to the Shim.
+fn app_server_subcommand_index(args: &[String]) -> Option<usize> {
+    const VALUE_OPTIONS: &[&str] = &[
+        "-c",
+        "--config",
+        "--enable",
+        "--disable",
+        "--profile",
+    ];
+    const FLAG_OPTIONS: &[&str] = &["--search", "--no-alt-screen", "--oss"];
+    let mut index = 0;
+    while let Some(arg) = args.get(index).map(String::as_str) {
+        if arg == "app-server" {
+            return Some(index);
+        }
+        if arg == "--" {
+            return None;
+        }
+        if VALUE_OPTIONS.contains(&arg) {
+            args.get(index + 1)?;
+            index += 2;
+            continue;
+        }
+        if VALUE_OPTIONS
+            .iter()
+            .any(|option| arg.strip_prefix(option).is_some_and(|rest| rest.starts_with('=')))
+            || FLAG_OPTIONS.contains(&arg)
+        {
+            index += 1;
+            continue;
+        }
+        return None;
+    }
+    None
+}
+
+// Only the app-server form used as the Desktop protocol endpoint belongs to
+// Harness Mix. `proxy`, `daemon`, and future management forms stay entirely
+// with the official CLI. Unknown app-server options also pass through.
+fn should_start_host_runtime(args: &[String]) -> bool {
+    const VALUE_OPTIONS: &[&str] = &[
+        "-c",
+        "--config",
+        "--enable",
+        "--disable",
+        "--listen",
+        "--ws-auth",
+        "--ws-token-file",
+        "--ws-token-sha256",
+        "--ws-shared-secret-file",
+        "--ws-issuer",
+        "--ws-audience",
+        "--ws-max-clock-skew-seconds",
+    ];
+    const FLAG_OPTIONS: &[&str] = &[
+        "--strict-config",
+        "--stdio",
+        "--analytics-default-enabled",
+    ];
+    let Some(mut index) = app_server_subcommand_index(args).map(|index| index + 1) else {
+        return false;
+    };
+    while let Some(arg) = args.get(index).map(String::as_str) {
+        if VALUE_OPTIONS.contains(&arg) {
+            if args.get(index + 1).is_none() {
+                return false;
+            }
+            index += 2;
+            continue;
+        }
+        if VALUE_OPTIONS
+            .iter()
+            .any(|option| arg.strip_prefix(option).is_some_and(|rest| rest.starts_with('=')))
+            || FLAG_OPTIONS.contains(&arg)
+        {
+            index += 1;
+            continue;
+        }
+        return false;
+    }
+    true
+}
 
 #[cfg(not(unix))]
 fn pump<R: Read + Send + 'static, W: Write + Send + 'static>(
@@ -129,7 +214,7 @@ fn run() -> io::Result<i32> {
     // Path.GetFullPath equivalent: normalize without resolving symlinks or adding \\?\.
     let root = std::path::absolute(exe_dir.join("../.."))?;
     let args: Vec<String> = env::args().skip(1).collect();
-    let server = args.iter().any(|arg| arg == "app-server");
+    let server = should_start_host_runtime(&args);
 
     rotate_log(exe_dir);
     // Kill-on-close job: the node host, every harness CLI it spawns and any
@@ -246,12 +331,70 @@ fn supervise(mut command: Command, exe_dir: &Path) -> io::Result<i32> {
     Ok(code)
 }
 
-fn main() {
+fn main() {
     match run() {
         Ok(code) => std::process::exit(code),
         Err(error) => {
             eprintln!("Harness Mix Shim: {error}");
             std::process::exit(1);
         }
-    }
-}
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{app_server_subcommand_index, should_start_host_runtime};
+
+    fn args(values: &[&str]) -> Vec<String> {
+        values.iter().map(|value| (*value).to_string()).collect()
+    }
+
+    #[test]
+    fn finds_only_the_real_app_server_subcommand() {
+        assert_eq!(app_server_subcommand_index(&args(&["app-server"])), Some(0));
+        assert_eq!(
+            app_server_subcommand_index(&args(&[
+                "-c",
+                "features.code_mode_host=true",
+                "app-server",
+                "--stdio",
+            ])),
+            Some(2)
+        );
+        assert_eq!(
+            app_server_subcommand_index(&args(&["exec", "say app-server"])),
+            None
+        );
+        assert_eq!(
+            app_server_subcommand_index(&args(&["-c", "app-server", "exec"])),
+            None
+        );
+        assert_eq!(app_server_subcommand_index(&args(&["--", "app-server"])), None);
+    }
+
+    #[test]
+    fn routes_only_plain_desktop_app_server_to_the_host() {
+        assert!(should_start_host_runtime(&args(&["app-server", "--stdio"])));
+        assert!(should_start_host_runtime(&args(&[
+            "-c",
+            "features.code_mode_host=true",
+            "app-server",
+            "--listen",
+            "stdio://",
+            "--analytics-default-enabled",
+        ])));
+        assert!(should_start_host_runtime(&args(&[
+            "app-server",
+            "--listen=ws://127.0.0.1:0",
+            "--ws-auth",
+            "token",
+        ])));
+        assert!(!should_start_host_runtime(&args(&["app-server", "proxy"])));
+        assert!(!should_start_host_runtime(&args(&["app-server", "daemon"])));
+        assert!(!should_start_host_runtime(&args(&[
+            "app-server",
+            "--future-option",
+        ])));
+        assert!(!should_start_host_runtime(&args(&["exec", "app-server"])));
+    }
+}