@envarai/envarpay 0.2.0-alpha.8 → 2026.1025.1

package/dist/commerce/external-oauth.js

@@ -0,0 +1,230 @@
+/** Single-user OAuth pairing for an owner-operated external Agent. PKCE, exact redirects and audience. */
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+import { DatabaseSync } from "node:sqlite";
+import { chmodSync } from "node:fs";
+import { CommerceError } from "./types.js";
+const hash = (s) => createHash("sha256").update(s).digest("hex");
+const escape = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+const random = () => randomBytes(32).toString("base64url");
+export class ExternalAgentOAuth {
+    origin;
+    principal;
+    pairingKey;
+    db;
+    constructor(path, origin, principal, pairingKey) {
+        this.origin = origin;
+        this.principal = principal;
+        this.pairingKey = pairingKey;
+        this.db = new DatabaseSync(path);
+        chmodSync(path, 0o600);
+        this.db.exec("PRAGMA synchronous=FULL;CREATE TABLE IF NOT EXISTS clients(id TEXT PRIMARY KEY,redirects TEXT NOT NULL);CREATE TABLE IF NOT EXISTS consent(id TEXT PRIMARY KEY,request_json TEXT NOT NULL,expires INTEGER NOT NULL);CREATE TABLE IF NOT EXISTS codes(hash TEXT PRIMARY KEY,request_json TEXT NOT NULL,expires INTEGER NOT NULL);CREATE TABLE IF NOT EXISTS tokens(hash TEXT PRIMARY KEY,principal TEXT NOT NULL,expires INTEGER NOT NULL)");
+        if (pairingKey.length < 32)
+            throw new CommerceError("pairing_key", "Use an owner-only pairing key");
+    }
+    challenge() {
+        return ('Bearer resource_metadata="' +
+            this.origin +
+            '/.well-known/oauth-protected-resource/mcp", scope="envar:tasks"');
+    }
+    authenticate(request) {
+        const token = request.headers.get("Authorization")?.replace(/^Bearer /, "") ?? "";
+        const row = this.db
+            .prepare("SELECT principal,expires FROM tokens WHERE hash=?")
+            .get(hash(token));
+        return row && Number(row.expires) > Date.now()
+            ? String(row.principal)
+            : null;
+    }
+    validRedirect(value) {
+        const u = new URL(value);
+        if (u.protocol !== "https:" || u.username || u.password || u.hash)
+            throw new CommerceError("oauth_redirect", "Use an exact registered HTTPS callback");
+        return u.href;
+    }
+    async handle(request) {
+        const url = new URL(request.url), path = url.pathname;
+        const json = (v, status = 200) => Response.json(v, { status, headers: { "Cache-Control": "no-store" } });
+        if (path.startsWith("/.well-known/oauth-protected-resource"))
+            return json({
+                resource: this.origin + "/mcp",
+                authorization_servers: [this.origin],
+                scopes_supported: ["envar:tasks"],
+                bearer_methods_supported: ["header"],
+            });
+        if (path.startsWith("/.well-known/oauth-authorization-server") ||
+            path.startsWith("/.well-known/openid-configuration"))
+            return json({
+                issuer: this.origin,
+                authorization_endpoint: this.origin + "/authorize",
+                token_endpoint: this.origin + "/token",
+                registration_endpoint: this.origin + "/register",
+                response_types_supported: ["code"],
+                grant_types_supported: ["authorization_code"],
+                code_challenge_methods_supported: ["S256"],
+                token_endpoint_auth_methods_supported: ["none"],
+                scopes_supported: ["envar:tasks"],
+            });
+        if (!["/register", "/authorize", "/token"].includes(path))
+            return undefined;
+        try {
+            if (path === "/register" && request.method === "POST") {
+                const text = await request.text();
+                if (Buffer.byteLength(text) > 8192)
+                    throw Error();
+                const v = JSON.parse(text);
+                if (!Array.isArray(v.redirect_uris) ||
+                    !v.redirect_uris.length ||
+                    v.redirect_uris.length > 5 ||
+                    (v.token_endpoint_auth_method &&
+                        v.token_endpoint_auth_method !== "none"))
+                    throw Error();
+                const redirects = v.redirect_uris.map((u) => this.validRedirect(u)), id = "client_" + random();
+                this.db
+                    .prepare("INSERT INTO clients VALUES (?,?)")
+                    .run(id, JSON.stringify(redirects));
+                return json({
+                    client_id: id,
+                    redirect_uris: redirects,
+                    token_endpoint_auth_method: "none",
+                    grant_types: ["authorization_code"],
+                    response_types: ["code"],
+                }, 201);
+            }
+            if (path === "/authorize" && request.method === "GET") {
+                const v = Object.fromEntries(url.searchParams), client = this.db
+                    .prepare("SELECT redirects FROM clients WHERE id=?")
+                    .get(v.client_id ?? "");
+                if (!client ||
+                    !JSON.parse(String(client.redirects)).includes(v.redirect_uri) ||
+                    v.response_type !== "code" ||
+                    v.code_challenge_method !== "S256" ||
+                    !v.code_challenge ||
+                    !/^[A-Za-z0-9_-]{43}$/.test(v.code_challenge) ||
+                    (v.scope && v.scope !== "envar:tasks") ||
+                    (v.resource && v.resource !== this.origin + "/mcp"))
+                    throw Error();
+                const id = random();
+                this.db
+                    .prepare("INSERT INTO consent VALUES (?,?,?)")
+                    .run(id, JSON.stringify(v), Date.now() + 600000);
+                const body = '<!doctype html><meta name="viewport" content="width=device-width"><title>Connect Germey to Envar</title><main style="font:18px/1.6 system-ui;max-width:600px;margin:60px auto"><h1>Connect this external Agent</h1><p>Scope: claim and return bounded free text tasks for <b>' +
+                    escape(this.principal) +
+                    '</b>.</p><p>No payment, wallet, other Agent, or unrelated account access.</p><form method="post" action="/authorize"><input type="hidden" name="consent" value="' +
+                    id +
+                    '"><label>Owner pairing key <input type="password" name="pairing_key" required autocomplete="off"></label><p><button>Allow this task connection</button></p></form></main>';
+                return new Response(body, {
+                    headers: {
+                        "Content-Type": "text/html",
+                        "Cache-Control": "no-store",
+                        "Set-Cookie": "envar_pair_csrf=" +
+                            id +
+                            "; Secure; HttpOnly; SameSite=Strict; Path=/authorize; Max-Age=600",
+                        "Content-Security-Policy": "default-src 'none'; style-src 'unsafe-inline'; form-action 'self' " +
+                            new URL(v.redirect_uri).origin +
+                            new URL(v.redirect_uri).pathname +
+                            "; frame-ancestors 'none'",
+                    },
+                });
+            }
+            if (path === "/authorize" && request.method === "POST") {
+                if (request.headers.get("Origin") !== this.origin)
+                    throw Error();
+                const text = await request.text();
+                if (Buffer.byteLength(text) > 4096)
+                    throw Error();
+                const form = new URLSearchParams(text), id = form.get("consent") ?? "", cookie = request.headers.get("Cookie") ?? "";
+                if (!cookie.split(";").some((c) => c.trim() === "envar_pair_csrf=" + id))
+                    throw Error();
+                const provided = form.get("pairing_key") ?? "";
+                if (provided.length !== this.pairingKey.length ||
+                    !timingSafeEqual(Buffer.from(provided), Buffer.from(this.pairingKey)))
+                    throw Error();
+                const row = this.db
+                    .prepare("SELECT request_json,expires FROM consent WHERE id=?")
+                    .get(id);
+                if (!row || Number(row.expires) < Date.now())
+                    throw Error();
+                const v = JSON.parse(String(row.request_json)), code = random();
+                this.db.exec("BEGIN IMMEDIATE");
+                try {
+                    this.db.prepare("DELETE FROM consent WHERE id=?").run(id);
+                    this.db
+                        .prepare("INSERT INTO codes VALUES (?,?,?)")
+                        .run(hash(code), JSON.stringify(v), Date.now() + 120000);
+                    this.db.exec("COMMIT");
+                }
+                catch (e) {
+                    this.db.exec("ROLLBACK");
+                    throw e;
+                }
+                const callback = new URL(v.redirect_uri);
+                callback.searchParams.set("code", code);
+                if (v.state)
+                    callback.searchParams.set("state", v.state);
+                return new Response(null, {
+                    status: 302,
+                    headers: {
+                        Location: callback.href,
+                        "Cache-Control": "no-store",
+                        "Set-Cookie": "envar_pair_csrf=; Secure; HttpOnly; SameSite=Strict; Path=/authorize; Max-Age=0",
+                    },
+                });
+            }
+            if (path === "/token" && request.method === "POST") {
+                const text = await request.text();
+                if (Buffer.byteLength(text) > 8192)
+                    throw Error();
+                const v = request.headers
+                    .get("Content-Type")
+                    ?.includes("application/json")
+                    ? JSON.parse(text)
+                    : Object.fromEntries(new URLSearchParams(text));
+                if (v.grant_type !== "authorization_code")
+                    throw Error();
+                const row = this.db
+                    .prepare("SELECT request_json,expires FROM codes WHERE hash=?")
+                    .get(hash(v.code ?? ""));
+                if (!row || Number(row.expires) < Date.now())
+                    throw Error();
+                const saved = JSON.parse(String(row.request_json));
+                if (v.client_id !== saved.client_id ||
+                    v.redirect_uri !== saved.redirect_uri ||
+                    (v.resource && v.resource !== this.origin + "/mcp") ||
+                    typeof v.code_verifier !== "string" ||
+                    v.code_verifier.length < 43 ||
+                    v.code_verifier.length > 128 ||
+                    createHash("sha256").update(v.code_verifier).digest("base64url") !==
+                        saved.code_challenge)
+                    throw Error();
+                const token = random();
+                this.db.exec("BEGIN IMMEDIATE");
+                try {
+                    if (!this.db.prepare("DELETE FROM codes WHERE hash=?").run(hash(v.code))
+                        .changes)
+                        throw Error();
+                    this.db
+                        .prepare("INSERT INTO tokens VALUES (?,?,?)")
+                        .run(hash(token), this.principal, Date.now() + 86400000);
+                    this.db.exec("COMMIT");
+                }
+                catch (e) {
+                    this.db.exec("ROLLBACK");
+                    throw e;
+                }
+                return json({
+                    access_token: token,
+                    token_type: "Bearer",
+                    expires_in: 86400,
+                    scope: "envar:tasks",
+                });
+            }
+            return json({ error: "method_not_allowed" }, 405);
+        }
+        catch {
+            return json({ error: "invalid_request" }, 400);
+        }
+    }
+    close() {
+        this.db.close();
+    }
+}

package/dist/commerce/external-runtime.d.ts

@@ -0,0 +1,25 @@
+import { CommerceStore } from "./store.js";
+import { CommerceServer } from "./server.js";
+import { ExternalAgentEvents, type CallbackLookup } from "./external-events.js";
+export declare function setupExternalAgent(directory: string, origin: string): {
+    directory: string;
+    cardUrl: string;
+    mcpUrl: string;
+    credentialsFile: string;
+    paymentsEnabled: boolean;
+};
+export declare function serveExternalAgent(options: {
+    configFile: string;
+    credentialsFile: string;
+    stateFile: string;
+    origin: string;
+    host: string;
+    port: number;
+    callbackLookup?: CallbackLookup;
+}): {
+    http: import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+    store: CommerceStore;
+    events: ExternalAgentEvents;
+    server: CommerceServer;
+    close: () => Promise<void>;
+};

package/dist/commerce/external-runtime.js

@@ -0,0 +1,244 @@
+import { ExternalAgentOAuth } from "./external-oauth.js";
+import { createServer } from "node:http";
+import { Readable } from "node:stream";
+import { join, dirname, resolve } from "node:path";
+import { readFileSync, lstatSync, chmodSync, mkdirSync, writeFileSync, } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { CommerceStore } from "./store.js";
+import { CommerceServer, bearerAuthenticator } from "./server.js";
+import { loadCommerceConfig } from "./config.js";
+import { ExternalAgentExecutor } from "./external-agent.js";
+import { ExternalAgentEvents, publicWebhook, } from "./external-events.js";
+import { ExternalAgentMcp, externalAgentSkill } from "./external-mcp.js";
+import { CredentialVault } from "./vault.js";
+import { CommerceError } from "./types.js";
+export function setupExternalAgent(directory, origin) {
+    directory = resolve(directory);
+    const u = new URL(origin);
+    if (u.protocol !== "https:" || u.origin !== origin)
+        throw new CommerceError("external_origin", "Provide the exact public HTTPS origin");
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const config = {
+        configVersion: 1,
+        agent: { id: "external-agent", name: "External Agent" },
+        paymentProfiles: {},
+        services: [
+            {
+                id: "text-answer",
+                name: "Bounded text answer",
+                revision: 1,
+                execution: { type: "a2a", cardUrl: origin + "/agent-card.json" },
+                contract: {
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            request: { type: "string", minLength: 1, maxLength: 2000 },
+                        },
+                        required: ["request"],
+                        additionalProperties: false,
+                    },
+                    deliverables: ["external-agent-result.txt"],
+                    targetDurationSeconds: 600,
+                    includedRevisions: 0,
+                },
+                offers: [
+                    {
+                        id: "free",
+                        pricing: { kind: "free" },
+                        collection: { kind: "none" },
+                    },
+                ],
+            },
+        ],
+    };
+    loadCommerceConfig(config);
+    const agentToken = randomBytes(32).toString("base64url"), buyerToken = randomBytes(32).toString("base64url");
+    const credentials = {
+        principal: "external-agent",
+        services: ["text-answer"],
+        agentTokens: { [agentToken]: "external-agent" },
+        callers: { [buyerToken]: "owner" },
+        vaultKeyFile: join(directory, "events.key"),
+    };
+    for (const [name, value] of Object.entries({
+        "seller.json": JSON.stringify(config, null, 2),
+        "credentials.json": JSON.stringify(credentials, null, 2),
+        "events.key": randomBytes(32),
+        "agent.token": agentToken,
+        "pairing.key": randomBytes(32).toString("base64url"),
+        "buyer.token": buyerToken,
+        "SKILL.md": externalAgentSkill,
+        "connection.json": JSON.stringify({
+            url: origin + "/services/text-answer/v1/offers/free/agent-card.json",
+            authToken: buyerToken,
+            mcpUrl: origin + "/mcp",
+        }),
+    }))
+        writeFileSync(join(directory, name), value, { mode: 0o600, flag: "wx" });
+    return {
+        directory,
+        cardUrl: origin + "/services/text-answer/v1/offers/free/agent-card.json",
+        mcpUrl: origin + "/mcp",
+        credentialsFile: join(directory, "credentials.json"),
+        paymentsEnabled: false,
+    };
+}
+export function serveExternalAgent(options) {
+    const privateBytes = (path) => {
+        const s = lstatSync(path);
+        if (!s.isFile() || s.isSymbolicLink() || s.mode & 0o077 || s.size > 65536)
+            throw new CommerceError("external_private_file", "Use private regular config/credential files");
+        return readFileSync(path);
+    };
+    const privateJson = (path) => JSON.parse(privateBytes(path).toString("utf8"));
+    const config = loadCommerceConfig(privateJson(options.configFile)), secret = privateJson(options.credentialsFile);
+    if (config.services.some((s) => s.execution.type !== "a2a" ||
+        s.offers.some((o) => o.pricing.kind !== "free")) ||
+        Object.keys(config.paymentProfiles).length)
+        throw new CommerceError("external_free_only", "External setup currently supports explicit free task acceptance only");
+    if (Object.keys(secret.agentTokens).some((token) => Object.hasOwn(secret.callers, token)))
+        throw new CommerceError("external_token_scope", "External Agent tokens must differ from buyer credentials");
+    const store = new CommerceStore(options.stateFile), executor = new ExternalAgentExecutor(store, secret.principal, secret.services), vault = new CredentialVault(join(dirname(options.stateFile), "event-secrets"), privateBytes(secret.vaultKeyFile));
+    const pairingFile = join(dirname(options.credentialsFile), "pairing.key"), oauth = new ExternalAgentOAuth(options.stateFile + ".oauth.sqlite3", options.origin, secret.principal, privateBytes(pairingFile).toString("utf8").trim());
+    const agentAuth = bearerAuthenticator(secret.agentTokens);
+    const eventsPath = options.stateFile + ".events.sqlite3", events = new ExternalAgentEvents(eventsPath, executor, vault, (url, body, headers) => publicWebhook(url, body, headers, options.callbackLookup));
+    chmodSync(eventsPath, 0o600);
+    const mcp = new ExternalAgentMcp(executor, events, async (r) => oauth.authenticate(r) ?? (await agentAuth(r)));
+    const server = new CommerceServer({
+        config,
+        store,
+        origin: options.origin,
+        authenticate: bearerAuthenticator(secret.callers),
+        execute: executor.execute,
+    });
+    const expected = new URL(options.origin).host;
+    async function externalA2a(request) {
+        const path = new URL(request.url).pathname;
+        let normalized = request;
+        if (request.method === "POST" && path.endsWith("/a2a")) {
+            const rawText = await request.text();
+            if (Buffer.byteLength(rawText) > 65536)
+                return Response.json({ error: "request_too_large" }, { status: 413 });
+            let raw;
+            try {
+                raw = JSON.parse(rawText);
+            }
+            catch {
+                return Response.json({ error: "invalid_json" }, { status: 400 });
+            }
+            if (raw.method === "SendMessage") {
+                const message = raw.params?.message;
+                if (message?.parts?.length === 1 &&
+                    typeof message.parts[0]?.text === "string" &&
+                    Object.keys(message.parts[0]).every((k) => ["text", "mediaType"].includes(k))) {
+                    const text = message.parts[0].text;
+                    // This opt-in external service advertises a bounded plain-text request.
+                    // A JSON-text request with exactly that schema is also accepted.
+                    let input = { request: text };
+                    try {
+                        const parsed = JSON.parse(text);
+                        if (parsed &&
+                            !Array.isArray(parsed) &&
+                            Object.keys(parsed).length === 1 &&
+                            typeof parsed.request === "string")
+                            input = parsed;
+                    }
+                    catch { }
+                    message.parts = [{ data: input }];
+                }
+                raw.params.configuration = {
+                    ...raw.params.configuration,
+                    returnImmediately: true,
+                };
+            }
+            normalized = new Request(request.url, {
+                method: "POST",
+                headers: request.headers,
+                body: JSON.stringify(raw),
+            });
+        }
+        const response = await server.handle(normalized);
+        if (response.status !== 200)
+            return response;
+        const value = await response.json();
+        if (request.method === "GET" && path.endsWith("/agent-card.json")) {
+            value.defaultInputModes = ["application/json", "text/plain"];
+        }
+        // Internally the completed dispatch queue waits for an external claim.
+        // A2A buyers see WORKING and can poll until this original Task completes.
+        for (const task of [value.result?.task, value.result]) {
+            if (task?.status?.state === "TASK_STATE_INPUT_REQUIRED" &&
+                task.metadata?.externalAgent) {
+                task.status.state = "TASK_STATE_WORKING";
+                delete task.status.message;
+            }
+        }
+        return Response.json(value, {
+            status: response.status,
+            headers: response.headers,
+        });
+    }
+    const http = createServer(async (req, res) => {
+        try {
+            if (req.headers.host !== expected) {
+                res.writeHead(421);
+                res.end();
+                return;
+            }
+            const headers = new Headers();
+            for (const [k, v] of Object.entries(req.headers))
+                if (v !== undefined)
+                    headers.set(k, Array.isArray(v) ? v.join(",") : v);
+            const request = new Request(new URL(req.url ?? "/", options.origin), {
+                method: req.method,
+                headers,
+                ...(!["GET", "HEAD"].includes(req.method ?? "GET")
+                    ? { body: Readable.toWeb(req), duplex: "half" }
+                    : {}),
+            });
+            let response = await oauth.handle(request);
+            if (!response)
+                response =
+                    new URL(request.url).pathname === "/mcp"
+                        ? await mcp.handle(request)
+                        : await externalA2a(request);
+            if (response.status === 401 && new URL(request.url).pathname === "/mcp")
+                response = new Response(response.body, {
+                    status: 401,
+                    headers: {
+                        ...Object.fromEntries(response.headers),
+                        "WWW-Authenticate": oauth.challenge(),
+                    },
+                });
+            res.writeHead(response.status, Object.fromEntries(response.headers));
+            if (response.body)
+                Readable.fromWeb(response.body).pipe(res);
+            else
+                res.end();
+        }
+        catch {
+            if (!res.headersSent)
+                res.writeHead(500);
+            res.end('{"error":"request_failed"}');
+        }
+    });
+    http.requestTimeout = 30000;
+    http.headersTimeout = 15000;
+    http.listen(options.port, options.host);
+    events.start();
+    return {
+        http,
+        store,
+        events,
+        server,
+        close: async () => {
+            oauth.close();
+            await events.close();
+            server.stop();
+            await new Promise((resolve) => http.close(() => resolve()));
+            while (server.isRunning)
+                await new Promise((r) => setTimeout(r, 10));
+            store.close();
+        },
+    };
+}

package/dist/commerce/managed.d.ts

@@ -0,0 +1,3 @@
+export declare function managedProfile(root: string): string;
+export declare function activateManagedProfile(root: string, agentId: string, profile: string): void;
+export declare function serveManaged(root: string, origin: string, host: string, port: number): Promise<void>;

package/dist/commerce/managed.js

@@ -0,0 +1,143 @@
+/** A persistent native-runtime host for the existing seller CLI. No wallet authority is added. */
+import { chownSync, closeSync, existsSync, fsyncSync, linkSync, lstatSync, openSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+import { once } from 'node:events';
+import { DatabaseSync } from 'node:sqlite';
+import { CommerceError } from './types.js';
+const idPattern = /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/;
+function rootDirectory(root) {
+    const path = resolve(root), stat = lstatSync(path);
+    if (!stat.isDirectory() || stat.isSymbolicLink() || (stat.mode & 0o077))
+        throw new CommerceError('managed_directory', 'Use the existing private managed EnvarPay directory');
+    return path;
+}
+export function managedProfile(root) {
+    const base = rootDirectory(root), file = join(base, 'active-profile.json');
+    const profiles = join(base, 'profiles');
+    if (existsSync(profiles)) {
+        const stat = lstatSync(profiles);
+        if (!stat.isDirectory() || stat.isSymbolicLink() || (stat.mode & 0o077))
+            throw new CommerceError('managed_profile', 'Use a private profile directory without links');
+    }
+    if (!existsSync(file))
+        return base;
+    const stat = lstatSync(file);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 1024 || (stat.mode & 0o077))
+        throw new CommerceError('managed_profile', 'Invalid managed profile');
+    const value = JSON.parse(readFileSync(file, 'utf8'));
+    if (value.version !== 1 || !idPattern.test(value.agentId))
+        throw new CommerceError('managed_profile', 'Invalid managed Agent identity');
+    const path = join(base, 'profiles', value.agentId), p = lstatSync(path);
+    if (!p.isDirectory() || p.isSymbolicLink() || (p.mode & 0o077))
+        throw new CommerceError('managed_profile', 'Use the original private profile');
+    return path;
+}
+export function activateManagedProfile(root, agentId, profile) {
+    const base = rootDirectory(root);
+    if (!idPattern.test(agentId) || resolve(profile) !== join(base, 'profiles', agentId))
+        throw new CommerceError('managed_profile', 'Profile does not belong to this managed Agent');
+    const previous = managedProfile(base);
+    if (previous !== base && previous !== resolve(profile))
+        throw new CommerceError('managed_bound', 'This runtime is already bound to another Agent; preserve its ledger');
+    if (previous === base) {
+        const config = JSON.parse(readFileSync(join(base, 'seller.json'), 'utf8'));
+        if (config.services?.length || Object.keys(config.paymentProfiles ?? {}).length)
+            throw new CommerceError('managed_in_use', 'Existing seller configuration requires review');
+        const ledger = join(base, 'seller.sqlite3');
+        if (existsSync(ledger)) {
+            const db = new DatabaseSync(ledger, { readOnly: true });
+            try {
+                for (const table of ['commerce_orders', 'commerce_service_revisions']) {
+                    if (db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?").get(table) && Number(db.prepare(`SELECT count(*) AS n FROM ${table}`).get()?.n))
+                        throw new CommerceError('managed_in_use', 'Keep the existing seller ledger and inspect its operations before connecting');
+                }
+            }
+            finally {
+                db.close();
+            }
+        }
+    }
+    const owner = lstatSync(base);
+    function ownership(path) {
+        const s = lstatSync(path);
+        if (s.isSymbolicLink() || (!s.isDirectory() && !s.isFile()))
+            throw new CommerceError('managed_profile', 'Managed profiles cannot contain links or special files');
+        if (process.getuid?.() === 0)
+            chownSync(path, owner.uid, owner.gid);
+        if (s.isDirectory())
+            for (const name of readdirSync(path))
+                ownership(join(path, name));
+    }
+    ownership(join(base, 'profiles'));
+    const connection = JSON.parse(readFileSync(join(profile, 'connection.json'), 'utf8'));
+    if (connection.agentId !== agentId)
+        throw new CommerceError('managed_profile', 'Connection belongs to another Agent');
+    if (previous === resolve(profile))
+        return;
+    const temp = join(base, `.active-${process.pid}.json`);
+    writeFileSync(temp, JSON.stringify({ version: 1, agentId }), { mode: 0o600, flag: 'wx', flush: true });
+    if (process.getuid?.() === 0)
+        chownSync(temp, owner.uid, owner.gid);
+    try {
+        // Atomic create prevents two setup processes from replacing one another's binding.
+        linkSync(temp, join(base, 'active-profile.json'));
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST' || managedProfile(base) !== resolve(profile))
+            throw new CommerceError('managed_bound', 'This runtime was bound by another setup; preserve its original profile');
+    }
+    finally {
+        unlinkSync(temp);
+    }
+    const directory = openSync(base, 'r');
+    try {
+        fsyncSync(directory);
+    }
+    finally {
+        closeSync(directory);
+    }
+}
+export async function serveManaged(root, origin, host, port) {
+    const base = rootDirectory(root), cli = fileURLToPath(new URL('./cli.js', import.meta.url));
+    let child, stopping = false;
+    const stop = () => { stopping = true; child?.kill('SIGTERM'); };
+    process.once('SIGTERM', stop);
+    process.once('SIGINT', stop);
+    try {
+        while (!stopping) {
+            const profile = managedProfile(base);
+            const stamp = () => ['credentials.json', 'envar.json', 'envar.token'].map(name => { const p = join(profile, name); return existsSync(p) ? lstatSync(p).mtimeMs : 0; }).join(':');
+            const initialStamp = stamp();
+            const args = [cli, 'serve', '--config', join(profile, 'seller.json'), '--credentials', join(profile, 'credentials.json'), '--state', join(profile, 'seller.sqlite3'), '--origin', origin, '--host', host, '--port', String(port)];
+            if (profile !== base)
+                args.push('--envar-config', join(profile, 'envar.json'), '--envar-credentials', join(profile, 'envar.token'));
+            child = spawn(process.execPath, args, { stdio: 'inherit' });
+            let switching = false;
+            const timer = setInterval(() => {
+                try {
+                    if (!switching && (managedProfile(base) !== profile || stamp() !== initialStamp)) {
+                        switching = true;
+                        child?.kill('SIGTERM');
+                    }
+                }
+                catch {
+                    stop();
+                }
+            }, 1000);
+            try {
+                const [code] = await once(child, 'exit');
+                if (!stopping && !switching)
+                    throw new CommerceError('managed_runtime_exit', `Seller stopped (${code}); keep its profile and inspect its configuration`);
+            }
+            finally {
+                clearInterval(timer);
+            }
+        }
+    }
+    finally {
+        process.removeListener('SIGTERM', stop);
+        process.removeListener('SIGINT', stop);
+    }
+}

package/dist/commerce/native-inventory.d.ts

@@ -0,0 +1,9 @@
+export declare const isSkillInstallerMetadata: (path: string) => path is ".clawhub/origin.json" | ".openclaw/source-origin.json";
+export declare function readSkillInventory(roots: string[]): {
+    name: string;
+    path: string;
+    description: string;
+    supported: boolean;
+    digest: string;
+    files: number;
+}[];