@aiwg/cli 2026.8.0 → 2026.8.1

package/dist/src/memory/intake.js

@@ -0,0 +1,118 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, writeFileSync, } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { basename, dirname, extname, relative, resolve, sep } from 'node:path';
+function sha256(value) {
+    return `sha256:${createHash('sha256').update(value).digest('hex')}`;
+}
+function safeProjectFile(projectRoot, requested) {
+    const root = realpathSync(projectRoot);
+    const candidate = realpathSync(resolve(root, requested));
+    if (candidate !== root && !candidate.startsWith(`${root}${sep}`)) {
+        throw new Error('intake source must resolve inside the project');
+    }
+    const segments = relative(root, candidate).split(sep);
+    if (segments.some(segment => segment === '.env' || segment === '.ssh'
+        || /^(?:credentials?|secrets?|tokens?)(?:\.|$)/i.test(segment))) {
+        throw new Error('protected paths cannot be ingested into ordinary project memory');
+    }
+    return { absolute: candidate, locator: segments.join('/') };
+}
+function kindFor(filePath) {
+    const extension = extname(filePath).toLocaleLowerCase();
+    if (['.jsonl', '.transcript'].includes(extension))
+        return 'session-transcript';
+    if (['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg'].includes(extension))
+        return 'image';
+    if (extension === '.pdf')
+        return 'pdf';
+    if (['.yaml', '.yml', '.json'].includes(extension))
+        return 'structured';
+    if (['.md', '.txt', '.html', '.htm'].includes(extension))
+        return 'document';
+    return 'artifact';
+}
+function assertFuturePathInsideProject(projectRoot, target) {
+    let ancestor = target;
+    while (!existsSync(ancestor))
+        ancestor = dirname(ancestor);
+    const actual = realpathSync(ancestor);
+    if (actual !== projectRoot && !actual.startsWith(`${projectRoot}${sep}`)) {
+        throw new Error('intake storage cannot traverse a link outside the project');
+    }
+}
+function atomicJson(filePath, value) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
+    renameSync(temporary, filePath);
+}
+export class MemoryIntakeCoordinator {
+    projectRoot;
+    rawRoot;
+    receiptRoot;
+    constructor(projectRoot) {
+        this.projectRoot = realpathSync(projectRoot);
+        this.rawRoot = resolve(this.projectRoot, '.aiwg/wiki/raw');
+        this.receiptRoot = resolve(this.projectRoot, '.aiwg/memory/compound-memory/intake-receipts');
+        assertFuturePathInsideProject(this.projectRoot, this.rawRoot);
+        assertFuturePathInsideProject(this.projectRoot, this.receiptRoot);
+    }
+    preview(requested) {
+        const source = safeProjectFile(this.projectRoot, requested);
+        const stat = statSync(source.absolute);
+        if (!stat.isFile())
+            throw new Error('intake source must be a regular file');
+        const bytes = readFileSync(source.absolute);
+        const digest = sha256(bytes);
+        const kind = kindFor(source.absolute);
+        const safeName = basename(source.absolute).replace(/[^a-zA-Z0-9._-]+/g, '-');
+        const rawLocator = `.aiwg/wiki/raw/${digest.slice(7, 23)}-${safeName}`;
+        const rawPath = resolve(this.projectRoot, rawLocator);
+        const duplicate = existsSync(rawPath) && sha256(readFileSync(rawPath)) === digest;
+        const identity = {
+            source: { locator: source.locator, digest, byteLength: bytes.length, kind },
+            rawLocator,
+            route: kind === 'session-transcript' ? 'sessions' : 'llm-wiki',
+        };
+        return {
+            schemaVersion: 'aiwg.compound-memory.intake-preview.v1',
+            operationId: sha256(JSON.stringify(identity)),
+            ...identity,
+            duplicate,
+            confirmationRequired: true,
+            mutation: { wouldCopyRaw: !duplicate, wouldPromoteKnowledge: false },
+        };
+    }
+    confirm(requested, operationId) {
+        const preview = this.preview(requested);
+        const receiptPath = resolve(this.receiptRoot, `${operationId.replace(':', '_')}.json`);
+        if (existsSync(receiptPath)) {
+            return { ...JSON.parse(readFileSync(receiptPath, 'utf8')), duplicate: true };
+        }
+        if (preview.operationId !== operationId) {
+            throw new Error('intake confirmation requires the exact current preview');
+        }
+        const source = safeProjectFile(this.projectRoot, requested);
+        const rawPath = resolve(this.projectRoot, preview.rawLocator);
+        mkdirSync(this.rawRoot, { recursive: true, mode: 0o700 });
+        if (!preview.duplicate)
+            copyFileSync(source.absolute, rawPath, 1);
+        if (sha256(readFileSync(rawPath)) !== preview.source.digest) {
+            throw new Error('immutable raw copy digest does not match the source preview');
+        }
+        const receipt = {
+            schemaVersion: 'aiwg.compound-memory.intake-receipt.v1',
+            receiptId: sha256(`${operationId}\0${preview.rawLocator}`),
+            operationId,
+            sourceLocator: preview.source.locator,
+            sourceDigest: preview.source.digest,
+            rawLocator: preview.rawLocator,
+            route: preview.route,
+            duplicate: preview.duplicate,
+            registeredAt: new Date().toISOString(),
+        };
+        atomicJson(receiptPath, receipt);
+        return receipt;
+    }
+}
+//# sourceMappingURL=intake.js.map

package/dist/src/resources/resolver.js

@@ -117,6 +117,7 @@ export async function resolveAiwgResourceBytes(logicalId, options) {
     const bytes = await fetchVerifiedRawResource(webRelease, parsed.rawPath, {
         baseUrl: options.webReleaseOptions?.baseUrl,
         fetcher: options.webReleaseOptions?.fetcher,
+        credentialProvider: options.webReleaseOptions?.credentialProvider,
         allowInsecureLoopbackHttp: options.webReleaseOptions?.allowInsecureLoopbackHttp,
         offline: options.offline,
     });

package/dist/src/resources/web-release.d.ts

@@ -45,6 +45,8 @@ export interface WebReleaseOptions {
     cacheRoot?: string;
     publicKeyPem?: string | Buffer;
     fetcher?: ResourceFetcher;
+    /** Returns a bearer token at request time. Tokens never participate in URLs or cache keys. */
+    credentialProvider?: () => Promise<string | null>;
     /** Test/development escape hatch. HTTP remains restricted to loopback. */
     allowInsecureLoopbackHttp?: boolean;
 }
@@ -72,7 +74,7 @@ export interface VerifiedWebRelease {
     channelSequence?: number;
     descriptors: ReadonlyMap<string, VerifiedReleaseDescriptor>;
 }
-export interface VerifiedRawResourceOptions extends Pick<WebReleaseOptions, "baseUrl" | "fetcher" | "allowInsecureLoopbackHttp"> {
+export interface VerifiedRawResourceOptions extends Pick<WebReleaseOptions, "baseUrl" | "fetcher" | "credentialProvider" | "allowInsecureLoopbackHttp"> {
     offline?: boolean;
 }
 export declare function verifySignedResourceBytes(bytes: Uint8Array, signatureBytes: Uint8Array, publicKeyPem?: string | Buffer, label?: string): string;

package/dist/src/resources/web-release.js

@@ -297,7 +297,7 @@ function resourceUrl(base, relativePath) {
     url.pathname = `${prefix}/${relativePath}`;
     return url.toString();
 }
-async function fetchBytes(fetcher, url, label, maxBytes) {
+async function fetchBytes(fetcher, url, label, maxBytes, bearerToken) {
     if (!Number.isSafeInteger(maxBytes) || maxBytes < 0)
         throw new Error(`${label} has an invalid network size limit`);
     const controller = new AbortController();
@@ -315,7 +315,10 @@ async function fetchBytes(fetcher, url, label, maxBytes) {
         const response = await Promise.race([
             fetcher(url, {
                 redirect: "error",
-                headers: { "accept-encoding": "identity" },
+                headers: {
+                    "accept-encoding": "identity",
+                    ...(bearerToken ? { authorization: `Bearer ${bearerToken}` } : {}),
+                },
                 signal: controller.signal,
             }),
             timeoutFailure,
@@ -904,16 +907,21 @@ export async function resolveWebRelease(options = {}) {
     const base = normalizeBaseUrl(options.baseUrl ?? DEFAULT_RESOURCE_BASE_URL, options.allowInsecureLoopbackHttp === true);
     // Validate injected trust material before reading cache or making requests.
     loadTrustRoot(publicKeyPem);
+    const bearerToken = options.offline ? null : await options.credentialProvider?.() ?? null;
+    const authorize = async (input, init = {}) => {
+        const headers = { ...(init.headers || {}), ...(bearerToken ? { authorization: `Bearer ${bearerToken}` } : {}) };
+        return (options.fetcher ?? globalThis.fetch)(input, { ...init, headers });
+    };
     if (selector.kind === "exact") {
         if (options.offline)
             return resolveOfflineExact(cacheRoot, selector, selector.value, publicKeyPem, base);
-        const fetcher = options.fetcher ?? globalThis.fetch;
+        const fetcher = authorize;
         if (!fetcher)
             throw new Error("No fetch implementation is available for AIWG web resources");
         return fetchAndCacheRelease(base, fetcher, cacheRoot, selector, selector.value, publicKeyPem);
     }
     if (selector.kind === "range" || selector.kind === "digest") {
-        const fetcher = options.fetcher ?? globalThis.fetch;
+        const fetcher = authorize;
         const index = await resolveVersionIndex(base, fetcher, cacheRoot, publicKeyPem, options.offline);
         const selected = selectVersionFromIndex(index, selector);
         if (options.offline) {
@@ -929,7 +937,7 @@ export async function resolveWebRelease(options = {}) {
             throw new Error(`AIWG resource channel ${selector.value} is not cached; offline mode cannot fetch it`);
         return resolveOfflineExact(cacheRoot, selector, cached.manifest.version, publicKeyPem, base, cached.manifest.releaseManifestSha256, cached.manifest.sequence);
     }
-    const fetcher = options.fetcher ?? globalThis.fetch;
+    const fetcher = authorize;
     if (!fetcher)
         throw new Error("No fetch implementation is available for AIWG web resources");
     const channelPrefix = `resources/channels/${selector.value}`;
@@ -989,7 +997,7 @@ export async function fetchVerifiedRawResource(release, resourcePath, options =
     const fetcher = options.fetcher ?? globalThis.fetch;
     if (!fetcher)
         throw new Error("No fetch implementation is available for AIWG web resources");
-    const bytes = await fetchBytes(fetcher, resourceUrl(base, `resources/${release.version}/${resourcePath}`), `raw resource ${resourcePath}`, Math.min(descriptor.size, MAX_RAW_RESOURCE_BYTES));
+    const bytes = await fetchBytes(fetcher, resourceUrl(base, `resources/${release.version}/${resourcePath}`), `raw resource ${resourcePath}`, Math.min(descriptor.size, MAX_RAW_RESOURCE_BYTES), await options.credentialProvider?.() ?? null);
     verifyDescriptor(bytes, descriptor);
     const stagingRoot = path.join(release.cacheDir, ".raw-staging");
     fs.mkdirSync(stagingRoot, { recursive: true });

package/dist/src/serve/agentic-sandbox-fleet-client.js

@@ -0,0 +1,213 @@
+/**
+ * AIWG management-plane adapter for Agentic Sandbox's neutral fleet API.
+ * The adapter owns no runtime state: it dispatches contract records and
+ * converts durable Sandbox observations into FleetMissionConductor events.
+ *
+ * @implements #1991
+ */
+import { routeDispatch } from './dispatch-router.js';
+const terminal = new Set([
+    'retained', 'healthy', 'scheduled', 'succeeded', 'failed', 'cancelled', 'timed-out',
+    'unknown', 'operator-review-required',
+]);
+export class AgenticSandboxFleetClient {
+    baseUrl;
+    token;
+    fetchImpl;
+    executorFetch;
+    pollIntervalMs;
+    maxPolls;
+    defaultPolicy;
+    defaultBudgets;
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/+$/, '');
+        this.token = options.token;
+        this.fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
+        this.executorFetch = options.executorFetch ?? globalThis.fetch.bind(globalThis);
+        this.pollIntervalMs = options.pollIntervalMs ?? 250;
+        this.maxPolls = options.maxPolls ?? 120;
+        this.defaultPolicy = options.defaultPolicy ?? { trustTier: 'T2', isolationKind: 'vm' };
+        this.defaultBudgets = options.defaultBudgets ?? { maxAttempts: 1, timeoutSeconds: 3600 };
+    }
+    /** Directly assignable to FleetMissionConductor's `runWorker` option. */
+    runWorker = async (cycle, executor, invocation, lineage) => {
+        const record = this.workloadRecord(cycle, executor, lineage);
+        const admitted = await this.request('/api/v2/fleet/workloads', { method: 'POST', body: JSON.stringify(record) });
+        const events = [this.toEvent(admitted.workload)];
+        if (!admitted.workload.lineage.task_id) {
+            const dispatched = await routeDispatch(executor, {
+                mission_id: lineage.dispatchId,
+                objective: cycle.prompt,
+                long_running: cycle.longRunning ?? cycle.workloadKind !== 'one-shot-command',
+                fleet_workload_kind: cycle.workloadKind,
+                fleet_child_id: lineage.childId,
+                native_primitive: invocation.primitive,
+                ...(executor.a2aInstanceId ? { a2a_instance_id: executor.a2aInstanceId } : {}),
+            }, { fetch: this.executorFetch });
+            if (!dispatched.task?.id) {
+                throw new Error(`Agentic Sandbox dispatch for '${lineage.childId}' returned no durable task identity`);
+            }
+            const bound = await this.bindDispatchedTask(cycle, lineage.childId, admitted.workload.status, dispatched.task.id, this.taskObservedState(cycle, dispatched.task.status.state));
+            events.push(this.toEvent(bound));
+        }
+        for (let attempt = 0; attempt < this.maxPolls && !this.settled(cycle, events.at(-1)); attempt += 1) {
+            if (this.pollIntervalMs > 0) {
+                await new Promise((resolve) => setTimeout(resolve, this.pollIntervalMs));
+            }
+            const next = await this.request(`/api/v2/fleet/workloads/${encodeURIComponent(lineage.childId)}`);
+            const event = this.toEvent(next);
+            if (event.revision > events.at(-1).revision)
+                events.push(event);
+        }
+        const latest = events.at(-1);
+        return {
+            output: latest.artifacts?.find((artifact) => artifact.kind === 'result')?.uri,
+            commandId: latest.commandId,
+            sessionId: latest.sessionId,
+            events,
+        };
+    };
+    async bindDispatchedTask(cycle, childId, current, taskId, observedState) {
+        const status = {
+            observed_state: observedState,
+            revision: current.revision + 1,
+            last_seen: new Date().toISOString(),
+            artifacts: current.artifacts ?? [],
+            ...(cycle.workloadKind === 'daemon' ? { health: observedState === 'healthy' ? 'healthy' : 'unknown' } : {}),
+            ...(observedState === 'blocked' ? { backpressure: { reason: 'approval', retryable: false } } : {}),
+        };
+        return this.request(`/api/v2/fleet/workloads/${encodeURIComponent(childId)}/observations`, {
+            method: 'POST',
+            body: JSON.stringify({
+                expected_revision: current.revision,
+                runtime_identity: { task_id: taskId },
+                status,
+            }),
+        });
+    }
+    taskObservedState(cycle, taskState) {
+        switch (taskState) {
+            case 'submitted': return 'starting';
+            case 'working': return cycle.workloadKind === 'daemon' ? 'healthy' : 'running';
+            case 'input-required': return 'blocked';
+            case 'completed':
+                if (cycle.workloadKind === 'persistent-agent')
+                    return 'retained';
+                if (cycle.workloadKind === 'daemon')
+                    return 'healthy';
+                if (cycle.workloadKind === 'scheduled-collector')
+                    return 'scheduled';
+                return 'succeeded';
+            case 'failed': return 'failed';
+            case 'canceled':
+            case 'cancelled': return 'cancelled';
+            case 'rejected': return 'failed';
+            default: return 'unknown';
+        }
+    }
+    async inventory() {
+        return this.request('/api/v2/fleet/workloads');
+    }
+    async reconcile(beforeRevision, childIds) {
+        return this.request('/api/v2/fleet/reconcile', {
+            method: 'POST',
+            body: JSON.stringify({ before_revision: beforeRevision, child_ids: childIds }),
+        });
+    }
+    workloadRecord(cycle, executor, lineage) {
+        if (cycle.workloadKind === 'scheduled-collector' && !cycle.schedule) {
+            throw new Error(`scheduled collector '${cycle.id}' requires a schedule`);
+        }
+        const policy = cycle.policy ?? this.defaultPolicy;
+        const budgets = cycle.budgets ?? this.defaultBudgets;
+        const spec = {
+            desired_state: 'running',
+            capabilities: (cycle.requiredCapabilities ?? []).map((name) => ({ name, status: 'supported' })),
+            policy: {
+                trust_tier: policy.trustTier,
+                isolation_kind: policy.isolationKind,
+                ...(policy.credentialPolicyRef ? { credential_policy_ref: policy.credentialPolicyRef } : {}),
+                ...(policy.networkPolicyRef ? { network_policy_ref: policy.networkPolicyRef } : {}),
+            },
+            budgets: {
+                max_attempts: budgets.maxAttempts,
+                timeout_seconds: budgets.timeoutSeconds,
+                ...(budgets.maxCostUsd === undefined ? {} : { max_cost_usd: budgets.maxCostUsd }),
+            },
+            ...(cycle.schedule ? { schedule: cycle.schedule } : {}),
+            orchestrator_metadata: { executor_spec_version: executor.specVersion },
+        };
+        return {
+            document_type: 'workload',
+            api_version: 'agentic-orchestration/v1',
+            kind: cycle.workloadKind,
+            lineage: {
+                orchestrator_id: lineage.orchestratorId,
+                mission_id: lineage.missionId,
+                dispatch_id: lineage.dispatchId,
+                idempotency_key: lineage.idempotencyKey,
+                parent_id: lineage.parentId,
+                child_id: lineage.childId,
+                target_id: lineage.targetId,
+                executor_id: lineage.executorId,
+                runtime_id: lineage.runtimeId,
+                session_id: null,
+                task_id: null,
+                command_id: null,
+            },
+            spec,
+            status: {
+                observed_state: 'pending',
+                revision: 0,
+                last_seen: new Date().toISOString(),
+                ...(cycle.workloadKind === 'daemon' ? { health: 'unknown' } : {}),
+                artifacts: [],
+            },
+        };
+    }
+    settled(cycle, event) {
+        if (event.observedState === 'running' && cycle.workloadKind === 'persistent-agent')
+            return true;
+        if (event.observedState === 'running' && cycle.workloadKind === 'daemon' && event.health === 'healthy')
+            return true;
+        if (event.observedState === 'blocked')
+            return event.backpressure?.retryable !== true;
+        return terminal.has(event.observedState);
+    }
+    toEvent(record) {
+        const { status, lineage } = record;
+        return {
+            revision: status.revision,
+            observedState: status.observed_state,
+            lastSeen: status.last_seen,
+            sessionId: lineage.session_id ?? undefined,
+            taskId: lineage.task_id ?? undefined,
+            commandId: lineage.command_id ?? undefined,
+            health: status.health,
+            backpressure: status.backpressure ? {
+                reason: status.backpressure.reason,
+                retryable: status.backpressure.retryable,
+                retryAfter: status.backpressure.retry_after,
+            } : undefined,
+            artifacts: status.artifacts,
+            errorCode: status.error_code,
+        };
+    }
+    async request(path, init = {}) {
+        const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+            ...init,
+            headers: {
+                accept: 'application/json',
+                authorization: `Bearer ${this.token}`,
+                ...(init.body ? { 'content-type': 'application/json' } : {}),
+                ...init.headers,
+            },
+        });
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`Agentic Sandbox fleet API ${response.status}: ${body.slice(0, 512)}`);
+        }
+        return response.json();
+    }
+}
+//# sourceMappingURL=agentic-sandbox-fleet-client.js.map