@expo/build-tools 21.3.0 → 21.5.0

package/dist/steps/functions/startAgentDeviceRemoteSession.js

@@ -13,7 +13,7 @@ const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const sentry_1 = require("../../sentry");
 const agentDeviceArtifacts_1 = require("../utils/agentDeviceArtifacts");
-const deviceRunSessionEvents_1 = require("../utils/deviceRunSessionEvents");
+const agentDeviceEvents_1 = require("../utils/agentDeviceEvents");
 const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
 const AGENT_DEVICE_PACKAGE_NAME = 'agent-device';
 const AGENT_DEVICE_REPO_URL = 'https://github.com/callstack/agent-device.git';
@@ -59,50 +59,51 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                 daemonProcess,
             });
             logger.info(`Daemon is listening on port ${daemonPort}; loaded auth token.`);
-            const agentDeviceRemoteSessionUrl = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
+            const agentDeviceTunnel = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
                 port: daemonPort,
                 subdomainPrefix: 'agent-device',
                 baseDomain: ngrokTunnelDomain,
                 authtoken: ngrokAuthtoken,
                 logger,
             });
+            const agentDeviceRemoteSessionUrl = agentDeviceTunnel.url;
             logger.info(`Tunnel is ready at ${agentDeviceRemoteSessionUrl}.`);
-            // serve-sim is iOS-only — only launch it (and report a webPreviewUrl)
-            // on Darwin. Android sessions go without a preview URL.
-            let webPreviewUrl;
-            if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
-                const { previewUrl } = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
-                    baseDomain: ngrokTunnelDomain,
-                    env,
+            let serveSim;
+            let eventCollection;
+            try {
+                // serve-sim is iOS-only — only launch it (and report a webPreviewUrl)
+                // on Darwin. Android sessions go without a preview URL.
+                if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
+                    serveSim = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
+                        baseDomain: ngrokTunnelDomain,
+                        env,
+                        logger,
+                        timeoutMs: STARTUP_TIMEOUT_MS,
+                    });
+                    logger.info(`Web preview URL: ${serveSim.previewUrl}`);
+                }
+                await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
+                    ctx,
+                    deviceRunSessionId,
+                    remoteConfig: {
+                        agentDeviceRemoteSessionUrl,
+                        agentDeviceRemoteSessionToken: daemonToken,
+                        ...(serveSim ? { webPreviewUrl: serveSim.previewUrl } : {}),
+                    },
+                    logger,
+                });
+                void (0, agentDeviceArtifacts_1.pollAgentDeviceArtifactsForUploadAsync)(ctx, {
+                    deviceRunSessionId,
+                    daemonUrl: `http://127.0.0.1:${daemonPort}`,
+                    daemonToken,
+                    logger,
+                });
+                eventCollection = await (0, agentDeviceEvents_1.startAgentDeviceEventCollectionAsync)({
+                    ctx,
+                    deviceRunSessionId,
+                    stateDir: AGENT_DEVICE_STATE_DIR,
                     logger,
-                    timeoutMs: STARTUP_TIMEOUT_MS,
                 });
-                webPreviewUrl = previewUrl;
-                logger.info(`Web preview URL: ${webPreviewUrl}`);
-            }
-            await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
-                ctx,
-                deviceRunSessionId,
-                remoteConfig: {
-                    agentDeviceRemoteSessionUrl,
-                    agentDeviceRemoteSessionToken: daemonToken,
-                    ...(webPreviewUrl ? { webPreviewUrl } : {}),
-                },
-                logger,
-            });
-            void (0, agentDeviceArtifacts_1.pollAgentDeviceArtifactsForUploadAsync)(ctx, {
-                deviceRunSessionId,
-                daemonUrl: `http://127.0.0.1:${daemonPort}`,
-                daemonToken,
-                logger,
-            });
-            const eventCollection = await (0, deviceRunSessionEvents_1.startAgentDeviceEventCollectionAsync)({
-                ctx,
-                deviceRunSessionId,
-                stateDir: AGENT_DEVICE_STATE_DIR,
-                logger,
-            });
-            try {
                 await (0, remoteDeviceRunSession_1.waitForDeviceRunSessionStoppedAsync)({
                     ctx,
                     deviceRunSessionId,
@@ -111,11 +112,18 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                 });
             }
             finally {
-                await stopAgentDeviceEventCollectionSafelyAsync({
-                    eventCollection,
-                    deviceRunSessionId,
-                    logger,
-                });
+                if (serveSim) {
+                    await serveSim.stopAsync();
+                }
+                await agentDeviceTunnel.stopAsync();
+                if (eventCollection) {
+                    await stopAgentDeviceEventCollectionSafelyAsync({
+                        eventCollection,
+                        deviceRunSessionId,
+                        logger,
+                    });
+                }
+                await daemonProcess.stopAsync();
             }
         },
     });

package/dist/steps/functions/startArgentRemoteSession.d.ts

@@ -2,7 +2,7 @@ import { type bunyan } from '@expo/logger';
 import { BuildFunction } from '@expo/steps';
 import { z } from 'zod';
 import { CustomBuildContext } from '../../customBuildContext';
-export declare const MIN_ARGENT_REMOTE_SESSION_VERSION = "0.12.0";
+export declare const MIN_ARGENT_REMOTE_SESSION_VERSION = "0.16.0";
 declare const ArgentToolServerStateSchema: z.ZodObject<{
     port: z.ZodNumber;
     pid: z.ZodNumber;
@@ -10,6 +10,13 @@ declare const ArgentToolServerStateSchema: z.ZodObject<{
 }, z.core.$strip>;
 type ArgentToolServerState = z.infer<typeof ArgentToolServerStateSchema>;
 export declare function createStartArgentRemoteSessionBuildFunction(ctx: CustomBuildContext): BuildFunction;
+export declare function stopArgentEventCollectionSafelyAsync({ eventCollection, deviceRunSessionId, logger, }: {
+    eventCollection: {
+        stopAsync: () => Promise<void>;
+    };
+    deviceRunSessionId: string;
+    logger: bunyan;
+}): Promise<void>;
 export declare function warnIfArgentPackageVersionCannotBeVerified({ packageVersion, logger, }: {
     packageVersion: string | undefined;
     logger: bunyan;

package/dist/steps/functions/startArgentRemoteSession.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MIN_ARGENT_REMOTE_SESSION_VERSION = void 0;
 exports.createStartArgentRemoteSessionBuildFunction = createStartArgentRemoteSessionBuildFunction;
+exports.stopArgentEventCollectionSafelyAsync = stopArgentEventCollectionSafelyAsync;
 exports.warnIfArgentPackageVersionCannotBeVerified = warnIfArgentPackageVersionCannotBeVerified;
 exports.waitForArgentToolServerStateAsync = waitForArgentToolServerStateAsync;
 const eas_build_job_1 = require("@expo/eas-build-job");
@@ -19,11 +20,20 @@ const sentry_1 = require("../../sentry");
 const processes_1 = require("../../utils/processes");
 const retry_1 = require("../../utils/retry");
 const argentArtifacts_1 = require("../utils/argentArtifacts");
+const argentEvents_1 = require("../utils/argentEvents");
 const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
 const ARGENT_PACKAGE_NAME = '@swmansion/argent';
-exports.MIN_ARGENT_REMOTE_SESSION_VERSION = '0.12.0';
+// 0.16.0 is the first version that exposes the tool-server event log flag; keeping the floor
+// here lets us enable it (and the artifacts list endpoint) unconditionally below.
+exports.MIN_ARGENT_REMOTE_SESSION_VERSION = '0.16.0';
 const ARGENT_ARTIFACTS_LIST_ENDPOINT_FLAG = 'artifacts-list-endpoint';
+// Tells the tool-server to write its structured event log so we can collect session events.
+const ARGENT_EVENT_LOG_FLAG = 'tool-server-event-log';
 const ARGENT_STATE_DIR = node_path_1.default.join(node_os_1.default.homedir(), '.argent');
+// Pin the event log path explicitly and hand the same value to the tool-server (via
+// ARGENT_EVENT_LOG) and the collector, so an ambient ARGENT_EVENT_LOG or a future change to
+// Argent's default can never make the two disagree.
+const ARGENT_EVENT_LOG_PATH = node_path_1.default.join(ARGENT_STATE_DIR, argentEvents_1.ARGENT_EVENT_LOG_FILENAME);
 const STARTUP_TIMEOUT_MS = 60_000;
 const ArgentToolServerStateSchema = zod_1.z.object({
     port: zod_1.z.number(),
@@ -59,8 +69,15 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
             if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
                 await (0, remoteDeviceRunSession_1.selectXcodeDeveloperDirectoryAsync)({ env, logger });
             }
+            // Argent shells out to ffmpeg to record the screen. Installing it pulls a
+            // large Homebrew dependency tree, so do not block session readiness on it:
+            // the session comes up at its usual speed and only a recording started in
+            // the first moments misses ffmpeg. Never rejects, so `void` is safe.
+            void (0, remoteDeviceRunSession_1.ensureFfmpegInstalledAsync)({ runtimePlatform, env, logger });
             logger.info('Enabling the Argent artifacts list endpoint flag.');
             await (0, turtle_spawn_1.default)('bunx', [`${ARGENT_PACKAGE_NAME}@${versionSpec}`, 'enable', ARGENT_ARTIFACTS_LIST_ENDPOINT_FLAG], { env, logger });
+            logger.info('Enabling the Argent tool-server event log flag.');
+            await (0, turtle_spawn_1.default)('bunx', [`${ARGENT_PACKAGE_NAME}@${versionSpec}`, 'enable', ARGENT_EVENT_LOG_FLAG], { env, logger });
             logger.info(`Launching ${ARGENT_PACKAGE_NAME}@${versionSpec} tool-server via bunx.`);
             // Keep Argent itself in foreground mode under the detached bunx process. This preserves
             // the bunx -> Argent CLI -> tool-server ancestry used to identify the matching state file.
@@ -76,7 +93,7 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                     '0',
                     '--force',
                 ],
-                env,
+                env: { ...env, ARGENT_EVENT_LOG: ARGENT_EVENT_LOG_PATH },
             });
             if (argentServer.pid === undefined) {
                 throw new eas_build_job_1.SystemError('Failed to start Argent: could not determine the PID of the launched process.');
@@ -109,8 +126,16 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                 logger,
                 signal: artifactPollSignal,
             });
+            const eventCollection = await (0, argentEvents_1.startArgentEventCollectionAsync)({
+                ctx,
+                deviceRunSessionId,
+                eventLogPath: ARGENT_EVENT_LOG_PATH,
+                logger,
+            });
+            let toolsTunnel;
+            let serveSim;
             try {
-                const publicToolsUrl = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
+                toolsTunnel = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
                     port: toolServerPort,
                     subdomainPrefix: 'argent',
                     baseDomain: ngrokTunnelDomain,
@@ -118,11 +143,12 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                     rewriteHostHeader: true,
                     logger,
                 });
+                const publicToolsUrl = toolsTunnel.url;
                 logger.info(`Tunnel is ready at ${publicToolsUrl}.`);
                 // serve-sim is iOS-only — Android sessions go without a preview URL.
                 let webPreviewUrl;
                 if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
-                    const serveSim = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
+                    serveSim = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
                         baseDomain: ngrokTunnelDomain,
                         env,
                         logger,
@@ -149,6 +175,13 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                 });
             }
             finally {
+                if (serveSim) {
+                    await serveSim.stopAsync();
+                }
+                if (toolsTunnel) {
+                    await toolsTunnel.stopAsync();
+                }
+                await stopArgentEventCollectionSafelyAsync({ eventCollection, deviceRunSessionId, logger });
                 artifactPollAbortController.abort();
                 try {
                     await artifactPollingPromise;
@@ -158,10 +191,25 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                     sentry_1.Sentry.capture('Could not finish Argent remote session artifact polling', error);
                     logger.warn({ err: error }, 'Could not finish Argent remote session artifact polling.');
                 }
+                await argentServer.stopAsync();
             }
         },
     });
 }
+async function stopArgentEventCollectionSafelyAsync({ eventCollection, deviceRunSessionId, logger, }) {
+    try {
+        await eventCollection.stopAsync();
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        sentry_1.Sentry.capture('Could not finish argent session event collection', error, {
+            level: 'warning',
+            tags: { phase: 'argent-event-collection', operation: 'stop' },
+            extras: { deviceRunSessionId },
+        });
+        logger.warn({ err: error }, 'Could not finish argent session event collection.');
+    }
+}
 function warnIfArgentPackageVersionCannotBeVerified({ packageVersion, logger, }) {
     if (!packageVersion || packageVersion === 'latest') {
         return;

package/dist/steps/functions/startServeSimMetrics.d.ts

@@ -0,0 +1,2 @@
+import { BuildFunction } from '@expo/steps';
+export declare function createStartServeSimMetricsBuildFunction(): BuildFunction;

package/dist/steps/functions/startServeSimMetrics.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStartServeSimMetricsBuildFunction = createStartServeSimMetricsBuildFunction;
+const steps_1 = require("@expo/steps");
+const serveSimMetricsRecorder_1 = require("../utils/serveSimMetricsRecorder");
+function createStartServeSimMetricsBuildFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'start_serve_sim_metrics',
+        name: 'Start serve-sim metrics',
+        __metricsId: 'eas/start_serve_sim_metrics',
+        supportedRuntimePlatforms: [steps_1.BuildRuntimePlatform.DARWIN],
+        fn: async ({ logger }) => {
+            await serveSimMetricsRecorder_1.ServeSimMetricsRecorder.startAsync({ logger });
+        },
+    });
+}

package/dist/steps/functions/startServeSimRemoteSession.js

@@ -16,25 +16,30 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
             const ngrokTunnelDomain = (0, remoteDeviceRunSession_1.getNgrokTunnelDomainOrThrow)(env);
             logger.info('Starting serve-sim remote session.');
             await (0, remoteDeviceRunSession_1.selectXcodeDeveloperDirectoryAsync)({ env, logger });
-            const { previewUrl } = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
+            const serveSim = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
                 baseDomain: ngrokTunnelDomain,
                 env,
                 logger,
                 timeoutMs: STARTUP_TIMEOUT_MS,
             });
-            logger.info(`Preview URL: ${previewUrl}`);
-            await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
-                ctx,
-                deviceRunSessionId,
-                remoteConfig: { previewUrl },
-                logger,
-            });
-            await (0, remoteDeviceRunSession_1.waitForDeviceRunSessionStoppedAsync)({
-                ctx,
-                deviceRunSessionId,
-                logger,
-                signal,
-            });
+            logger.info(`Preview URL: ${serveSim.previewUrl}`);
+            try {
+                await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
+                    ctx,
+                    deviceRunSessionId,
+                    remoteConfig: { previewUrl: serveSim.previewUrl },
+                    logger,
+                });
+                await (0, remoteDeviceRunSession_1.waitForDeviceRunSessionStoppedAsync)({
+                    ctx,
+                    deviceRunSessionId,
+                    logger,
+                    signal,
+                });
+            }
+            finally {
+                await serveSim.stopAsync();
+            }
         },
     });
 }

package/dist/steps/utils/agentDeviceArtifacts.js

@@ -68,7 +68,7 @@ async function pollAgentDeviceArtifactsForUploadAsync(ctx, { deviceRunSessionId,
             }
             const error = err instanceof Error ? err : new Error(String(err));
             listArtifactsErrorCount += 1;
-            if (listArtifactsErrorCount === 1 || listArtifactsErrorCount % 5 === 0) {
+            if (listArtifactsErrorCount % 5 === 0) {
                 sentry_1.Sentry.capture('Could not list agent-device remote session artifacts', error);
                 logger.warn({ err: error, failedArtifactListCount: listArtifactsErrorCount }, 'Could not list agent-device remote session artifacts.');
             }

package/dist/steps/utils/agentDeviceEvents.d.ts

@@ -0,0 +1,11 @@
+import { type bunyan } from '@expo/logger';
+import { type CustomBuildContext } from '../../customBuildContext';
+export declare function startAgentDeviceEventCollectionAsync({ ctx, deviceRunSessionId, stateDir, logger, pollIntervalMs, }: {
+    ctx: CustomBuildContext;
+    deviceRunSessionId: string;
+    stateDir: string;
+    logger: bunyan;
+    pollIntervalMs?: number;
+}): Promise<{
+    stopAsync: () => Promise<void>;
+}>;

package/dist/steps/utils/agentDeviceEvents.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startAgentDeviceEventCollectionAsync = startAgentDeviceEventCollectionAsync;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const zod_1 = require("zod");
+const deviceRunSessionEvents_1 = require("./deviceRunSessionEvents");
+const AGENT_DEVICE_PRODUCER = 'agent-device';
+const AGENT_DEVICE_EVENT_KIND_TO_TYPE = {
+    'request.started': 'operation.started',
+    'request.finished': 'operation.completed',
+    'action.recorded': 'interaction.recorded',
+};
+const AgentDeviceEventSchema = zod_1.z
+    .object({
+    version: zod_1.z.number(),
+    ts: zod_1.z.string(),
+    session: zod_1.z.string(),
+    kind: zod_1.z.string(),
+    requestId: zod_1.z.string().optional().catch(undefined),
+    command: zod_1.z.string().optional().catch(undefined),
+    status: zod_1.z.string().optional().catch(undefined),
+    summary: zod_1.z.string().optional().catch(undefined),
+    details: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional().catch(undefined),
+})
+    .passthrough();
+async function startAgentDeviceEventCollectionAsync({ ctx, deviceRunSessionId, stateDir, logger, pollIntervalMs, }) {
+    return (0, deviceRunSessionEvents_1.startDeviceRunSessionEventCollectionAsync)({
+        ctx,
+        deviceRunSessionId,
+        logger,
+        pollIntervalMs,
+        source: {
+            producer: AGENT_DEVICE_PRODUCER,
+            findEventFilesAsync: () => findAgentDeviceEventFilesAsync(stateDir),
+            sourceKeyForFile: eventFile => node_path_1.default.basename(node_path_1.default.dirname(eventFile)),
+            parseLine: ({ line, sourceKey, sequenceNumber, deviceRunSessionId }) => {
+                const { event, failure } = parseAgentDeviceEvent(line);
+                if (!event) {
+                    return { failure };
+                }
+                return {
+                    event: normalizeAgentDeviceEvent({
+                        event,
+                        sequenceNumber,
+                        sourceSessionDirectory: sourceKey,
+                        deviceRunSessionId,
+                    }),
+                };
+            },
+        },
+    });
+}
+async function findAgentDeviceEventFilesAsync(stateDir) {
+    const sessionsDir = node_path_1.default.join(stateDir, 'sessions');
+    let entries;
+    try {
+        entries = await node_fs_1.default.promises.readdir(sessionsDir, { withFileTypes: true });
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return [];
+        }
+        throw err;
+    }
+    return entries
+        .filter(entry => entry.isDirectory())
+        .map(entry => node_path_1.default.join(sessionsDir, entry.name, 'events.ndjson'));
+}
+function parseAgentDeviceEvent(line) {
+    if (!line.trim()) {
+        return {};
+    }
+    try {
+        const result = AgentDeviceEventSchema.safeParse(JSON.parse(line));
+        return result.success ? { event: result.data } : { failure: 'invalid-event' };
+    }
+    catch {
+        return { failure: 'invalid-json' };
+    }
+}
+function normalizeAgentDeviceEvent({ event, sequenceNumber, sourceSessionDirectory, deviceRunSessionId, }) {
+    const type = AGENT_DEVICE_EVENT_KIND_TO_TYPE[event.kind] ?? event.kind;
+    const durationMs = event.details?.durationMs;
+    const outcome = event.status === 'ok' ? 'success' : event.status === 'error' ? 'failure' : undefined;
+    const summary = event.summary ??
+        (event.kind === 'request.started'
+            ? `Started ${event.command ?? 'activity'}`
+            : event.kind === 'request.finished'
+                ? `Finished ${event.command ?? 'activity'}`
+                : event.kind === 'action.recorded'
+                    ? `Recorded ${event.command ?? 'activity'}`
+                    : `${event.kind}${event.command ? `: ${event.command}` : ''}`);
+    return {
+        v: 1,
+        // Consumers use eventId to deduplicate events across polls. Keep the per-file sequence
+        // monotonic across source-file truncations so an ID is never reused during collection.
+        eventId: `agent-device:${deviceRunSessionId}:${sourceSessionDirectory}:${sequenceNumber}`,
+        ts: event.ts,
+        producer: 'agent-device',
+        type,
+        ...(event.requestId ? { operationId: event.requestId } : {}),
+        ...(outcome ? { outcome } : {}),
+        ...(typeof durationMs === 'number' ? { durationMs } : {}),
+        summary,
+        data: {
+            ...event.details,
+            session: event.session,
+            sourceVersion: event.version,
+            ...(event.status ? { sourceStatus: event.status } : {}),
+        },
+    };
+}

package/dist/steps/utils/argentArtifacts.js

@@ -68,7 +68,7 @@ async function pollArgentArtifactsForUploadAsync(ctx, { deviceRunSessionId, tool
             }
             const error = err instanceof Error ? err : new Error(String(err));
             listArtifactsErrorCount += 1;
-            if (listArtifactsErrorCount === 1 || listArtifactsErrorCount % 5 === 0) {
+            if (listArtifactsErrorCount % 5 === 0) {
                 sentry_1.Sentry.capture('Could not list Argent remote session artifacts', error);
                 logger.warn({ err: error, failedArtifactListCount: listArtifactsErrorCount }, 'Could not list Argent remote session artifacts.');
             }

package/dist/steps/utils/argentEvents.d.ts

@@ -0,0 +1,12 @@
+import { type bunyan } from '@expo/logger';
+import { type CustomBuildContext } from '../../customBuildContext';
+export declare const ARGENT_EVENT_LOG_FILENAME = "tool-server-events.jsonl";
+export declare function startArgentEventCollectionAsync({ ctx, deviceRunSessionId, eventLogPath, logger, pollIntervalMs, }: {
+    ctx: CustomBuildContext;
+    deviceRunSessionId: string;
+    eventLogPath: string;
+    logger: bunyan;
+    pollIntervalMs?: number;
+}): Promise<{
+    stopAsync: () => Promise<void>;
+}>;

package/dist/steps/utils/argentEvents.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARGENT_EVENT_LOG_FILENAME = void 0;
+exports.startArgentEventCollectionAsync = startArgentEventCollectionAsync;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const zod_1 = require("zod");
+const deviceRunSessionEvents_1 = require("./deviceRunSessionEvents");
+const ARGENT_PRODUCER = 'argent';
+// Argent's tool-server writes its event log to `~/.argent/tool-server-events.jsonl`
+// (its default $ARGENT_EVENT_LOG path) once the `tool-server-event-log` flag is on.
+exports.ARGENT_EVENT_LOG_FILENAME = 'tool-server-events.jsonl';
+// Argent records are bunyan log lines tagged with a `type`. Map the tool-lifecycle
+// types onto the shared operation vocabulary; anything else (service.*,
+// tool_server.*, future types) passes through unchanged, mirroring agent-device.
+const ARGENT_EVENT_TYPE_TO_TYPE = {
+    'tool.invoked': 'operation.started',
+    'tool.completed': 'operation.completed',
+    'tool.failed': 'operation.completed',
+};
+// Bunyan bookkeeping plus the fields we promote to the top level of a
+// DeviceRunSessionEvent — excluded from the free-form `data` bag so it carries
+// only the record's own context (toolId, serviceId, failureSignal, ...).
+const NON_DATA_KEYS = new Set([
+    'name',
+    'hostname',
+    'pid',
+    'v',
+    'time',
+    'msg',
+    'level',
+    'type',
+    'toolInvocationId',
+    'durationMs',
+]);
+const ArgentEventSchema = zod_1.z
+    .object({
+    time: zod_1.z.string(),
+    type: zod_1.z.string(),
+    // Argent's EventLogRecord requires `msg` and every emit site sets it to the
+    // human-readable description of the event, so it is our summary verbatim.
+    msg: zod_1.z.string(),
+    level: zod_1.z.number().optional().catch(undefined),
+    toolId: zod_1.z.string().optional().catch(undefined),
+    toolInvocationId: zod_1.z.string().optional().catch(undefined),
+    durationMs: zod_1.z.number().optional().catch(undefined),
+})
+    .passthrough();
+async function startArgentEventCollectionAsync({ ctx, deviceRunSessionId, eventLogPath, logger, pollIntervalMs, }) {
+    return (0, deviceRunSessionEvents_1.startDeviceRunSessionEventCollectionAsync)({
+        ctx,
+        deviceRunSessionId,
+        logger,
+        pollIntervalMs,
+        source: {
+            producer: ARGENT_PRODUCER,
+            findEventFilesAsync: () => findArgentEventFilesAsync(eventLogPath),
+            sourceKeyForFile: eventFile => node_path_1.default.basename(eventFile, node_path_1.default.extname(eventFile)),
+            parseLine: ({ line, sourceKey, sequenceNumber, deviceRunSessionId }) => {
+                const { event, failure } = parseArgentEvent(line);
+                if (!event) {
+                    return { failure };
+                }
+                return {
+                    event: normalizeArgentEvent({ event, sequenceNumber, sourceKey, deviceRunSessionId }),
+                };
+            },
+        },
+    });
+}
+async function findArgentEventFilesAsync(eventLogPath) {
+    try {
+        await node_fs_1.default.promises.access(eventLogPath);
+        return [eventLogPath];
+    }
+    catch (err) {
+        // The tool-server has not created the file yet — expected until the first event is written.
+        // Surface any other error (permissions, I/O) to the engine so it reaches Sentry.
+        if (err.code === 'ENOENT') {
+            return [];
+        }
+        throw err;
+    }
+}
+function parseArgentEvent(line) {
+    if (!line.trim()) {
+        return {};
+    }
+    try {
+        const result = ArgentEventSchema.safeParse(JSON.parse(line));
+        return result.success ? { event: result.data } : { failure: 'invalid-event' };
+    }
+    catch {
+        return { failure: 'invalid-json' };
+    }
+}
+function normalizeArgentEvent({ event, sequenceNumber, sourceKey, deviceRunSessionId, }) {
+    const type = ARGENT_EVENT_TYPE_TO_TYPE[event.type] ?? event.type;
+    const outcome = event.type === 'tool.completed'
+        ? 'success'
+        : event.type === 'tool.failed'
+            ? 'failure'
+            : undefined;
+    const data = {};
+    for (const [key, value] of Object.entries(event)) {
+        if (!NON_DATA_KEYS.has(key) && value !== undefined) {
+            data[key] = value;
+        }
+    }
+    data.sourceType = event.type;
+    if (typeof event.level === 'number') {
+        data.sourceLevel = event.level;
+    }
+    return {
+        v: 1,
+        // Consumers use eventId to deduplicate events across polls. Keep the per-file sequence
+        // monotonic across source-file truncations so an ID is never reused during collection.
+        eventId: `argent:${deviceRunSessionId}:${sourceKey}:${sequenceNumber}`,
+        ts: event.time,
+        producer: 'argent',
+        type,
+        ...(event.toolInvocationId ? { operationId: event.toolInvocationId } : {}),
+        ...(outcome ? { outcome } : {}),
+        ...(typeof event.durationMs === 'number' ? { durationMs: event.durationMs } : {}),
+        summary: event.msg,
+        data,
+    };
+}