@envarai/envarpay 0.2.0-alpha.2 → 0.2.0-alpha.20

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/index.d.ts

@@ -2,3 +2,4 @@ export * from './types.js';
 export * from './config.js';
 export * from './pricing.js';
 export * from './card.js';
+export * from './skill-gate.js';

package/dist/commerce/index.js

@@ -2,3 +2,4 @@ export * from './types.js';
 export * from './config.js';
 export * from './pricing.js';
 export * from './card.js';
+export * from './skill-gate.js';

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;
+}[];

package/dist/commerce/native-inventory.js

@@ -0,0 +1,75 @@
+import { existsSync, lstatSync, readFileSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { extname, join, resolve } from 'node:path';
+import { createHash } from 'node:crypto';
+import { parse } from 'yaml';
+const namePattern = /^[a-z][a-z0-9-]{0,63}$/;
+// Native installer provenance is included in the source digest, but never
+// copied into the executable service package or supplied to the model.
+export const isSkillInstallerMetadata = (path) => path === '.clawhub/origin.json' || path === '.openclaw/source-origin.json';
+export function readSkillInventory(roots) {
+    const found = [];
+    const seen = new Set();
+    function visit(folder, depth) {
+        if (depth > 10 || found.length >= 128 || !existsSync(folder))
+            return;
+        const stat = lstatSync(folder);
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            return;
+        const entry = join(folder, 'SKILL.md');
+        if (!existsSync(entry)) {
+            for (const child of readdirSync(folder).sort())
+                if (!child.startsWith('.'))
+                    visit(join(folder, child), depth + 1);
+            return;
+        }
+        const info = lstatSync(entry);
+        if (!info.isFile() || info.isSymbolicLink() || info.size > 48000)
+            return;
+        const raw = readFileSync(entry, 'utf8'), header = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(raw)?.[1];
+        let meta;
+        try {
+            meta = parse(header ?? '') ?? {};
+        }
+        catch {
+            return;
+        }
+        if (typeof meta.name !== 'string' || !namePattern.test(meta.name) || seen.has(meta.name))
+            return;
+        const files = [];
+        let size = 0, supported = true;
+        function collect(path, prefix = '', level = 0) {
+            if (level > 10) {
+                supported = false;
+                return;
+            }
+            for (const name of readdirSync(path).sort()) {
+                const file = join(path, name), s = lstatSync(file);
+                if (s.isSymbolicLink()) {
+                    supported = false;
+                    continue;
+                }
+                if (s.isDirectory()) {
+                    collect(file, prefix + name + '/', level + 1);
+                    continue;
+                }
+                if (!s.isFile() || s.size > 512 * 1024 || (size += s.size) > 1024 * 1024 || files.length >= 128) {
+                    supported = false;
+                    continue;
+                }
+                if (!['.md', '.txt'].includes(extname(name).toLowerCase()) && name !== 'LICENSE' && !isSkillInstallerMetadata(prefix + name))
+                    supported = false;
+                files.push([prefix + name, createHash('sha256').update(readFileSync(file)).digest('hex')]);
+            }
+        }
+        collect(folder);
+        files.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+        const canonical = JSON.stringify(files).replace(/[\u007f-\uffff]/g, c => '\\u' + c.charCodeAt(0).toString(16).padStart(4, '0'));
+        seen.add(meta.name);
+        found.push({ name: meta.name, path: resolve(folder), description: String(meta.description ?? '').slice(0, 500), supported, digest: createHash('sha256').update(canonical).digest('hex'), files: files.length });
+    }
+    for (const root of roots.slice(0, 16))
+        if (typeof root === 'string')
+            visit(resolve(root.replace(/^~(?=\/|$)/, homedir())), 0);
+    return found;
+}

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

@@ -0,0 +1,32 @@
+import { type SkillDescriptor } from './skill-gate.js';
+import type { ExecuteOrder } from './server.js';
+export interface NativeSkillSettings {
+    framework: 'hermes' | 'openclaw';
+    skillsDirectory: string;
+    freeSkills: string[];
+    stateDirectory: string;
+    python: string;
+    command?: string[];
+    model: string;
+    baseUrl: string;
+    apiKeyFile: string;
+    /** Host-side Docker CLI, never a Docker socket mounted into the Agent. */
+    dockerContainer?: string;
+    dockerStateDirectory?: string;
+    discovery?: {
+        hermesHome: string;
+        enabledFromWeb: true;
+        roots?: string[];
+    };
+}
+interface InstalledSkill {
+    descriptor: SkillDescriptor;
+    instructions: string;
+}
+/** Hash every resource; reject symlinks, unbounded packages and executable skill requirements. */
+export declare function readInstalledSkills(root: string, freeSkills: readonly string[], cardUrl: string): InstalledSkill[];
+export declare function createNativeSkillExecutor(settings: NativeSkillSettings, origin: string, agentName: string): {
+    execute: ExecuteOrder;
+    close(): Promise<void>;
+};
+export {};