@harness-mix/cli 0.1.4 → 0.1.6

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

@@ -21,6 +21,7 @@ const {
   readState,
 } = require('./update-state');
 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');
@@ -33,7 +34,6 @@ const routeModel = harnessId => ['pi', 'claude-code', 'deepseek-harness', 'antig
   : `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 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' },
@@ -193,10 +193,16 @@ class NativeProtocol {
     this.runtime = runtime;
     this.emit = emit;
     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
     this.steerReceipts = new Map(); // `${threadId}\0${clientUserMessageId}` -> bounded delivery receipt
+    this.queues = new Map();        // threadId -> Array<{ id, input, clientUserMessageId, createdAt }>
     this.unsubscribe = runtime.core.subscribe(({ event, projected }) => this.onCore(event, projected));
     // Host 侧新建的线程（协作子任务等）也要通知 Desktop 侧栏，与 thread/start 同一契约
     this.unsubscribeRuntime = runtime.subscribe(event => {
@@ -206,6 +212,13 @@ class NativeProtocol {
       }
     });
   }
+  getQueue(threadId) {
+    if (!this.queues.has(threadId)) this.queues.set(threadId, []);
+    return this.queues.get(threadId);
+  }
+  emitQueueChanged(threadId) {
+    this.emit({ method: 'thread/queue/changed', params: { threadId } });
+  }
   thread(id) { return this.runtime.threads.find(t => t.id === id); }
   owns(id) { return Boolean(this.thread(id)); }
   turn(turn) { return { id: turn.id, status: turnStatus(turn.status), error: turn.error ? { message: String(turn.error), codexErrorInfo: null, additionalDetails: null } : null,
@@ -318,12 +331,33 @@ class NativeProtocol {
     return model;
   }
   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 +463,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]];
@@ -571,15 +619,22 @@ class NativeProtocol {
     }
     if (method === 'thread/start') {
       const route = decodeRoute(params.model);
-      if (!route) return undefined;
-      const id = ALIASES[route.harnessId] || route.harnessId;
+      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 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);
@@ -597,9 +652,83 @@ class NativeProtocol {
       return undefined;
     }
     if (method === 'thread/read') return { thread: this.projectThread(thread, params.includeTurns !== false) };
-    // External sessions currently accept immediate turns only, so their Desktop
-    // submission queue is empty. Do not forward their IDs to the stock server.
-    if (method === 'thread/queue/list') return { data: [], nextCursor: null };
+    if (method === 'thread/queue/list') {
+      const queue = this.getQueue(thread.id);
+      return {
+        data: queue.map(item => ({
+          id: item.id,
+          input: item.input,
+          clientUserMessageId: item.clientUserMessageId,
+          createdAt: item.createdAt,
+        })),
+        nextCursor: null,
+      };
+    }
+    if (method === 'thread/queue/add') {
+      const input = Array.isArray(params.input) ? params.input : [];
+      if (!input.length) throw new Error('Queue submission requires non-empty input');
+      const queue = this.getQueue(thread.id);
+      const submission = {
+        id: randomUUID(),
+        input,
+        clientUserMessageId: typeof params.clientUserMessageId === 'string' && params.clientUserMessageId ? params.clientUserMessageId : null,
+        createdAt: Date.now(),
+      };
+      queue.push(submission);
+      this.emitQueueChanged(thread.id);
+      return { queuedSubmission: submission };
+    }
+    if (method === 'thread/queue/delete') {
+      const queue = this.getQueue(thread.id);
+      const idx = queue.findIndex(item => item.id === params.queuedSubmissionId);
+      if (idx !== -1) {
+        queue.splice(idx, 1);
+        this.emitQueueChanged(thread.id);
+        return { deleted: true };
+      }
+      return { deleted: false };
+    }
+    if (method === 'thread/queue/update') {
+      const queue = this.getQueue(thread.id);
+      const item = queue.find(it => it.id === params.queuedSubmissionId);
+      if (!item) throw new Error('Queued submission not found');
+      if (Array.isArray(params.input)) item.input = params.input;
+      this.emitQueueChanged(thread.id);
+      return { queuedSubmission: item };
+    }
+    if (method === 'thread/queue/reorder') {
+      const queue = this.getQueue(thread.id);
+      const ids = Array.isArray(params.queuedSubmissionIds) ? params.queuedSubmissionIds : [];
+      const map = new Map(queue.map(item => [item.id, item]));
+      const reordered = ids.map(id => map.get(id)).filter(Boolean);
+      for (const item of queue) {
+        if (!ids.includes(item.id)) reordered.push(item);
+      }
+      this.queues.set(thread.id, reordered);
+      this.emitQueueChanged(thread.id);
+      return {};
+    }
+    if (method === 'thread/queue/start') {
+      const queue = this.getQueue(thread.id);
+      const idx = params.queuedSubmissionId
+        ? queue.findIndex(item => item.id === params.queuedSubmissionId)
+        : 0;
+      if (idx === -1 || !queue[idx]) throw new Error('Queued submission not found');
+      const [submission] = queue.splice(idx, 1);
+      this.emitQueueChanged(thread.id);
+      const { text, attachments } = await prepareInput(submission.input, thread.cwd);
+      if (attachments.length && !this.runtime.getCapabilities(thread.harnessId).conversation.attachments) {
+        throw new Error('当前 Harness 不支持图片附件');
+      }
+      if (this.runtime.execution.isRunning(thread.id)) {
+        // 正在执行中：打断当前回合并立即执行该排队消息
+        const turnId = await this.steerExclusive(thread, thread.currentTurn?.id, text, attachments);
+        const started = this.runtime.core.getTurn(turnId) || thread.currentTurn;
+        return { turn: this.turn(started) };
+      }
+      const turn = await this.startNativeTurn(thread, text, attachments);
+      return { turn: this.turn(turn) };
+    }
     if (method === 'thread/metadata/update') return { thread: this.projectThread(await this.runtime.updateThreadMetadata(thread.id, params.gitInfo)) };
     if (method === 'thread/section/move') {
       if (params.sectionId !== null && (typeof params.sectionId !== 'string' || !params.sectionId)) throw new Error('Invalid sectionId');
@@ -660,7 +789,17 @@ class NativeProtocol {
     }
     if (method === 'thread/rollback') return { thread: this.projectThread(await this.runtime.rollbackThread(thread.id, params.numTurns)) };
     if (method === 'thread/name/set') { await this.runtime.renameThread(thread.id, params.name); return {}; }
-    if (method === 'thread/archive' || method === 'thread/unarchive') { await this.runtime.setThreadArchived(thread.id, method === 'thread/archive'); return method === 'thread/archive' ? {} : { thread: this.projectThread(thread) }; }
+    if (method === 'thread/archive' || method === 'thread/unarchive') {
+      const isArchive = method === 'thread/archive';
+      await this.runtime.setThreadArchived(thread.id, isArchive);
+      if (isArchive) {
+        this.emit({ method: 'thread/archived', params: { threadId: thread.id } });
+        return {};
+      }
+      const projected = this.projectThread(thread);
+      this.emit({ method: 'thread/unarchived', params: { thread: projected } });
+      return { thread: projected };
+    }
     if (method === 'thread/loaded/list') return { data: [...this.runtime.sessions.keys()] };
     if (method === 'codexhost/thread/usage/inspect') {
       const usage = params.refresh === 'exact' ? await this.runtime.refreshUsage(thread.id) : this.runtime.core.getThread(thread.id)?.usage;
@@ -697,8 +836,12 @@ class NativeProtocol {
     }
     // 原地切换 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 };
+      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) {
@@ -760,6 +903,25 @@ class NativeProtocol {
       if (Array.isArray(projected.turn.itemIds)) {
         for (const id of projected.turn.itemIds) this.published.delete(id);
       }
+      for (const [id, app] of this.approvals.entries()) {
+        if (app.threadId === threadId) this.approvals.delete(id);
+      }
+      if (projected.turn.status === 'completed') {
+        setTimeout(async () => {
+          const queue = this.getQueue(threadId);
+          const currentThread = this.thread(threadId);
+          if (queue.length > 0 && currentThread && !this.runtime.execution.isRunning(threadId) && !this.steering.has(threadId) && !this.runtime.sending?.has(threadId)) {
+            const [submission] = queue.splice(0, 1);
+            this.emitQueueChanged(threadId);
+            try {
+              const { text, attachments } = await prepareInput(submission.input, currentThread.cwd);
+              await this.startNativeTurn(currentThread, text, attachments);
+            } catch (err) {
+              console.error(`Failed to auto-drain queued submission for thread ${threadId}:`, err);
+            }
+          }
+        }, 2500);
+      }
     }
   }
   async startNativeTurn(thread, text, attachments, commandId) {
@@ -831,6 +993,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) {