@myagentroam/node 0.11.15 → 0.11.16

package/dist/runner/claude-code-runner.js

@@ -3,8 +3,10 @@ import { ClaudeAgentSdkAdapter } from '../claude-agent-sdk.js';
 import { AbstractRunner } from './abstract-runner.js';
 import { claudeDefaultModel, declaredRunnerProfiles } from '../runner-profiles.js';
 import { withClaudePlanTag } from '../runner-command-engine.js';
-import { discoverNativeSessions, readNativeSession, readClaudeNativeContextUsage } from '../native-session-history.js';
-import { claudeDiscoveredSession, deduplicateDirectSessions, isNativeHistory, isWithinWorkspace, latestNativeActivity } from './codex/conversation-parser.js';
+import { discoverNativeSessions, readNativeSession } from '../native-session-history.js';
+import { readClaudeNativeContextUsage } from './claude/native-context-usage.js';
+import { claudeDiscoveredSession } from './claude/conversation-parser.js';
+import { deduplicateDirectSessions, isNativeHistory, isWithinWorkspace, latestNativeActivity } from '../util/runner-native-session-parsers.js';
 export class ClaudeCodeRunner extends AbstractRunner {
     client;
     environment;
@@ -16,6 +18,12 @@ export class ClaudeCodeRunner extends AbstractRunner {
         this.client = client;
         this.environment = environment;
     }
+    migrateSessionIdentity(previousId, nativeSessionId) {
+        for (const [runId, managed] of this.execution.runs) {
+            if (managed.marSessionId === previousId)
+                this.execution.runs.set(runId, { ...managed, marSessionId: nativeSessionId });
+        }
+    }
     profile(capabilities) {
         return declaredRunnerProfiles({
             codexAvailable: capabilities.codex.available,
@@ -46,6 +54,9 @@ export class ClaudeCodeRunner extends AbstractRunner {
             access: 'default'
         };
     }
+    goalAccess(currentAccess) {
+        return { access: 'bypass', accessChanged: currentAccess !== 'bypass' };
+    }
     mcpConfiguration(raw, secrets, executionServers = []) {
         const servers = withMarctlGuide(super.mcpConfiguration(raw, secrets, executionServers), secrets);
         return Object.fromEntries(servers.map((server) => [

package/dist/runner/codex/conversation-parser.js

@@ -1,3 +1,4 @@
+import { fileURLToPath } from 'node:url';
 import { open, stat } from 'node:fs/promises';
 import { StringDecoder } from 'node:string_decoder';
 import { nodeLog } from '../../operational.js';
@@ -134,7 +135,6 @@ import { publicGoalHistoryText } from '../../service/goal-runtime.js';
 const MAX_COMPOSER_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 const MAX_COMPOSER_ATTACHMENTS_BYTES = 10 * 1024 * 1024;
 const MAX_ASSISTANT_MESSAGE_CHARACTERS = 64 * 1024;
-export * from '../../util/runner-native-session-parsers.js';
 /** Only the official thread descriptor can declare history-only Revert support. */
 export function codexThreadHistoryModes(result) {
     if (!isPlainRecord(result))
@@ -1334,5 +1334,69 @@ export function isCodexImageBlock(value) {
         return false;
     return value.type === 'image' || value.type === 'input_image' || value.type === 'output_image';
 }
-import { codexTimestamp, compactRunnerText, compactRunnerValue, boundedConversationItemId, isCanonicalBase64, isPlainRecord, nativePageEnd } from '../../util/node-operation-parsers.js';
-export * from '../../util/node-operation-parsers.js';
+import { compactRunnerText, compactRunnerValue, boundedConversationItemId, isCanonicalBase64, isPlainRecord, nativePageEnd } from '../../util/node-operation-parsers.js';
+export function extractId(result, key) {
+    if (typeof result === 'object' &&
+        result !== null &&
+        key in result &&
+        typeof result[key] === 'object' &&
+        result[key] !== null &&
+        typeof result[key]['id'] === 'string') {
+        return result[key]['id'];
+    }
+    throw new Error(`CODEX_${key.toUpperCase()}_ID_MISSING`);
+}
+export function extractCodexThreads(result) {
+    if (typeof result !== 'object' || result === null || !('data' in result))
+        return [];
+    const data = result.data;
+    if (!Array.isArray(data))
+        return [];
+    return data.flatMap((entry) => {
+        if (typeof entry !== 'object' || entry === null)
+            return [];
+        const value = entry;
+        if (typeof value.id !== 'string')
+            return [];
+        const source = typeof value.sourceKind === 'string'
+            ? value.sourceKind
+            : typeof value.source === 'string'
+                ? value.source
+                : typeof value.source === 'object' &&
+                    value.source !== null &&
+                    typeof value.source.kind === 'string'
+                    ? value.source.kind
+                    : undefined;
+        const sourceRecord = isPlainRecord(value.source) ? value.source : undefined;
+        const derived = source === 'subagent' ||
+            sourceRecord?.kind === 'subagent' ||
+            isPlainRecord(sourceRecord?.subagent) ||
+            isPlainRecord(sourceRecord?.subAgent);
+        const name = typeof value.name === 'string' ? value.name.trim() : '';
+        const preview = typeof value.preview === 'string' ? value.preview.trim() : '';
+        const title = name || preview || undefined;
+        const titleOrigin = name ? 'OFFICIAL' : preview ? 'PREVIEW' : undefined;
+        return [{ id: value.id, source, derived, cwd: value.cwd, title, titleOrigin }];
+    });
+}
+export function codexThreadCwd(value) {
+    if (typeof value !== 'string' || value.length === 0)
+        throw new Error('CODEX_THREAD_CWD_INVALID');
+    if (!value.startsWith('file:'))
+        return value;
+    try {
+        return fileURLToPath(value);
+    }
+    catch {
+        throw new Error('CODEX_THREAD_CWD_INVALID');
+    }
+}
+export function codexTimestamp(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value < 10_000_000_000 ? value * 1_000 : value;
+    if (typeof value === 'string') {
+        const timestamp = Date.parse(value);
+        return Number.isNaN(timestamp) ? null : timestamp;
+    }
+    return null;
+}

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

@@ -1,12 +1,13 @@
 import { NODE_MCP } from '../../mcp/naming.js';
 import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
-import { extractId } from '../../util/runner-native-session-parsers.js';
+import { extractId } from './conversation-parser.js';
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
 import { safeErrorCode } from '../../util/safe-error.js';
 import { runnerErrorProjection } from '../../util/runner-error.js';
 import { ResponseLatencyTracker } from '../../service/response-latency-tracker.js';
 import { GenerationTimingTracker } from '../../service/generation-timing-tracker.js';
-import { boundedConversationItemId, codexImageAttachments, codexLiveConversationItem, codexSourceItemId, CodexUsageNormalizer, codexUserInputQuestions, compactRunnerText, isPlainRecord } from './conversation-parser.js';
+import { boundedConversationItemId, compactRunnerText, isPlainRecord } from '../../util/node-operation-parsers.js';
+import { codexImageAttachments, codexLiveConversationItem, codexSourceItemId, CodexUsageNormalizer, codexUserInputQuestions } from './conversation-parser.js';
 export function resolveCodexNotificationRun(runs, input) {
     const entries = [...runs.entries()];
     if (input.turnId !== undefined) {

package/dist/runner/codex/native-context-usage.js

@@ -0,0 +1,42 @@
+import { forEachJsonlRecord, readJsonlWindow } from '../../native-jsonl-reader.js';
+import { locateNativeSessionPath } from '../../native-session-history.js';
+const CONTEXT_USAGE_READ_BYTES = 256 * 1024;
+export async function readCodexNativeContextUsage(workspacePath, externalSessionId) {
+    const path = await locateNativeSessionPath('codex', workspacePath, externalSessionId);
+    if (path === undefined)
+        return undefined;
+    const window = await readJsonlWindow(path, { tailBytes: CONTEXT_USAGE_READ_BYTES });
+    if (window === undefined)
+        return undefined;
+    let usage;
+    forEachJsonlRecord(window.content, (record) => {
+        const next = codexContextUsage(record);
+        if (next !== undefined)
+            usage = next;
+    });
+    return usage;
+}
+function codexContextUsage(value) {
+    if (!isRecord(value) || value.type !== 'event_msg' || !isRecord(value.payload))
+        return undefined;
+    const payload = value.payload;
+    if (payload.type !== 'token_count' || !isRecord(payload.info))
+        return undefined;
+    const promptUsage = payload.info.last_token_usage;
+    const maxTokens = payload.info.model_context_window;
+    if (!isRecord(promptUsage) ||
+        typeof promptUsage.input_tokens !== 'number' ||
+        typeof maxTokens !== 'number')
+        return undefined;
+    if (!Number.isFinite(promptUsage.input_tokens) ||
+        !Number.isInteger(promptUsage.input_tokens) ||
+        !Number.isFinite(maxTokens) ||
+        !Number.isInteger(maxTokens) ||
+        maxTokens <= 0 ||
+        promptUsage.input_tokens < 0)
+        return undefined;
+    return { usedTokens: promptUsage.input_tokens, maxTokens };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}