@aiwg/cli 2026.8.0 → 2026.8.1

package/agentic/code/providers/model-catalog.v1.json

@@ -0,0 +1,96 @@
+{
+  "$schema": "../../../schemas/models/model-catalog.v1.schema.json",
+  "version": "1.0.0",
+  "refreshedAt": "2026-07-20",
+  "staleAfterDays": 90,
+  "providers": {
+    "claude": {
+      "roles": {
+        "reasoning": { "id": "claude-opus-4-7", "status": "active", "observed": false },
+        "coding": { "id": "claude-sonnet-4-6", "status": "active", "observed": false },
+        "efficiency": { "id": "claude-haiku-4-5", "status": "active", "observed": false }
+      },
+      "sourceUrl": "https://docs.anthropic.com/en/docs/about-claude/models/overview", "verifiedAt": "2026-07-20"
+    },
+    "codex": {
+      "roles": {
+        "reasoning": { "id": "gpt-5.4", "status": "active", "observed": true },
+        "coding": { "id": "gpt-5.5", "status": "active", "observed": true },
+        "efficiency": { "id": "gpt-5.4-mini", "status": "active", "observed": true }
+      },
+      "sourceUrl": "https://learn.chatgpt.com/docs/agent-configuration/subagents", "verifiedAt": "2026-07-20"
+    },
+    "copilot": {
+      "roles": {
+        "reasoning": { "id": "claude-opus-4.6", "status": "unverified", "observed": false },
+        "coding": { "id": "claude-sonnet-4.6", "status": "unverified", "observed": false },
+        "efficiency": { "id": "gpt-5.1-codex-mini", "status": "unverified", "observed": false }
+      },
+      "sourceUrl": "https://docs.github.com/en/copilot/reference/ai-models/supported-models", "verifiedAt": "2026-07-20"
+    },
+    "cursor": {
+      "roles": {
+        "reasoning": { "id": "claude-4.6-opus-high-thinking", "status": "unverified", "observed": false },
+        "coding": { "id": "claude-4.6-sonnet", "status": "unverified", "observed": false },
+        "efficiency": { "id": "auto", "status": "unverified", "observed": false }
+      },
+      "sourceUrl": "https://cursor.com/docs/models", "verifiedAt": "2026-07-20"
+    },
+    "factory": {
+      "roles": {
+        "reasoning": { "id": "heavy", "status": "active", "observed": false },
+        "coding": { "id": "medium", "status": "active", "observed": false },
+        "efficiency": { "id": "light", "status": "active", "observed": false }
+      },
+      "sourceUrl": "https://docs.factory.ai/cli/user-guides/choosing-your-model", "verifiedAt": "2026-07-20"
+    },
+    "opencode": {
+      "roles": {
+        "reasoning": { "id": "anthropic/claude-opus-4-7", "status": "unverified", "observed": false },
+        "coding": { "id": "anthropic/claude-sonnet-4-6", "status": "unverified", "observed": false },
+        "efficiency": { "id": "anthropic/claude-haiku-4-5", "status": "unverified", "observed": false }
+      },
+      "sourceUrl": "https://opencode.ai/docs/models", "verifiedAt": "2026-07-20"
+    },
+    "warp": {
+      "roles": {
+        "reasoning": { "id": "profile-selected", "status": "unverified", "observed": false },
+        "coding": { "id": "profile-selected", "status": "unverified", "observed": false },
+        "efficiency": { "id": "profile-selected", "status": "unverified", "observed": false }
+      },
+      "sourceUrl": "https://docs.warp.dev/agent-platform/capabilities/agent-profiles-permissions", "verifiedAt": "2026-07-20"
+    },
+    "windsurf": {
+      "roles": {
+        "reasoning": { "id": "inherited", "status": "unverified", "observed": false },
+        "coding": { "id": "inherited", "status": "unverified", "observed": false },
+        "efficiency": { "id": "inherited", "status": "unverified", "observed": false }
+      },
+      "sourceUrl": "https://docs.devin.ai/desktop/cascade/models", "verifiedAt": "2026-07-20"
+    },
+    "openclaw": {
+      "roles": {
+        "reasoning": { "id": "configured/reasoning", "status": "unverified", "observed": false },
+        "coding": { "id": "configured/coding", "status": "unverified", "observed": false },
+        "efficiency": { "id": "configured/efficiency", "status": "unverified", "observed": false }
+      },
+      "sourceUrl": "https://docs.openclaw.ai/tools/subagents", "verifiedAt": "2026-07-20"
+    },
+    "hermes": {
+      "roles": {
+        "reasoning": { "id": "global-delegation-model", "status": "unverified", "observed": false },
+        "coding": { "id": "global-delegation-model", "status": "unverified", "observed": false },
+        "efficiency": { "id": "global-delegation-model", "status": "unverified", "observed": false }
+      },
+      "sourceUrl": "https://hermes-agent.nousresearch.com/docs/user-guide/features/delegation", "verifiedAt": "2026-07-20"
+    },
+    "openhuman": {
+      "roles": {
+        "reasoning": { "id": "Hint(reasoning)", "status": "active", "observed": false },
+        "coding": { "id": "Hint(coding)", "status": "active", "observed": false },
+        "efficiency": { "id": "Hint(efficiency)", "status": "active", "observed": false }
+      },
+      "sourceUrl": "https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/agent/harness/definition.rs", "verifiedAt": "2026-07-20"
+    }
+  }
+}

package/agentic/code/providers/model-policy-evaluations.v1.json

@@ -0,0 +1,50 @@
+{
+  "version": "1.0.0",
+  "evaluatedAt": "2026-07-20",
+  "method": "Deterministic representative-fixture rubric: required instructions, bounded scope, tool contract, output contract, and risk controls are scored from canonical artifacts. Provider live resolution is tracked separately by #1807.",
+  "threshold": 0.8,
+  "cases": [
+    {
+      "tier": "economy",
+      "kind": "agent",
+      "artifact": "technical-writer",
+      "checks": ["instructions", "bounded-scope", "tool-contract", "output-contract"],
+      "score": 1
+    },
+    {
+      "tier": "economy",
+      "kind": "skill",
+      "artifact": "radar-status",
+      "checks": ["instructions", "bounded-scope", "tool-contract", "output-contract"],
+      "score": 1
+    },
+    {
+      "tier": "standard",
+      "kind": "agent",
+      "artifact": "software-implementer",
+      "checks": ["instructions", "multi-step-work", "tool-contract", "verification"],
+      "score": 1
+    },
+    {
+      "tier": "standard",
+      "kind": "skill",
+      "artifact": "uat-execute",
+      "checks": ["instructions", "multi-step-work", "tool-contract", "verification"],
+      "score": 1
+    },
+    {
+      "tier": "premium",
+      "kind": "agent",
+      "artifact": "security-architect",
+      "checks": ["instructions", "risk-controls", "tool-contract", "decision-rationale"],
+      "score": 1
+    },
+    {
+      "tier": "premium",
+      "kind": "skill",
+      "artifact": "security-gate",
+      "checks": ["instructions", "risk-controls", "tool-contract", "decision-rationale"],
+      "score": 1
+    }
+  ]
+}

package/agentic/code/providers/premium-model-allowlist.v1.json

@@ -0,0 +1,36 @@
+{
+  "version": "1.0.0",
+  "reviewedAt": "2026-07-20",
+  "exemptions": {
+    "agents": {
+      "factory-compat": "Compatibility documentation is not a deployable agent definition and has no YAML frontmatter.",
+      "openai-compat": "Compatibility documentation is not a deployable agent definition and has no YAML frontmatter.",
+      "windsurf-compat": "Compatibility documentation is not a deployable agent definition and has no YAML frontmatter."
+    },
+    "skills": {}
+  },
+  "agents": {
+    "architecture-designer": "Cross-system architecture tradeoffs have a high downstream rework cost.",
+    "aiwg-model-reasoning-worker": "Cross-domain architecture and synthesis assignments have high downstream rework cost.",
+    "cloud-architect": "Infrastructure topology decisions carry material reliability and security risk.",
+    "forensics-orchestrator": "Evidence-preserving investigation plans require high-confidence sequencing.",
+    "incident-responder": "Active incident containment decisions can cause irreversible operational impact.",
+    "legal-liaison": "Legal and regulatory interpretation has material compliance consequences.",
+    "legal-reviewer": "Legal approval findings can block release and require high-confidence review.",
+    "security-architect": "System threat boundaries and trust decisions are security-critical.",
+    "security-auditor": "Vulnerability findings and exploitability judgments are security-critical.",
+    "security-gatekeeper": "Release security gate decisions require high-confidence risk assessment.",
+    "vision-owner": "Product-direction decisions coordinate multiple downstream delivery tracks."
+  },
+  "skills": {
+    "best-practices-audit": "External evidence synthesis can change high-impact technical policy.",
+    "crisis-response": "Public crisis decisions carry material legal and reputational risk.",
+    "flow-deploy-to-production": "Production release and rollback decisions have high operational impact.",
+    "flow-incident-response": "Incident orchestration must preserve containment and evidence integrity.",
+    "legal-compliance": "Legal and regulatory compliance conclusions require high confidence.",
+    "physical-threat-modeling": "Physical safety and asset protection decisions are high impact.",
+    "security-assessment": "Security posture findings influence remediation and release decisions.",
+    "security-audit": "Security audit conclusions require high-confidence vulnerability analysis.",
+    "security-gate": "The skill makes a release-blocking security decision."
+  }
+}

package/bin/aiwg.mjs

@@ -21,7 +21,7 @@
  * @implements #919
  */
 
-import { fileURLToPath } from 'url';
+import { fileURLToPath, pathToFileURL } from 'url';
 import path from 'path';
 import { existsSync, readFileSync } from 'fs';
 import os from 'os';
@@ -186,7 +186,7 @@ async function resolveRouterPath() {
  * argv — handlers still see the flags. Call before the router loads so the
  * logger picks up the right level when it initializes.
  */
-async function applyVerbosityFromArgs(args) {
+async function applyVerbosityFromArgs(args, routerPath) {
   let level = 'warn'; // default
   if (args.includes('--quiet') || args.includes('-q')) level = 'error';
   else if (args.includes('-vvv')) { level = 'debug'; process.env['AIWG_DEBUG'] ??= '1'; }
@@ -201,10 +201,9 @@ async function applyVerbosityFromArgs(args) {
   // and set the level. Failing to import the logger here is non-fatal — the
   // logger's own fallbacks will pick up AIWG_LOG_LEVEL from env.
   try {
-    const routerPath = await resolveRouterPath();
     const logPath = path.join(path.dirname(routerPath), 'log.js');
     if (existsSync(logPath)) {
-      const { setLogLevel, setInvocationId, pruneOldLogs } = await import('file://' + logPath);
+      const { setLogLevel, setInvocationId, pruneOldLogs } = await import(pathToFileURL(logPath).href);
       setLogLevel(level);
       setInvocationId(invocationId);
       // One-shot prune of old JSONL files on startup. Bounded work; safe to
@@ -240,18 +239,24 @@ async function main() {
     return;
   }
 
+  // Resolve the active router once. In dev mode this points into the checkout,
+  // while packageRoot still points at the globally installed launcher.
+  const routerPath = await resolveRouterPath();
+  const activePackageRoot = path.resolve(path.dirname(routerPath), '..', '..', '..');
+
   // Wire up the logger level from -v/-vv/--quiet/AIWG_LOG_LEVEL before any
   // handler runs, and stamp the top-level invocation ID so the logger can
   // tag every record with it.
-  await applyVerbosityFromArgs(args);
+  await applyVerbosityFromArgs(args, routerPath);
 
   // Update notifier: print any pending notice from the previous run's
   // background check, then schedule the next background check. Both are
   // non-blocking — the current command never waits on the network.
   // Honors NO_UPDATE_NOTIFIER, CI=*, and non-TTY stderr.
-  const { scheduleBackgroundCheck, maybePrintNotice } = await import('../dist/src/update/notifier.mjs');
-  maybePrintNotice();
-  scheduleBackgroundCheck(packageRoot);
+  const notifierPath = path.join(activePackageRoot, 'dist', 'src', 'update', 'notifier.mjs');
+  const { scheduleBackgroundCheck, maybePrintNotice } = await import(pathToFileURL(notifierPath).href);
+  maybePrintNotice(activePackageRoot);
+  scheduleBackgroundCheck(activePackageRoot);
 
   // Top-level cancellation controller. SIGINT / SIGTERM flip it, long-running
   // handlers plumb ctx.signal through fetches and loops so Ctrl-C cancels
@@ -276,9 +281,8 @@ async function main() {
 
   // Direct in-process dispatch — no tsx fork, no facade, no router-loader.
   trace('resolve:router');
-  const routerPath = await resolveRouterPath();
   trace('import:router');
-  const { run } = await import('file://' + routerPath);
+  const { run } = await import(pathToFileURL(routerPath).href);
   trace('dispatch:begin');
   try {
     await run(args, { cwd: process.cwd(), signal: abortController.signal });

package/dist/src/api/index.d.ts

@@ -8,5 +8,6 @@
 export { run } from '../cli/router.js';
 export * from '../resources/index.js';
 export * from '../sessions/index.js';
+export * from '../memory/index.js';
 export * from '../security/threat-assessment-config.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/api/index.js

@@ -8,5 +8,6 @@
 export { run } from '../cli/router.js';
 export * from '../resources/index.js';
 export * from '../sessions/index.js';
+export * from '../memory/index.js';
 export * from '../security/threat-assessment-config.js';
 //# sourceMappingURL=index.js.map

package/dist/src/artifacts/cli.js

@@ -23,6 +23,7 @@ import { GRAPH_CONFIGS, OPERATIONAL_DISCOVERY_TYPES, OPERATIONAL_SHOW_TYPES, isO
 import { SUPPORTED_VIEWS } from './corpus-views/renderers.js';
 import { parseResourceSelector, readVerifiedRegularFile, } from '../resources/web-release.js';
 import { findPackageRoot } from '../cli/find-package-root.js';
+import { createResourceCredentialProvider } from '../auth/resource-credentials.js';
 const MAX_RESOURCE_TRUST_ROOT_BYTES = 64 * 1024;
 function webReleaseOptionsFromEnvironment() {
     const baseUrl = process.env.AIWG_RESOURCE_BASE_URL;
@@ -42,6 +43,7 @@ function webReleaseOptionsFromEnvironment() {
         }
     }
     return {
+        credentialProvider: createResourceCredentialProvider(process.env),
         ...(baseUrl === undefined ? {} : { baseUrl }),
         ...(cacheRoot === undefined ? {} : { cacheRoot }),
         ...(publicKeyPem === undefined ? {} : { publicKeyPem }),

package/dist/src/artifacts/types.js

@@ -178,6 +178,10 @@ export const BUILTIN_GRAPH_CONFIGS = {
             '~/.aiwg/flows',
             '~/.aiwg/runbooks',
             '~/.aiwg/frameworks',
+            '~/.aiwg/addons',
+            '~/.aiwg/extensions',
+            '~/.aiwg/plugins',
+            '~/.aiwg/providers',
         ],
         extensions: [...DEFAULT_INDEX_EXTENSIONS],
         shared: true,

package/dist/src/auth/client.js

@@ -0,0 +1,209 @@
+import { createHash, randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { spawn } from "node:child_process";
+const random = (bytes = 32) => randomBytes(bytes).toString("base64url");
+export const createPkceChallenge = (verifier) => createHash("sha256").update(verifier).digest("base64url");
+async function responseJson(response) {
+    const value = await response.json().catch(() => ({}));
+    return value && typeof value === "object" ? value : {};
+}
+function oauthError(value, fallback) {
+    return new Error(typeof value.error === "string" ? value.error : fallback);
+}
+function toCredentials(value, now = new Date()) {
+    if (typeof value.access_token !== "string" || typeof value.refresh_token !== "string"
+        || value.token_type !== "Bearer" || !Number.isSafeInteger(value.expires_in))
+        throw new Error("authorization server returned an invalid token response");
+    return {
+        accessToken: value.access_token,
+        refreshToken: value.refresh_token,
+        tokenType: "Bearer",
+        scope: String(value.scope || "").split(/\s+/).filter(Boolean),
+        expiresAt: new Date(now.getTime() + Number(value.expires_in) * 1000).toISOString(),
+    };
+}
+export const defaultBrowserOpener = async (url) => {
+    const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd.exe" : "xdg-open";
+    const args = process.platform === "win32" ? ["/d", "/s", "/c", "start", "", url] : [url];
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, args, { detached: true, stdio: "ignore", windowsHide: true });
+        child.once("error", reject);
+        child.once("spawn", () => { child.unref(); resolve(); });
+    });
+};
+function wait(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted)
+            return reject(new Error("authentication canceled"));
+        const timer = setTimeout(resolve, ms);
+        const abort = () => { clearTimeout(timer); reject(new Error("authentication canceled")); };
+        signal?.addEventListener("abort", abort, { once: true });
+    });
+}
+export class AuthClient {
+    config;
+    store;
+    fetcher;
+    openBrowser;
+    now;
+    sleep;
+    constructor(config, store, fetcher = globalThis.fetch, openBrowser = defaultBrowserOpener, now = () => new Date(), sleep = wait) {
+        this.config = config;
+        this.store = store;
+        this.fetcher = fetcher;
+        this.openBrowser = openBrowser;
+        this.now = now;
+        this.sleep = sleep;
+    }
+    async request(pathname, init) {
+        const signal = init.signal || AbortSignal.timeout(this.config.requestTimeoutMs);
+        return this.fetcher(`${this.config.baseUrl}${pathname}`, { ...init, signal, redirect: "error" });
+    }
+    async loginBrowser(options = {}) {
+        const verifier = random(48);
+        const state = random();
+        let server;
+        const callback = new Promise((resolve, reject) => {
+            server = createServer((request, response) => {
+                try {
+                    const url = new URL(request.url || "/", "http://127.0.0.1");
+                    if (url.pathname !== "/callback" || !url.searchParams.get("code") || !url.searchParams.get("state")) {
+                        response.writeHead(400, { "content-type": "text/plain", "cache-control": "no-store" });
+                        response.end("Invalid authorization callback");
+                        return;
+                    }
+                    response.writeHead(200, { "content-type": "text/plain", "cache-control": "no-store" });
+                    response.end("AIWG authorization complete. You may close this window.");
+                    resolve({ code: url.searchParams.get("code"), state: url.searchParams.get("state") });
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+            server.once("error", reject);
+            server.listen(0, "127.0.0.1");
+        });
+        try {
+            const callbackServer = server;
+            if (!callbackServer)
+                throw new Error("loopback callback server was not created");
+            await new Promise((resolve, reject) => { callbackServer.once("listening", resolve); callbackServer.once("error", reject); });
+            const address = callbackServer.address();
+            if (!address || typeof address === "string")
+                throw new Error("loopback callback did not bind a random port");
+            const redirectUri = `http://127.0.0.1:${address.port}/callback`;
+            const authorize = new URL(`${this.config.baseUrl}/oauth/authorize`);
+            authorize.search = new URLSearchParams({
+                client_id: this.config.clientId,
+                redirect_uri: redirectUri,
+                response_type: "code",
+                code_challenge: createPkceChallenge(verifier),
+                code_challenge_method: "S256",
+                state,
+                scope: this.config.scopes.join(" "),
+                ...(options.deviceLabel ? { device_label: options.deviceLabel } : {}),
+            }).toString();
+            await this.openBrowser(authorize.toString());
+            const result = await Promise.race([
+                callback,
+                new Promise((_, reject) => options.signal?.addEventListener("abort", () => reject(new Error("authentication canceled")), { once: true })),
+            ]);
+            if (result.state !== state)
+                throw new Error("OAuth state mismatch");
+            const response = await this.request("/oauth/token", {
+                method: "POST",
+                headers: { "content-type": "application/x-www-form-urlencoded" },
+                body: new URLSearchParams({ grant_type: "authorization_code", code: result.code, code_verifier: verifier, client_id: this.config.clientId, redirect_uri: redirectUri }),
+                signal: options.signal,
+            });
+            const value = await responseJson(response);
+            if (!response.ok)
+                throw oauthError(value, "authorization code exchange failed");
+            const credentials = toCredentials(value, this.now());
+            await this.store.save(credentials);
+            return credentials;
+        }
+        finally {
+            server?.closeAllConnections();
+            server?.close();
+        }
+    }
+    async loginDevice(options = {}) {
+        const start = await this.request("/v1/auth/device/authorization", {
+            method: "POST", headers: { "content-type": "application/json" }, signal: options.signal,
+            body: JSON.stringify({ client_id: this.config.clientId, scope: this.config.scopes.join(" "), device_label: options.deviceLabel }),
+        });
+        const value = await responseJson(start);
+        if (!start.ok || typeof value.device_code !== "string" || typeof value.expires_in !== "number" || typeof value.interval !== "number") {
+            throw oauthError(value, "device authorization failed");
+        }
+        options.onCode?.(value);
+        const deadline = this.now().getTime() + value.expires_in * 1000;
+        let interval = value.interval;
+        while (this.now().getTime() < deadline) {
+            await this.sleep(interval * 1000, options.signal);
+            if (this.now().getTime() >= deadline)
+                break;
+            const response = await this.request("/oauth/token", {
+                method: "POST", headers: { "content-type": "application/x-www-form-urlencoded" }, signal: options.signal,
+                body: new URLSearchParams({ grant_type: "urn:ietf:params:oauth:grant-type:device_code", device_code: value.device_code, client_id: this.config.clientId }),
+            });
+            const token = await responseJson(response);
+            if (response.ok) {
+                const credentials = toCredentials(token, this.now());
+                await this.store.save(credentials);
+                return credentials;
+            }
+            if (token.error === "authorization_pending")
+                continue;
+            if (token.error === "slow_down") {
+                interval += 5;
+                continue;
+            }
+            throw oauthError(token, "device authorization failed");
+        }
+        throw new Error("expired_token");
+    }
+    async refresh(credentials, signal) {
+        const response = await this.request("/oauth/token", {
+            method: "POST", headers: { "content-type": "application/x-www-form-urlencoded" }, signal,
+            body: new URLSearchParams({ grant_type: "refresh_token", refresh_token: credentials.refreshToken, client_id: this.config.clientId }),
+        });
+        const value = await responseJson(response);
+        if (!response.ok)
+            throw oauthError(value, "refresh failed");
+        const updated = toCredentials(value, this.now());
+        await this.store.save(updated);
+        return updated;
+    }
+    async status(signal) {
+        let credentials = await this.store.load();
+        if (!credentials)
+            throw new Error("not_authenticated");
+        if (Date.parse(credentials.expiresAt) <= this.now().getTime() + 30_000)
+            credentials = await this.refresh(credentials, signal);
+        let response = await this.request("/v1/me", { headers: { authorization: `Bearer ${credentials.accessToken}` }, signal });
+        if (response.status === 401) {
+            credentials = await this.refresh(credentials, signal);
+            response = await this.request("/v1/me", { headers: { authorization: `Bearer ${credentials.accessToken}` }, signal });
+        }
+        const value = await responseJson(response);
+        if (!response.ok || typeof value.sub !== "string")
+            throw oauthError(value, "status request failed");
+        return { profile: value, credentials };
+    }
+    async logout(signal) {
+        const credentials = await this.store.load();
+        try {
+            if (credentials)
+                await this.request("/oauth/revoke", {
+                    method: "POST", headers: { "content-type": "application/x-www-form-urlencoded" }, signal,
+                    body: new URLSearchParams({ token: credentials.refreshToken, token_type_hint: "refresh_token" }),
+                });
+        }
+        finally {
+            await this.store.delete();
+        }
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/src/auth/config.js

@@ -0,0 +1,38 @@
+import fs from "node:fs";
+import path from "node:path";
+export const DEFAULT_AUTH_BASE_URL = "https://releases.aiwg.io";
+export const DEFAULT_AUTH_CLIENT_ID = "aiwg-cli";
+export const DEFAULT_AUTH_SCOPES = ["releases:read", "profile:read"];
+function cleanOrigin(value, allowLoopbackHttp = false) {
+    const url = new URL(value);
+    const loopback = ["127.0.0.1", "[::1]", "::1", "localhost"].includes(url.hostname);
+    if (url.protocol !== "https:" && !(allowLoopbackHttp && loopback && url.protocol === "http:")) {
+        throw new Error("AIWG authentication requires HTTPS; HTTP is allowed only for explicitly enabled loopback tests");
+    }
+    if (url.username || url.password || url.search || url.hash)
+        throw new Error("AIWG authentication URL must be a clean origin");
+    url.pathname = url.pathname.replace(/\/+$/, "");
+    return url.toString().replace(/\/$/, "");
+}
+export function authConfigFromEnvironment(env = process.env) {
+    const baseUrl = cleanOrigin(env.AIWG_AUTH_BASE_URL || DEFAULT_AUTH_BASE_URL, env.AIWG_AUTH_ALLOW_INSECURE_LOOPBACK_HTTP === "1");
+    const clientId = env.AIWG_AUTH_CLIENT_ID || DEFAULT_AUTH_CLIENT_ID;
+    if (!/^[a-z0-9][a-z0-9._-]{1,63}$/.test(clientId))
+        throw new Error("AIWG auth client ID is invalid");
+    const scopes = (env.AIWG_AUTH_SCOPES || DEFAULT_AUTH_SCOPES.join(" ")).split(/\s+/).filter(Boolean);
+    if (!scopes.length || scopes.some((scope) => !/^[a-z][a-z0-9._:-]{1,63}$/.test(scope)))
+        throw new Error("AIWG auth scopes are invalid");
+    return { baseUrl, clientId, scopes, requestTimeoutMs: 30_000 };
+}
+export function explicitResourceToken(env = process.env) {
+    if (env.AIWG_RESOURCE_TOKEN_FILE) {
+        const pathname = path.resolve(env.AIWG_RESOURCE_TOKEN_FILE);
+        const stat = fs.lstatSync(pathname);
+        if (!stat.isFile() || stat.isSymbolicLink() || (stat.mode & 0o077) !== 0) {
+            throw new Error("AIWG_RESOURCE_TOKEN_FILE must be a non-symlink regular file with mode 0600");
+        }
+        return fs.readFileSync(pathname, "utf8").trim() || null;
+    }
+    return env.AIWG_RESOURCE_TOKEN?.trim() || null;
+}
+//# sourceMappingURL=config.js.map