@aiwg/cli 2026.8.19 → 2026.8.25

package/dist/src/uhp/mission.js

@@ -0,0 +1,111 @@
+import { UHP_VERSION } from './types.js';
+import { decodeMission } from '../mission-protocol/index.js';
+function collectArtifacts(response) {
+    const artifacts = new Map();
+    const visit = (value) => {
+        if (Array.isArray(value)) {
+            value.forEach(visit);
+            return;
+        }
+        if (!value || typeof value !== 'object')
+            return;
+        const object = value;
+        if (typeof object.file_id === 'string')
+            artifacts.set(object.file_id, {
+                fileId: object.file_id,
+                ...(typeof object.container_id === 'string' ? { containerId: object.container_id } : {}),
+                ...(typeof object.filename === 'string' ? { filename: object.filename } : {}),
+                ...(typeof object.media_type === 'string' ? { mediaType: object.media_type } : {}),
+                source: structuredClone(object),
+            });
+        for (const child of Object.values(object))
+            visit(child);
+    };
+    visit(response.output);
+    return [...artifacts.values()];
+}
+function collectInputFiles(request) {
+    const files = [];
+    const visit = (value) => {
+        if (Array.isArray(value)) {
+            value.forEach(visit);
+            return;
+        }
+        if (!value || typeof value !== 'object')
+            return;
+        const object = value;
+        if (object.type === 'input_file')
+            files.push({
+                ...(typeof object.file_id === 'string' ? { fileId: object.file_id } : {}),
+                ...(typeof object.filename === 'string' ? { filename: object.filename } : {}),
+                ...(typeof object.file_data === 'string' && object.file_data.startsWith('data:') ? { mediaType: object.file_data.slice(5).split(/[;,]/, 1)[0] } : {}),
+                source: structuredClone(object),
+            });
+        for (const child of Object.values(object))
+            visit(child);
+    };
+    visit(request.input);
+    return files;
+}
+export function projectUhpResponseToMission(profile, response, request = { input: '' }, event) {
+    const known = ['in_progress', 'completed', 'failed', 'incomplete', 'cancelled'].includes(response.status);
+    const state = response.status === 'in_progress' ? 'running' : known ? response.status : 'unknown';
+    const metadata = response.metadata ?? {};
+    const artifacts = collectArtifacts(response);
+    const knownKeys = new Set(['id', 'object', 'created_at', 'status', 'model', 'previous_response_id', 'output', 'error', 'incomplete_details', 'metadata', 'store', 'usage']);
+    return {
+        transport: 'uhp',
+        protocolVersion: UHP_VERSION,
+        endpointProfile: profile,
+        state,
+        nativeState: response.status,
+        observationState: known ? 'authoritative' : 'unknown',
+        responseId: response.id,
+        previousResponseId: response.previous_response_id ?? request.previous_response_id,
+        sessionId: metadata.session_id,
+        harness: {
+            requested: request.metadata?.harness_id,
+            actual: metadata.harness_id,
+            substitutionReason: typeof metadata.harness_substitution_reason === 'string' ? metadata.harness_substitution_reason : undefined,
+        },
+        model: {
+            requested: request.model,
+            actual: response.model,
+            substitutionReason: metadata.model_substitution_reason ?? (typeof metadata.model_fallback_reason === 'string' ? metadata.model_fallback_reason : undefined),
+        },
+        containerId: metadata.container_id,
+        eventSequence: event?.sequence_number,
+        terminalEvent: event && /^response\.(?:completed|failed|incomplete|cancelled)$/.test(event.type) ? event.type : undefined,
+        artifactIds: artifacts.map(artifact => artifact.fileId),
+        inputFiles: collectInputFiles(request),
+        artifacts,
+        partialOutput: response.status !== 'completed' && Boolean(response.output?.length),
+        extensions: Object.fromEntries(Object.entries(response).filter(([key]) => !knownKeys.has(key))),
+        ...(known ? {} : { diagnostic: `Unknown UHP response state '${String(response.status)}'` }),
+    };
+}
+export function unknownUhpMissionEvidence(profile, diagnostic, responseId, lastSequence) {
+    return {
+        transport: 'uhp', protocolVersion: UHP_VERSION, endpointProfile: profile,
+        state: 'unknown', nativeState: 'unknown', observationState: 'unknown', responseId,
+        harness: {}, model: {}, eventSequence: lastSequence, artifactIds: [], inputFiles: [], artifacts: [], partialOutput: false,
+        extensions: {}, diagnostic,
+    };
+}
+/** Canonical Mission adapter consumed by UHP; the legacy evidence projection remains a compatibility view. */
+export function projectUhpResponseToCanonicalMission(profile, response, request = { input: '' }, event) {
+    const evidence = projectUhpResponseToMission(profile, response, request, event);
+    return decodeMission({
+        ...evidence,
+        objective: typeof request.input === 'string' && request.input.length ? request.input : 'UHP task',
+        status: evidence.nativeState,
+        artifacts: evidence.artifacts.map(artifact => ({
+            id: artifact.fileId,
+            kind: 'uhp-file',
+            ...(artifact.mediaType ? { mediaType: artifact.mediaType } : {}),
+            ...(artifact.source.sha256 ? { sha256: artifact.source.sha256 } : {}),
+            extensions: { 'uhp.file': artifact.source },
+        })),
+    }, 'uhp-2026-08-11');
+}
+//# sourceMappingURL=mission.js.map

package/dist/src/uhp/sse.js

@@ -0,0 +1,76 @@
+import { UhpError, redactUhpText } from './errors.js';
+const TERMINAL_EVENTS = new Set(['response.completed', 'response.failed', 'response.incomplete', 'response.cancelled']);
+export async function* parseUhpEventStream(body, options) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let expectedSequence = 0;
+    let terminalCount = 0;
+    let first = true;
+    const read = async () => {
+        let timer;
+        try {
+            return await Promise.race([
+                reader.read(),
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new UhpError('stream_inactivity_timeout', 'UHP stream became inactive; remote task state is unknown', { retryable: true, remoteState: 'unknown' })), options.inactivityTimeoutMs);
+                }),
+            ]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    };
+    const decodeBlock = (block) => {
+        const data = block.split(/\r?\n/).filter(line => line.startsWith('data:')).map(line => line.slice(5).trimStart()).join('\n');
+        if (!data)
+            return undefined;
+        let event;
+        try {
+            event = JSON.parse(data);
+        }
+        catch {
+            throw new UhpError('malformed_sse', redactUhpText('Malformed JSON in UHP event stream', options.secrets), { remoteState: 'unknown' });
+        }
+        if (!Number.isSafeInteger(event.sequence_number) || event.sequence_number !== expectedSequence) {
+            throw new UhpError('event_sequence_gap', `Expected UHP event sequence ${expectedSequence}, received ${String(event.sequence_number)}`, { remoteState: 'unknown' });
+        }
+        if (first && event.type !== 'response.created')
+            throw new UhpError('invalid_first_event', `First UHP event must be response.created, received ${event.type}`, { remoteState: 'unknown' });
+        first = false;
+        expectedSequence += 1;
+        if (TERMINAL_EVENTS.has(event.type))
+            terminalCount += 1;
+        if (terminalCount > 1)
+            throw new UhpError('duplicate_terminal_event', 'UHP stream emitted more than one terminal event', { remoteState: 'unknown' });
+        return event;
+    };
+    try {
+        while (true) {
+            options.signal?.throwIfAborted();
+            const { done, value } = await read();
+            buffer += decoder.decode(value, { stream: !done });
+            const blocks = buffer.split(/\r?\n\r?\n/);
+            buffer = blocks.pop() ?? '';
+            for (const block of blocks) {
+                const event = decodeBlock(block);
+                if (event)
+                    yield event;
+            }
+            if (done)
+                break;
+        }
+        if (buffer.trim()) {
+            const event = decodeBlock(buffer);
+            if (event)
+                yield event;
+        }
+        if (terminalCount !== 1)
+            throw new UhpError('missing_terminal_event', 'UHP stream ended without exactly one terminal event; remote task state is unknown', { retryable: true, remoteState: 'unknown' });
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+//# sourceMappingURL=sse.js.map

package/dist/src/uhp/types.js

@@ -0,0 +1,2 @@
+export const UHP_VERSION = '2026-08-11';
+//# sourceMappingURL=types.js.map

package/dist/src/update/service.mjs

@@ -6,7 +6,6 @@
  * the calling handlers.
  */
 
-import { execFileSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { getPackageRoot, loadConfig } from '../channel/manager.mjs';
@@ -16,7 +15,7 @@ import {
   loadInstallationIdentity,
   saveInstallationIdentity,
 } from '../installation/manager.mjs';
-import { resolveManagerCommand } from '../installation/manager-command.mjs';
+import { executeManagerCommand } from '../installation/manager-command.mjs';
 
 const VALID_MODES = new Set(['npm', 'web', 'source']);
 
@@ -149,9 +148,7 @@ export async function updateInstallation(options = {}) {
     throw new Error('Canonical npm installation has no package-manager executable. Run `aiwg installation adopt --manager <absolute-path-to-npm>`.');
   }
   if (!dryRun) {
-    const invocation = resolveManagerCommand(managerExecutable, command, options);
-    const execute = options.execute ?? ((file, args) => execFileSync(file, args, { stdio: 'inherit' }));
-    execute(invocation.file, invocation.args);
+    executeManagerCommand(managerExecutable, command, options);
     if (detected.identity && detected.identityPersistent && options.persistIdentity !== false) {
       saveInstallationIdentity({ ...detected.identity, channel }, options);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwg/cli",
-  "version": "2026.8.19",
+  "version": "2026.8.25",
   "description": "Lightweight AIWG CLI for signed, versioned web-backed resources.",
   "type": "module",
   "license": "MIT",