@myagentroam/node 0.9.132 → 0.9.134

package/dist/capabilities.js

@@ -9,6 +9,7 @@ const runtimeCredentialCapability = () => ({
     apiVersion: 1,
     websocket: true,
     fastMode: true,
+    namespacedTools: true,
     httpVersions: ['1.1', '2']
 });
 const workspaceDirectTransferCapability = () => ({
@@ -52,6 +53,7 @@ export function unavailableCapabilities() {
         openCode: { available: false },
         marAgent: { available: true, version: nodeAppVersion },
         marAgentRuntimeCredentials: runtimeCredentialCapability(),
+        chatgptLogin: { apiVersion: 1, loopback: true },
         workspaceDirectTransfer: workspaceDirectTransferCapability(),
         terminalDirect: terminalDirectCapability()
     };
@@ -86,6 +88,7 @@ export function detectCapabilities(commands = {}) {
         },
         marAgent: { available: true, version: nodeAppVersion },
         marAgentRuntimeCredentials: runtimeCredentialCapability(),
+        chatgptLogin: { apiVersion: 1, loopback: true },
         workspaceDirectTransfer: workspaceDirectTransferCapability(),
         terminalDirect: terminalDirectCapability()
     };
@@ -124,6 +127,7 @@ export async function detectCapabilitiesAsync(commands = {}) {
         },
         marAgent: { available: true, version: nodeAppVersion },
         marAgentRuntimeCredentials: runtimeCredentialCapability(),
+        chatgptLogin: { apiVersion: 1, loopback: true },
         workspaceDirectTransfer: workspaceDirectTransferCapability(),
         terminalDirect: terminalDirectCapability()
     };

package/dist/connector.js

@@ -99,6 +99,7 @@ import { safeErrorCode } from './util/safe-error.js';
 import { RuntimeCredentialControlService } from './service/runtime-credential-control-service.js';
 import { MarAgentRuntimeModelFactory } from './runner/mar-agent/runtime-model-factory.js';
 import { MarAgentModelTransportTestService } from './service/mar-agent-model-transport-test-service.js';
+import { ChatgptLoginService } from './service/chatgpt-login-service.js';
 const HEARTBEAT_MS = 15_000;
 const CAPABILITY_REFRESH_MS = 60_000;
 const RETRY_MIN_MS = 500;
@@ -170,6 +171,11 @@ export class NodeConnector {
     marAgentModelTransportTests = new MarAgentModelTransportTestService({
         modelFactory: this.marAgentRuntimeModels
     });
+    chatgptLogins = new ChatgptLoginService(() => {
+        if (!this.config)
+            throw new Error('NODE_CONFIG_UNAVAILABLE');
+        return nodeDataDirectory(this.config, this.configPath);
+    });
     /** @internal Existing contract tests inject their socket through this boundary. */
     set socket(value) {
         this.controlChannel.replaceSocketForTesting(value);
@@ -1233,6 +1239,7 @@ export class NodeConnector {
             onClose: (code, reason) => {
                 this.directTransferService?.close();
                 this.runtimeCredentials.disconnected();
+                this.chatgptLogins.close();
                 this.scheduledRunAuthorization.disconnected();
                 this.mailNotificationControl.disconnected();
                 this.mailNotificationMcpServer.revokeAll();
@@ -1453,6 +1460,7 @@ export class NodeConnector {
         this.operationRouter.registerAll(this.sessionCommandService.operations());
         this.operationRouter.registerAll(this.workspaceQueueWorkbenchService.operations());
         this.operationRouter.registerAll(this.marAgentModelTransportTests.operations());
+        this.operationRouter.registerAll(this.chatgptLogins.operations());
         this.operationRouter.registerAll(new ConversationHostingEnablementService({
             config: () => this.config,
             setConfig: (config) => (this.config = config),
@@ -2009,6 +2017,7 @@ export class NodeConnector {
         const terminalDrain = this.terminalManager.shutdown();
         this.terminalChannel.stop();
         this.runtimeCredentials.close();
+        this.chatgptLogins.close();
         this.scheduledSessions.stop();
         this.scheduledRunAuthorization.close();
         this.mailNotificationControl.close();

package/dist/native-session-history.js

@@ -433,6 +433,7 @@ async function readTranscript(path, runner, byteLimit, page, targetLines = Numbe
     const toolIndexes = new Map();
     const metaRecordIds = new Set();
     const claudeCompactCommandIds = new Set();
+    let codexTurnId;
     forEachJsonlRecord(content, (value) => {
         if (derivedTranscriptRecord(runner, value))
             derivedSession = true;
@@ -444,6 +445,13 @@ async function readTranscript(path, runner, byteLimit, page, targetLines = Numbe
             claudeCompactCommandIds.add(value['uuid']);
     });
     forEachJsonlRecord(truncated ? window.pageContent : content, (value) => {
+        if (runner === 'codex' && value['type'] === 'event_msg' && isRecord(value['payload'])) {
+            const payload = value['payload'];
+            if (payload['type'] === 'task_started')
+                codexTurnId = typeof payload['turn_id'] === 'string' ? payload['turn_id'] : undefined;
+            else if (payload['type'] === 'task_complete')
+                codexTurnId = undefined;
+        }
         const recordId = typeof value['uuid'] === 'string' ? value['uuid'] : undefined;
         const parentId = typeof value['parentUuid'] === 'string' ? value['parentUuid'] : undefined;
         if (value['isMeta'] === true && recordId !== undefined)
@@ -469,7 +477,16 @@ async function readTranscript(path, runner, byteLimit, page, targetLines = Numbe
         if (generatedImage !== undefined)
             items.push(generatedImage);
         for (const parsedItem of transcriptItems(runner, value)) {
-            const item = recordId === undefined ? parsedItem : { ...parsedItem, nativeId: recordId };
+            const item = {
+                ...parsedItem,
+                ...(recordId === undefined ? {} : { nativeId: recordId }),
+                ...(runner === 'codex' &&
+                    parsedItem.kind === 'message' &&
+                    parsedItem.role === 'USER' &&
+                    codexTurnId !== undefined
+                    ? { nativeTurnId: codexTurnId }
+                    : {})
+            };
             if (item.kind === 'tool_result') {
                 const toolIndex = toolIndexes.get(item.toolUseId);
                 if (toolIndex !== undefined)

package/dist/node-execution-environment.js

@@ -0,0 +1,47 @@
+import { existsSync } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** Environment for processes started by this Node, not for the Node service itself. */
+export function nodeExecutionEnvironment(provided = {}, inherited = process.env, options = {}) {
+    const environment = Object.fromEntries(Object.entries(inherited).filter((entry) => typeof entry[1] === 'string'));
+    Object.assign(environment, provided);
+    environment['MAR_NODE_CONTEXT'] = '1';
+    const platform = options.platform ?? process.platform;
+    const packageRoot = options.packageRoot ?? resolve(dirname(fileURLToPath(import.meta.url)), '..');
+    const cliBins = [join(packageRoot, 'node_modules', '.bin')];
+    const nodeModules = resolve(packageRoot, '..', '..');
+    if (basename(packageRoot) === 'node' &&
+        basename(dirname(packageRoot)) === '@myagentroam' &&
+        basename(nodeModules) === 'node_modules') {
+        // npm prefix installs and pnpm's virtual store place shims beside scoped packages.
+        cliBins.push(join(nodeModules, '.bin'));
+        const prefix = dirname(nodeModules);
+        if (platform === 'win32')
+            cliBins.push(prefix);
+        else if (basename(prefix) === 'lib')
+            cliBins.push(resolve(prefix, '..', 'bin'));
+    }
+    const cliBin = cliBins.find((bin) => existsSync(join(bin, platform === 'win32' ? 'marnodes.cmd' : 'marnodes')));
+    if (cliBin === undefined)
+        return environment;
+    const separator = platform === 'win32' ? ';' : ':';
+    const existingKeys = Object.keys(environment).filter((key) => key.toLowerCase() === 'path');
+    const key = platform === 'win32'
+        ? (Object.keys(provided).find((name) => name.toLowerCase() === 'path') ??
+            existingKeys[0] ??
+            'Path')
+        : 'PATH';
+    const current = environment[key] ?? environment[existingKeys[0] ?? key] ?? '';
+    if (platform === 'win32')
+        for (const other of existingKeys)
+            if (other !== key)
+                delete environment[other];
+    const samePath = (entry) => platform === 'win32'
+        ? entry.replaceAll('/', '\\').toLowerCase() === cliBin.replaceAll('/', '\\').toLowerCase()
+        : entry === cliBin;
+    environment[key] = [
+        cliBin,
+        ...current.split(separator).filter((entry) => entry && !samePath(entry))
+    ].join(separator);
+    return environment;
+}

package/dist/runner/abstract-runner.js

@@ -1,4 +1,5 @@
 import { mcpRuntimeDescriptorSchema } from '@myagentroam/protocol';
+import { nodeExecutionEnvironment } from '../node-execution-environment.js';
 /**
  * Stable lifecycle boundary for every Node Runner implementation.
  *
@@ -175,6 +176,7 @@ function resolvedMcpServers(raw, secrets) {
             : { MAR_MGR_USER_TOKEN: secrets['MAR_MGR_USER_TOKEN'] }),
         MAR_MGR_CONTEXT_REQUIRED: '1'
     };
+    const mcpEnvironment = (provided) => nodeExecutionEnvironment({ ...provided, ...marmgrEnvironment }, { PATH: process.env['PATH'], Path: process.env['Path'] });
     const result = [];
     for (const value of raw) {
         if (value === null || typeof value !== 'object' || Array.isArray(value))
@@ -197,24 +199,21 @@ function resolvedMcpServers(raw, secrets) {
                 transport: 'STDIO',
                 command: record['command'],
                 args: record['args'],
-                environment: record['__marGoal'] === true
+                environment: mcpEnvironment(record['__marGoal'] === true
                     ? {
                         MAR_GOAL_MCP_ENDPOINT: record['endpoint'],
-                        MAR_GOAL_MCP_TOKEN: secrets[record['secretName']],
-                        ...marmgrEnvironment
+                        MAR_GOAL_MCP_TOKEN: secrets[record['secretName']]
                     }
                     : record['__marScheduled'] === true
                         ? {
                             MAR_SCHEDULE_MCP_ENDPOINT: record['endpoint'],
                             MAR_SCHEDULE_MCP_TOKEN: secrets[record['secretName']],
-                            MAR_SCHEDULE_MCP_READ_ONLY: record['readOnly'] === true ? '1' : '0',
-                            ...marmgrEnvironment
+                            MAR_SCHEDULE_MCP_READ_ONLY: record['readOnly'] === true ? '1' : '0'
                         }
                         : {
                             MAR_MAIL_MCP_ENDPOINT: record['endpoint'],
-                            MAR_MAIL_MCP_TOKEN: secrets[record['secretName']],
-                            ...marmgrEnvironment
-                        }
+                            MAR_MAIL_MCP_TOKEN: secrets[record['secretName']]
+                        })
             });
             continue;
         }
@@ -251,11 +250,10 @@ function resolvedMcpServers(raw, secrets) {
                         ? configuration['arguments'].filter((item) => typeof item === 'string')
                         : [])
                 ],
-                environment: {
+                environment: mcpEnvironment({
                     ...runtimeEnvironment,
-                    ...configuredEnvironment,
-                    ...marmgrEnvironment
-                }
+                    ...configuredEnvironment
+                })
             });
         }
         else {

package/dist/runner/claude/managed-run-controller.js

@@ -1,5 +1,6 @@
 import { createEnvelope } from '@myagentroam/protocol';
 import { ClaudeChannelGate } from '../../claude-channel.js';
+import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
 import { boundedConversationItemId, claudePlanText, compactRunnerText, extractClaudeText, extractClaudeThinkingSummaries, extractClaudeToolResults, extractClaudeToolUses } from '../codex/conversation-parser.js';
 import { normalizeClaudeTool } from './tool-normalizer.js';
 import { claudeContentBlocks } from '../../util/node-operation-parsers.js';
@@ -170,7 +171,10 @@ export class ClaudeManagedRunController {
                 ...(typeof payload.model === 'string' ? { model: payload.model } : {}),
                 ...(typeof payload.effort === 'string' ? { effort: payload.effort } : {}),
                 ...(typeof payload.access === 'string' ? { access: payload.access } : {}),
-                environment: { ...secretEnvironment, MAR_MGR_CONTEXT_REQUIRED: '1' },
+                environment: nodeExecutionEnvironment({
+                    ...secretEnvironment,
+                    MAR_MGR_CONTEXT_REQUIRED: '1'
+                }, { PATH: process.env['PATH'], Path: process.env['Path'] }),
                 ...(typeof payload.personalInstructions === 'string'
                     ? { personalInstructions: payload.personalInstructions }
                     : {}),

package/dist/runner/codex/managed-run-controller.js

@@ -1,3 +1,4 @@
+import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
 import { extractId } from '../../util/runner-native-session-parsers.js';
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
 import { safeErrorCode } from '../../util/safe-error.js';
@@ -65,7 +66,7 @@ export class CodexManagedRunController {
             throw new Error('RUNNER_COMMAND_UNAVAILABLE');
         if (command.id === 'compact') {
             const runId = crypto.randomUUID();
-            this.runner.prepareEnvironment(context.secretEnvironment, runId);
+            this.runner.prepareEnvironment(nodeExecutionEnvironment({ ...context.secretEnvironment, MAR_MGR_CONTEXT_REQUIRED: '1' }, { PATH: process.env['PATH'], Path: process.env['Path'] }), runId);
             try {
                 await this.runner.start(runId);
                 return await this.compact(session, threadId, runId, context.initiatedByUserId);
@@ -385,7 +386,7 @@ export class CodexManagedRunController {
             return;
         }
         try {
-            this.runner.prepareEnvironment({ ...secretEnvironment, MAR_MGR_CONTEXT_REQUIRED: '1' }, runId);
+            this.runner.prepareEnvironment(nodeExecutionEnvironment({ ...secretEnvironment, MAR_MGR_CONTEXT_REQUIRED: '1' }, { PATH: process.env['PATH'], Path: process.env['Path'] }), runId);
         }
         catch (error) {
             this.host.emit(runId, 'run.rejected', { code: safeErrorCode(error, 'SECRET_ENVIRONMENT_INVALID') }, 'FAILED');

package/dist/runner/mar-agent/managed-run-controller.js

@@ -2,6 +2,7 @@ import { computerUseHostSkill } from './computer-use-skill.js';
 import { createHash, randomUUID } from 'node:crypto';
 import { homedir } from 'node:os';
 import { access, constants } from 'node:fs/promises';
+import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
 import { BUNDLED_RIPGREP_VERSION, bundledRipgrepPath, prependBundledRipgrepToPath } from '../../ripgrep-binary.js';
 import { LocalAgentHost, createMarAgent } from '@myagentroam/agent';
 import { marAgentReasoningEffortSchema, marAgentRuntimeModelConfigurationSchema } from '@myagentroam/protocol';
@@ -686,7 +687,10 @@ export function allowsUntrustedWebFetchTls(environment) {
     return environment['MAR_AGENT_WEB_FETCH_ALLOW_UNTRUSTED_TLS'] !== '0';
 }
 async function resolveMarAgentHostRuntimeConfiguration(secretEnvironment = {}) {
-    const environment = { ...process.env, ...secretEnvironment, MAR_MGR_CONTEXT_REQUIRED: '1' };
+    const environment = nodeExecutionEnvironment({
+        ...secretEnvironment,
+        MAR_MGR_CONTEXT_REQUIRED: '1'
+    });
     const ripgrep = await availableBundledRipgrep();
     return {
         environment: ripgrep === undefined ? environment : prependBundledRipgrepToPath(environment, ripgrep),

package/dist/runner/mar-agent/runtime-model-factory.js

@@ -22,6 +22,7 @@ class PendingCredentialResolution {
     }
 }
 const CREDENTIAL_REFRESH_WINDOW_MS = 60_000;
+const CREDENTIAL_REFRESH_RETRY_MS = 30_000;
 export class MarAgentRuntimeModelFactory {
     control;
     now;
@@ -73,6 +74,7 @@ export class MarAgentRuntimeModelFactory {
                     ...(configuration.responsesEncoding === undefined
                         ? {}
                         : { responsesEncoding: configuration.responsesEncoding }),
+                    responsesToolNamespace: configuration.responsesToolNamespace,
                     responsesPreviousResponseId: configuration.responsesPreviousResponseId,
                     enabled: configuration.enabled
                 };
@@ -229,12 +231,12 @@ class ServerRuntimeCredentialProvider {
             if (this.state.pending !== pending)
                 return;
             delete this.state.pending;
-            scheduleRefresh(this.state, this.now);
+            scheduleRefresh(this.state, this.now, CREDENTIAL_REFRESH_RETRY_MS);
         }, () => {
             if (this.state.pending !== pending)
                 return;
             delete this.state.pending;
-            scheduleRefresh(this.state, this.now, false);
+            scheduleRefresh(this.state, this.now, CREDENTIAL_REFRESH_RETRY_MS);
         });
         return pending;
     }
@@ -296,20 +298,23 @@ function sameRuntimeCredentialTicket(first, second) {
         first.allowedModelIds.length === second.allowedModelIds.length &&
         first.allowedModelIds.every((modelId, index) => modelId === second.allowedModelIds[index]));
 }
-function scheduleRefresh(state, now, includeDue = true) {
+function scheduleRefresh(state, now, minimumDelayMs = 0) {
     clearRefreshTimer(state);
     if (state.released || state.pending !== undefined || state.providers.size === 0)
         return;
+    const timestamp = now();
+    if (state.ticket.expiresAt <= timestamp)
+        return;
     const expiresAt = Math.min(state.ticket.expiresAt, state.credential?.expiresAt ?? Number.POSITIVE_INFINITY);
-    const delay = expiresAt - now() - CREDENTIAL_REFRESH_WINDOW_MS;
-    if (!includeDue && delay <= 0)
+    const delay = Math.max(minimumDelayMs, expiresAt - timestamp - CREDENTIAL_REFRESH_WINDOW_MS, 0);
+    if (timestamp + delay > state.ticket.expiresAt)
         return;
     const timer = setTimeout(() => {
         if (state.refreshTimer === timer)
             delete state.refreshTimer;
         const provider = state.providers.values().next().value;
         provider?.refreshAutomatically();
-    }, Math.max(0, delay));
+    }, delay);
     timer.unref();
     state.refreshTimer = timer;
 }

package/dist/runner/mar-agent-runner.js

@@ -221,24 +221,36 @@ export class MarAgentRunner extends AbstractRunner {
         let catalog;
         try {
             catalog = await openMarAgentSessionCatalog({ homeDirectory: this.homeDirectory });
-            const listed = await catalog.list({ limit: 200 });
+            const activeCatalog = catalog;
+            const listed = await activeCatalog.list({ limit: 200 });
             const workspaces = workspace ? [workspace] : context.workspaces;
-            return listed.sessions.flatMap((session) => {
+            return (await Promise.all(listed.sessions.map(async (session) => {
                 const target = workspaces.find((candidate) => resolve(candidate.path) === resolve(session.workspace));
                 if (!target)
                     return [];
+                const executionConfiguration = session.modelId === undefined
+                    ? await activeCatalog.executionConfiguration(session.id)
+                    : session;
                 return [
-                    context.createProjection({
-                        workspace: target,
-                        runner: this.name,
-                        externalSessionId: session.id,
-                        cwd: session.workspace,
-                        title: session.title,
-                        titleOrigin: 'NATIVE',
-                        lastActivityAt: Date.parse(session.lastActivityAt)
-                    })
+                    {
+                        ...context.createProjection({
+                            workspace: target,
+                            runner: this.name,
+                            externalSessionId: session.id,
+                            cwd: session.workspace,
+                            title: session.title,
+                            titleOrigin: 'NATIVE',
+                            lastActivityAt: Date.parse(session.lastActivityAt)
+                        }),
+                        ...(executionConfiguration?.modelId === undefined
+                            ? {}
+                            : { model: executionConfiguration.modelId }),
+                        ...(executionConfiguration?.reasoningEffort === undefined
+                            ? {}
+                            : { effort: executionConfiguration.reasoningEffort })
+                    }
                 ];
-            });
+            }))).flat();
         }
         catch {
             return [];

package/dist/runner/opencode/managed-run-controller.js

@@ -1,3 +1,4 @@
+import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
 import { runnerErrorProjection } from '../../util/runner-error.js';
 import { boundedConversationItemId, compactRunnerText } from '../codex/conversation-parser.js';
@@ -49,7 +50,7 @@ export class OpenCodeManagedRunController {
             this.host.hasActiveSessionLease(session.id))
             throw new Error('RUNNER_COMMAND_UNAVAILABLE');
         const runId = crypto.randomUUID();
-        const client = this.runner.managedClient(environment);
+        const client = this.runner.managedClient(nodeExecutionEnvironment({ ...environment, MAR_MGR_CONTEXT_REQUIRED: '1' }, { PATH: process.env['PATH'], Path: process.env['Path'] }));
         this.host.adopt({
             runId,
             sessionId: session.id,
@@ -108,10 +109,10 @@ export class OpenCodeManagedRunController {
         let mcp;
         let attachments;
         try {
-            environment = {
+            environment = nodeExecutionEnvironment({
                 ...parseSecretEnvironment(payload.secretEnvironment),
                 MAR_MGR_CONTEXT_REQUIRED: '1'
-            };
+            }, { PATH: process.env['PATH'], Path: process.env['Path'] });
             mcpSecretEnvironment = parseSecretEnvironment(payload.mcpSecretEnvironment);
             mcp = this.runner.mcpConfiguration(payload.mcpInstallations, {
                 ...environment,

package/dist/service/chatgpt-login-service.js

@@ -0,0 +1,345 @@
+import { createHash, randomBytes, randomUUID } from 'node:crypto';
+import { createServer } from 'node:http';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { requestHttp } from '@myagentroam/agent/host/network';
+import { CHATGPT_ISSUER, CHATGPT_RESOURCE, CHATGPT_TOKEN_ENDPOINT, CHATGPT_JWKS_ENDPOINT, CHATGPT_REQUESTED_SCOPE, chatgptLoginStartSchema, chatgptTokenResponseSchema, verifyChatgptIdentity } from '@myagentroam/protocol';
+const TTL_MS = 10 * 60_000;
+/** Temporary, loopback-only OAuth provider. Only the Server may consume token results. */
+export class ChatgptLoginService {
+    dataDirectory;
+    request;
+    attempts = new Map();
+    starting = new Map();
+    hostIdFlight;
+    constructor(dataDirectory, request = (url, init, proxy, signal) => requestHttp(url, { request: init, httpVersion: '1.1', ...(proxy ? { socks5Url: proxy } : {}) }, signal ?? AbortSignal.timeout(30_000), 30_000)) {
+        this.dataDirectory = dataDirectory;
+        this.request = request;
+    }
+    operations() {
+        return {
+            'chatgpt.login.start': (raw) => this.start(raw),
+            'chatgpt.login.status': (raw) => this.status(raw),
+            'chatgpt.login.ack': (raw) => this.remove(raw),
+            'chatgpt.login.cancel': (raw) => this.remove(raw)
+        };
+    }
+    async start(raw) {
+        const { data, userId, session } = this.context(raw);
+        const parsed = chatgptLoginStartSchema.safeParse(data);
+        if (!parsed.success)
+            throw new Error('CHATGPT_LOGIN_INPUT_INVALID');
+        const input = parsed.data;
+        if (this.attempts.has(input.attemptId))
+            return this.status(raw);
+        const existing = this.starting.get(input.attemptId);
+        if (existing) {
+            if (existing.userId !== userId || existing.session !== session)
+                throw new Error('CHATGPT_LOGIN_FORBIDDEN');
+            await existing.flight;
+            return this.status(raw);
+        }
+        if (this.attempts.size + this.starting.size >= 64)
+            throw new Error('CHATGPT_LOGIN_LIMIT_REACHED');
+        if (input.socks5Url !== undefined && new URL(input.socks5Url).protocol !== 'socks5:')
+            throw new Error('CHATGPT_LOGIN_INPUT_INVALID');
+        const pending = { userId, session, cancelled: false };
+        this.starting.set(input.attemptId, pending);
+        pending.flight = this.openAttempt(input, pending);
+        try {
+            await pending.flight;
+            return this.status(raw);
+        }
+        finally {
+            if (this.starting.get(input.attemptId) === pending)
+                this.starting.delete(input.attemptId);
+        }
+    }
+    async openAttempt(input, pending) {
+        const hostId = await this.hostId();
+        if (pending.cancelled)
+            throw new Error('CHATGPT_LOGIN_CANCELLED');
+        const server = createServer((req, res) => {
+            void this.handle(input.attemptId, req, res).catch(() => {
+                if (!res.headersSent)
+                    res.writeHead(500);
+                res.end('Login failed.');
+            });
+        });
+        server.maxHeadersCount = 32;
+        server.headersTimeout = 10_000;
+        server.requestTimeout = 10_000;
+        await new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(0, '127.0.0.1', () => {
+                server.removeListener('error', reject);
+                resolve();
+            });
+        });
+        const address = server.address();
+        if (pending.cancelled) {
+            server.close();
+            server.closeAllConnections();
+            throw new Error('CHATGPT_LOGIN_CANCELLED');
+        }
+        if (address === null || typeof address === 'string') {
+            server.close();
+            throw new Error('CHATGPT_LISTENER_FAILED');
+        }
+        const attempt = {
+            id: input.attemptId,
+            userId: pending.userId,
+            session: pending.session,
+            nonce: input.nonce,
+            state: randomBytes(32).toString('base64url'),
+            entry: randomBytes(32).toString('base64url'),
+            verifier: randomBytes(48).toString('base64url'),
+            clientId: input.clientId,
+            subject: input.subject,
+            proxy: input.socks5Url,
+            hostId,
+            server,
+            expiresAt: Date.now() + TTL_MS,
+            redirectUri: `http://127.0.0.1:${address.port}/auth/callback`,
+            abort: new AbortController(),
+            started: false,
+            exchanging: false,
+            timer: setTimeout(() => this.clear(input.attemptId), TTL_MS)
+        };
+        attempt.timer.unref();
+        this.attempts.set(attempt.id, attempt);
+    }
+    status(raw) {
+        const attempt = this.owned(raw);
+        if (attempt.result !== undefined)
+            return { status: 'SUCCEEDED', result: attempt.result };
+        if (attempt.error !== undefined)
+            return { status: 'FAILED', code: attempt.error };
+        return {
+            status: 'PENDING',
+            verificationUri: attempt.redirectUri.replace('/auth/callback', `/auth/start?ticket=${attempt.entry}`),
+            expiresAt: attempt.expiresAt
+        };
+    }
+    async remove(raw) {
+        const { data, userId, session } = this.context(raw);
+        const id = data['attemptId'];
+        const pending = typeof id === 'string' ? this.starting.get(id) : undefined;
+        if (pending) {
+            if (pending.userId !== userId || pending.session !== session)
+                throw new Error('CHATGPT_LOGIN_FORBIDDEN');
+            pending.cancelled = true;
+            await pending.flight?.catch(() => undefined);
+            return { cleared: true };
+        }
+        const attempt = this.owned(raw);
+        this.clear(attempt.id);
+        return { cleared: true };
+    }
+    close() {
+        for (const pending of this.starting.values())
+            pending.cancelled = true;
+        this.starting.clear();
+        for (const id of this.attempts.keys())
+            this.clear(id);
+    }
+    clear(id) {
+        const attempt = this.attempts.get(id);
+        if (!attempt)
+            return;
+        this.attempts.delete(id);
+        clearTimeout(attempt.timer);
+        attempt.abort.abort();
+        attempt.server.close();
+        attempt.server.closeAllConnections();
+        attempt.result = undefined;
+        attempt.verifier = '';
+        attempt.entry = '';
+    }
+    context(raw) {
+        if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+            throw new Error('CHATGPT_LOGIN_INPUT_INVALID');
+        const data = { ...raw };
+        const userId = data['__requestUserId'], session = data['__workspaceWatchSessionHash'];
+        delete data['__requestUserId'];
+        delete data['__workspaceWatchSessionHash'];
+        if (!Number.isSafeInteger(userId) ||
+            userId < 1 ||
+            typeof session !== 'string' ||
+            session.length < 1)
+            throw new Error('CHATGPT_LOGIN_FORBIDDEN');
+        return { data, userId: userId, session };
+    }
+    owned(raw) {
+        const { data, userId, session } = this.context(raw);
+        const id = data['attemptId'];
+        const attempt = typeof id === 'string' ? this.attempts.get(id) : undefined;
+        if (!attempt ||
+            attempt.userId !== userId ||
+            attempt.session !== session ||
+            Date.now() >= attempt.expiresAt)
+            throw new Error('CHATGPT_LOGIN_NOT_FOUND');
+        return attempt;
+    }
+    hostId() {
+        this.hostIdFlight ??= this.loadHostId().catch((error) => {
+            this.hostIdFlight = undefined;
+            throw error;
+        });
+        return this.hostIdFlight;
+    }
+    async loadHostId() {
+        const directory = this.dataDirectory(), path = join(directory, 'chatgpt-host-id');
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        try {
+            await writeFile(path, `urn:uuid:${randomUUID()}`, { flag: 'wx', mode: 0o600 });
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw new Error('CHATGPT_HOST_ID_FAILED');
+        }
+        const id = await readFile(path, 'utf8');
+        if (!/^urn:uuid:[0-9a-f-]{36}$/u.test(id))
+            throw new Error('CHATGPT_HOST_ID_INVALID');
+        return id;
+    }
+    async json(url, init, attempt) {
+        const response = await this.request(url, { ...init, redirect: 'error' }, attempt.proxy, AbortSignal.any([attempt.abort.signal, AbortSignal.timeout(30_000)]));
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw new Error('CHATGPT_TOKEN_EXCHANGE_FAILED');
+        }
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new Error('CHATGPT_TOKEN_RESPONSE_INVALID');
+        let length = 0;
+        const chunks = [];
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                length += value.length;
+                if (length > 524_288)
+                    throw new Error('CHATGPT_TOKEN_RESPONSE_INVALID');
+                chunks.push(value);
+            }
+            const bytes = new Uint8Array(length);
+            let offset = 0;
+            for (const chunk of chunks) {
+                bytes.set(chunk, offset);
+                offset += chunk.length;
+            }
+            return JSON.parse(new TextDecoder().decode(bytes));
+        }
+        finally {
+            await reader.cancel().catch(() => undefined);
+        }
+    }
+    async handle(id, req, res) {
+        res.setHeader('cache-control', 'no-store');
+        res.setHeader('referrer-policy', 'no-referrer');
+        res.setHeader('content-security-policy', "default-src 'none'; frame-ancestors 'none'");
+        const attempt = this.attempts.get(id);
+        if (!attempt ||
+            req.method !== 'GET' ||
+            !req.url ||
+            req.url.length > 16_384 ||
+            req.headers.host !== new URL(attempt.redirectUri).host ||
+            Date.now() >= attempt.expiresAt) {
+            res.writeHead(400);
+            res.end('Invalid login request.');
+            return;
+        }
+        const url = new URL(req.url, attempt.redirectUri);
+        if (url.pathname === '/auth/start' &&
+            !attempt.started &&
+            url.searchParams.getAll('ticket').length === 1 &&
+            url.searchParams.get('ticket') === attempt.entry) {
+            attempt.started = true;
+            attempt.entry = '';
+            const authorize = new URL(`${CHATGPT_ISSUER}/api/accounts/authorize`);
+            authorize.search = new URLSearchParams({
+                response_type: 'code',
+                client_id: attempt.clientId ?? 'dynamic_agent_client',
+                ext_agent_host_id: attempt.hostId,
+                scope: CHATGPT_REQUESTED_SCOPE,
+                resource: CHATGPT_RESOURCE,
+                redirect_uri: attempt.redirectUri,
+                state: attempt.state,
+                nonce: attempt.nonce,
+                code_challenge_method: 'S256',
+                code_challenge: createHash('sha256').update(attempt.verifier).digest('base64url'),
+                ...(attempt.clientId ? {} : { agent_name_hint: 'MyAgentRoam' })
+            }).toString();
+            res.writeHead(302, { location: authorize.href });
+            res.end();
+            return;
+        }
+        if (url.pathname !== '/auth/callback' ||
+            !attempt.started ||
+            attempt.exchanging ||
+            attempt.result ||
+            attempt.error ||
+            url.searchParams.getAll('state').length !== 1 ||
+            url.searchParams.get('state') !== attempt.state) {
+            res.writeHead(400);
+            res.end('Invalid login callback.');
+            return;
+        }
+        attempt.exchanging = true;
+        try {
+            if (url.searchParams.has('error'))
+                throw new Error('CHATGPT_AUTHORIZATION_DENIED');
+            const callbackClient = url.searchParams.get('client_id');
+            const clientId = callbackClient ?? attempt.clientId;
+            const code = url.searchParams.get('code');
+            if (!clientId ||
+                clientId === 'dynamic_agent_client' ||
+                clientId.length > 512 ||
+                !code ||
+                code.length > 8192 ||
+                url.searchParams.getAll('code').length !== 1 ||
+                url.searchParams.getAll('client_id').length > 1 ||
+                (attempt.clientId && clientId !== attempt.clientId))
+                throw new Error('CHATGPT_CALLBACK_INVALID');
+            const raw = await this.json(CHATGPT_TOKEN_ENDPOINT, {
+                method: 'POST',
+                headers: { 'content-type': 'application/x-www-form-urlencoded' },
+                body: new URLSearchParams({
+                    grant_type: 'authorization_code',
+                    client_id: clientId,
+                    code,
+                    code_verifier: attempt.verifier,
+                    redirect_uri: attempt.redirectUri,
+                    resource: CHATGPT_RESOURCE
+                }).toString()
+            }, attempt);
+            const parsed = chatgptTokenResponseSchema.safeParse(raw);
+            if (!parsed.success || !parsed.data.id_token)
+                throw new Error('CHATGPT_TOKEN_RESPONSE_INVALID');
+            const jwks = await this.json(CHATGPT_JWKS_ENDPOINT, { method: 'GET' }, attempt);
+            await verifyChatgptIdentity(parsed.data.id_token, jwks, {
+                clientId,
+                nonce: attempt.nonce,
+                subject: attempt.subject
+            });
+            if (this.attempts.get(id) !== attempt || attempt.abort.signal.aborted)
+                throw new Error('CHATGPT_LOGIN_CANCELLED');
+            attempt.result = { attemptId: id, clientId, hostId: attempt.hostId, tokens: parsed.data };
+            res.end('Login completed. Return to MyAgentRoam to save the credential.');
+        }
+        catch (error) {
+            attempt.error =
+                error instanceof Error && /^CHATGPT_[A-Z0-9_]+$/u.test(error.message)
+                    ? error.message
+                    : 'CHATGPT_LOGIN_FAILED';
+            res.writeHead(400);
+            res.end('Login failed. Return to MyAgentRoam to retry.');
+        }
+        finally {
+            attempt.verifier = '';
+            attempt.server.close();
+        }
+    }
+}

package/dist/service/conversation-history-service.js

@@ -369,20 +369,22 @@ export class ConversationHistoryService {
     }
     async readManagedRuntime(session, input, cursor, snapshotSequence, readAt) {
         const page = await this.readManagedActive(session, input, cursor, snapshotSequence, readAt);
+        const codexActive = session.runner === 'codex' && this.options.hasManagedActiveRun(session);
         if (input.cursor !== undefined ||
             session.externalSessionId === null ||
-            this.options.hasManagedActiveRun(session) ||
-            !this.hasManagedRuntimeHistory(session) ||
+            (!codexActive &&
+                (this.options.hasManagedActiveRun(session) || !this.hasManagedRuntimeHistory(session))) ||
             !page.turns.some((turn) => turn.rewind === undefined &&
                 terminalConversationTurn(turn.status) &&
                 conversationClientMessageId(turn) !== null))
             return page;
         // A completed managed Turn keeps its live items and Run identity until Runtime cleanup.
-        // Only the SDK's matched native Turn may supply a destructive history boundary.
-        const official = await this.readOfficial(session, {
-            limit: Math.min(500, Math.max(30, page.turns.length + 1))
-        }).catch(() => undefined);
-        if (official === undefined)
+        // Only its matched native Turn may supply a Rewind boundary.
+        const historyInput = { limit: Math.min(500, Math.max(30, page.turns.length + 1)) };
+        const authoritative = codexActive
+            ? (await this.readRunnerHistory(session, historyInput).catch(() => undefined))?.page
+            : await this.readOfficial(session, historyInput).catch(() => undefined);
+        if (authoritative === undefined)
             return page;
         return {
             ...page,
@@ -392,7 +394,7 @@ export class ConversationHistoryService {
                 const messageId = conversationClientMessageId(turn);
                 if (messageId === null)
                     return turn;
-                const native = official.turns.find((candidate) => candidate.rewind !== undefined &&
+                const native = authoritative.turns.find((candidate) => candidate.rewind !== undefined &&
                     candidate.userItemId !== null &&
                     conversationClientMessageId(candidate) === messageId);
                 return native?.rewind === undefined ? turn : { ...turn, rewind: native.rewind };

package/dist/terminal.js

@@ -5,6 +5,7 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { spawn } from 'node-pty';
 import { terminalDataFrameSchema } from '@myagentroam/protocol';
+import { nodeExecutionEnvironment } from './node-execution-environment.js';
 import { terminateProcessTree } from './process-tree.js';
 const MAX_FRAME_CHARACTERS = 65_536;
 const TERMINAL_COMMAND_MAX_BYTES = 64 * 1024;
@@ -138,7 +139,7 @@ export class TerminalManager {
             cols,
             rows,
             cwd: typeof input.cwd === 'string' ? input.cwd : this.cwd,
-            env: { ...process.env, ...input.environment }
+            env: nodeExecutionEnvironment(input.environment, process.env, { platform: this.platform })
         };
         const commandArgs = command === undefined
             ? undefined

package/dist/util/runner-native-session-parsers.js

@@ -182,6 +182,11 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
         const startedAt = items[0]?.startedAt ?? null;
         const completedAt = items.at(-1)?.completedAt ?? startedAt;
         const after = lastNativeItemId(entries);
+        const nativeIndex = start + relativeIndex;
+        const turnBoundaryAfter = nativeUser?.kind === 'message' ? nativeUser.nativeTurnId : undefined;
+        const previousNativeUser = nativeTurns[nativeIndex - 1]?.find(({ entry }) => entry.kind === 'message' && entry.role === 'USER')?.entry;
+        const turnBoundaryBefore = previousNativeUser?.kind === 'message' ? previousNativeUser.nativeTurnId : undefined;
+        const firstNativeTurn = nativeIndex === 0 && history.truncated !== true;
         return {
             id: turnId,
             sessionId: session.id,
@@ -199,6 +204,10 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
                         after
                     }
                 }),
+            ...(turnBoundaryAfter === undefined ||
+                (!firstNativeTurn && turnBoundaryBefore === undefined)
+                ? {}
+                : { rewind: { before: turnBoundaryBefore ?? null, after: turnBoundaryAfter } }),
             items,
             startedAt,
             completedAt

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.132",
+  "version": "0.9.134",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -34,10 +34,10 @@
     "npm": "11.12.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/marmgr": "0.9.115",
-    "@myagentroam/agent": "0.9.132",
-    "@myagentroam/protocol": "0.9.132",
-    "@myagentroam/code-navigation": "0.9.129"
+    "@myagentroam/marmgr": "0.9.117",
+    "@myagentroam/agent": "0.9.134",
+    "@myagentroam/code-navigation": "0.9.129",
+    "@myagentroam/protocol": "0.9.134"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"