@clawcrony/claw-crony 1.2.2 → 1.2.4

package/dist/src/hub-match.d.ts

@@ -1,20 +1,14 @@
 /**
- * Hub Match API client for openclaw-claw-crony.
- *
- * Provides a typed client for the hub's /api/matches endpoints:
- * - POST   /api/matches              createMatch
- * - GET    /api/matches/{id}         getMatch
- * - GET    /api/matches/pending       getPendingMatches
- * - POST   /api/matches/{id}/token   submitToken
- * - POST   /api/matches/{id}/complete completeMatch
- * - POST   /api/matches/{id}/cancel  cancelMatch
+ * Hub Match API client for claw-crony.
  */
 import type { HubRegistrationData } from "./types.js";
 export interface HubAgentDto {
     id: number;
     name: string;
-    address: string;
     skills: string[];
+    clientId?: string;
+    publicKey?: string;
+    presenceStatus?: string;
 }
 export interface HubMatchResult {
     id: number;
@@ -22,58 +16,53 @@ export interface HubMatchResult {
     status: string;
     requester: HubAgentDto | null;
     provider: HubAgentDto | null;
-    yourToken: string | null;
-    peerToken: string | null;
+    yourToken?: string | null;
+    peerToken?: string | null;
     callerRole?: "requester" | "provider" | "observer" | null;
     requesterTokenSubmitted?: boolean;
     providerTokenSubmitted?: boolean;
     readyForComplete?: boolean;
+    requesterHandshakeSent?: boolean;
+    providerHandshakeSent?: boolean;
+    requesterHandshakeConsumed?: boolean;
+    providerHandshakeConsumed?: boolean;
+    requesterReady?: boolean;
+    providerReady?: boolean;
+    readyForConnect?: boolean;
+}
+export interface HubHandshakeMessage {
+    id: number;
+    senderAgentId: number;
+    receiverAgentId: number;
+    messageType: "offer" | "answer";
+    ciphertext: string;
+    status: string;
+    expiresAt: string;
+    createdAt?: string;
+    consumedAt?: string | null;
 }
 export declare class HubMatchClient {
     private readonly hubUrl;
     private readonly registration;
     constructor(hubUrl: string, registration: HubRegistrationData);
     get agentId(): number;
-    get registrationToken(): string;
     static create(): Promise<HubMatchClient>;
     private request;
-    /**
-     * Create a new match request.
-     * @param params.skills - Skills to search for in a provider
-     * @param params.description - Optional description of the match request
-     * @param params.token - Optional bearer token to include for this agent
-     */
     createMatch(params: {
         skills: string[];
         description?: string;
-        token?: string;
     }): Promise<HubMatchResult>;
-    /**
-     * Get a match result by ID.
-     * @param matchId - The match ID
-     * @param callerId - Optional agent ID to set callerId query param (affects yourToken)
-     */
     getMatch(matchId: number, callerId?: number): Promise<HubMatchResult>;
-    /**
-     * Get all pending matches for this agent.
-     */
     getPendingMatches(): Promise<HubMatchResult[]>;
-    /**
-     * Submit this agent's token for a match.
-     * @param matchId - The match ID
-     * @param token - This agent's bearer token
-     */
-    submitToken(matchId: number, token: string): Promise<HubMatchResult>;
-    /**
-     * Mark a match as completed (both parties have submitted tokens).
-     * @param matchId - The match ID
-     * @param token - This agent's bearer token (for authorization)
-     */
-    completeMatch(matchId: number, token: string): Promise<HubMatchResult>;
-    /**
-     * Cancel a pending or token_exchange match.
-     * @param matchId - The match ID
-     * @param token - This agent's bearer token (for authorization)
-     */
-    cancelMatch(matchId: number, token: string): Promise<HubMatchResult>;
+    updatePresence(presenceStatus: "online" | "offline" | "busy", clientVersion?: string): Promise<HubAgentDto>;
+    sendHandshakeMessage(matchId: number, params: {
+        messageType: "offer" | "answer";
+        ciphertext: string;
+        expiresAt: string;
+    }): Promise<HubHandshakeMessage>;
+    getPendingHandshakeMessages(matchId: number): Promise<HubHandshakeMessage[]>;
+    consumeHandshakeMessage(matchId: number, messageId: number): Promise<HubHandshakeMessage>;
+    markReady(matchId: number): Promise<HubMatchResult>;
+    completeMatch(matchId: number): Promise<HubMatchResult>;
+    cancelMatch(matchId: number): Promise<HubMatchResult>;
 }

package/dist/src/hub-match.js

@@ -1,18 +1,7 @@
 /**
- * Hub Match API client for openclaw-claw-crony.
- *
- * Provides a typed client for the hub's /api/matches endpoints:
- * - POST   /api/matches              createMatch
- * - GET    /api/matches/{id}         getMatch
- * - GET    /api/matches/pending       getPendingMatches
- * - POST   /api/matches/{id}/token   submitToken
- * - POST   /api/matches/{id}/complete completeMatch
- * - POST   /api/matches/{id}/cancel  cancelMatch
+ * Hub Match API client for claw-crony.
  */
 import { loadRegistration } from "./hub-registration.js";
-// ---------------------------------------------------------------------------
-// HubMatchClient
-// ---------------------------------------------------------------------------
 export class HubMatchClient {
     hubUrl;
     registration;
@@ -23,16 +12,12 @@ export class HubMatchClient {
     get agentId() {
         return this.registration.agentId;
     }
-    get registrationToken() {
-        return this.registration.token;
-    }
     static async create() {
         const registration = loadRegistration();
         if (!registration) {
             throw new Error("No hub registration found. Run the gateway first to register with the hub.");
         }
-        const configUrl = registration.hubUrl;
-        return new HubMatchClient(configUrl, registration);
+        return new HubMatchClient(registration.hubUrl, registration);
     }
     async request(path, options = {}) {
         const url = `${this.hubUrl}${path}`;
@@ -40,7 +25,6 @@ export class HubMatchClient {
             ...options,
             headers: {
                 "Content-Type": "application/json",
-                "Authorization": `Bearer ${this.registration.token}`,
                 ...(options.headers ?? {}),
             },
         });
@@ -50,12 +34,6 @@ export class HubMatchClient {
         }
         return res.json();
     }
-    /**
-     * Create a new match request.
-     * @param params.skills - Skills to search for in a provider
-     * @param params.description - Optional description of the match request
-     * @param params.token - Optional bearer token to include for this agent
-     */
     async createMatch(params) {
         return this.request("/api/matches", {
             method: "POST",
@@ -63,45 +41,57 @@ export class HubMatchClient {
                 agentId: this.registration.agentId,
                 requiredSkills: params.skills,
                 description: params.description ?? "",
-                token: params.token,
             }),
         });
     }
-    /**
-     * Get a match result by ID.
-     * @param matchId - The match ID
-     * @param callerId - Optional agent ID to set callerId query param (affects yourToken)
-     */
     async getMatch(matchId, callerId) {
         const path = callerId != null ? `/api/matches/${matchId}?callerId=${callerId}` : `/api/matches/${matchId}`;
         return this.request(path);
     }
-    /**
-     * Get all pending matches for this agent.
-     */
     async getPendingMatches() {
         return this.request(`/api/matches/pending?agentId=${this.registration.agentId}`);
     }
-    /**
-     * Submit this agent's token for a match.
-     * @param matchId - The match ID
-     * @param token - This agent's bearer token
-     */
-    async submitToken(matchId, token) {
-        return this.request(`/api/matches/${matchId}/token`, {
+    async updatePresence(presenceStatus, clientVersion = "claw-crony/1.2.4") {
+        return this.request(`/api/agents/${this.registration.agentId}/presence`, {
+            method: "PUT",
+            body: JSON.stringify({
+                presenceStatus,
+                clientVersion,
+            }),
+        });
+    }
+    async sendHandshakeMessage(matchId, params) {
+        return this.request(`/api/matches/${matchId}/handshake`, {
+            method: "POST",
+            body: JSON.stringify({
+                agentId: this.registration.agentId,
+                messageType: params.messageType,
+                ciphertext: params.ciphertext,
+                expiresAt: params.expiresAt,
+            }),
+        });
+    }
+    async getPendingHandshakeMessages(matchId) {
+        const result = await this.request(`/api/matches/${matchId}/handshake/pending?agentId=${this.registration.agentId}`);
+        return result.messages ?? [];
+    }
+    async consumeHandshakeMessage(matchId, messageId) {
+        return this.request(`/api/matches/${matchId}/handshake/${messageId}/consume`, {
+            method: "POST",
+            body: JSON.stringify({
+                agentId: this.registration.agentId,
+            }),
+        });
+    }
+    async markReady(matchId) {
+        return this.request(`/api/matches/${matchId}/ready`, {
             method: "POST",
             body: JSON.stringify({
                 agentId: this.registration.agentId,
-                token,
             }),
         });
     }
-    /**
-     * Mark a match as completed (both parties have submitted tokens).
-     * @param matchId - The match ID
-     * @param token - This agent's bearer token (for authorization)
-     */
-    async completeMatch(matchId, token) {
+    async completeMatch(matchId) {
         return this.request(`/api/matches/${matchId}/complete`, {
             method: "POST",
             body: JSON.stringify({
@@ -109,12 +99,7 @@ export class HubMatchClient {
             }),
         });
     }
-    /**
-     * Cancel a pending or token_exchange match.
-     * @param matchId - The match ID
-     * @param token - This agent's bearer token (for authorization)
-     */
-    async cancelMatch(matchId, token) {
+    async cancelMatch(matchId) {
         return this.request(`/api/matches/${matchId}/cancel`, {
             method: "POST",
             body: JSON.stringify({

package/dist/src/hub-registration.d.ts

@@ -1,8 +1,8 @@
 /**
- * Hub registration module for openclaw-claw-crony.
+ * Hub registration module for claw-crony.
  *
- * Handles automatic registration of the gateway with the hub server on first startup,
- * token generation, and idempotent re-registration.
+ * Registers the local plugin with the hub using client_id + public_key
+ * and persists the resulting agent binding locally.
  */
 import type { GatewayConfig, HubConfig, HubRegistrationData, OpenClawPluginApi, RegistrationConfig } from "./types.js";
 export declare function loadRegistration(configDir?: string): HubRegistrationData | null;
@@ -13,11 +13,4 @@ export interface HubRegistration {
     address: string;
     name: string;
 }
-/**
- * Run the full hub registration flow:
- * 1. Load existing registration (if any)
- * 2. Validate existing token with hub
- * 3. If no valid registration, create new one (handling 409 conflicts)
- * 4. Save registration file atomically
- */
 export declare function runHubRegistration(api: OpenClawPluginApi, config: GatewayConfig, hubConfig: HubConfig, registrationConfig: RegistrationConfig): Promise<HubRegistration | null>;

package/dist/src/hub-registration.js

@@ -1,22 +1,13 @@
 /**
- * Hub registration module for openclaw-claw-crony.
+ * Hub registration module for claw-crony.
  *
- * Handles automatic registration of the gateway with the hub server on first startup,
- * token generation, and idempotent re-registration.
+ * Registers the local plugin with the hub using client_id + public_key
+ * and persists the resulting agent binding locally.
  */
-import crypto from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-// ---------------------------------------------------------------------------
-// Token generation
-// ---------------------------------------------------------------------------
-function generateToken() {
-    return crypto.randomBytes(32).toString("hex");
-}
-// ---------------------------------------------------------------------------
-// Registration file path & I/O
-// ---------------------------------------------------------------------------
+import { loadOrCreateIdentity } from "./identity-store.js";
 const REGISTRATION_FILENAME = "a2a-registration.json";
 function getRegistrationPath(configDir) {
     return path.join(configDir, REGISTRATION_FILENAME);
@@ -48,7 +39,6 @@ async function registerHubUser(hubUrl, agentId, username, password) {
         body: JSON.stringify({ agentId, username, password }),
     });
     if (res.status === 409) {
-        // Already registered — this is fine, idempotent
         return;
     }
     if (!res.ok) {
@@ -63,18 +53,14 @@ async function registerWithHub(hubUrl, payload) {
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(payload),
     });
-    if (res.status === 409) {
-        const err = await res.json().catch(() => ({}));
-        throw Object.assign(new Error("Agent address already registered"), { status: 409, body: err });
-    }
     if (!res.ok) {
         const err = await res.json().catch(() => ({}));
         throw Object.assign(new Error(`Hub rejected registration: ${JSON.stringify(err)}`), { status: res.status });
     }
     return res.json();
 }
-async function lookupAgentByAddress(hubUrl, address) {
-    const url = `${hubUrl.replace(/\/$/, "")}/api/agents?address=${encodeURIComponent(address)}`;
+async function lookupAgentByClientId(hubUrl, clientId) {
+    const url = `${hubUrl.replace(/\/$/, "")}/api/agents?clientId=${encodeURIComponent(clientId)}`;
     const res = await fetch(url);
     if (!res.ok) {
         throw Object.assign(new Error(`Hub lookup failed: ${res.status}`), { status: res.status });
@@ -82,9 +68,6 @@ async function lookupAgentByAddress(hubUrl, address) {
     const agents = await res.json();
     return agents.length > 0 ? agents[0] : null;
 }
-// ---------------------------------------------------------------------------
-// Retry with exponential backoff
-// ---------------------------------------------------------------------------
 async function retryWithBackoff(fn, maxRetries, baseDelayMs, maxDelayMs) {
     let lastError;
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
@@ -101,106 +84,37 @@ async function retryWithBackoff(fn, maxRetries, baseDelayMs, maxDelayMs) {
     }
     throw lastError;
 }
-// ---------------------------------------------------------------------------
-// Flatten skills from agent card config
-// ---------------------------------------------------------------------------
 function flattenSkills(skills) {
     return skills.map((s) => (typeof s === "string" ? s : s.name));
 }
-/**
- * Run the full hub registration flow:
- * 1. Load existing registration (if any)
- * 2. Validate existing token with hub
- * 3. If no valid registration, create new one (handling 409 conflicts)
- * 4. Save registration file atomically
- */
 export async function runHubRegistration(api, config, hubConfig, registrationConfig) {
     const configDir = getConfigDir();
     const hubUrl = hubConfig.url;
-    // Derive address from agentCard.url (the externally reachable address), not server.bind
-    // e.g. "http://100.10.10.1:18800/a2a/jsonrpc" -> "100.10.10.1:18800"
-    let address;
-    if (config.agentCard.url) {
-        try {
-            const urlObj = new URL(config.agentCard.url);
-            address = `${urlObj.hostname}:${urlObj.port || (urlObj.protocol === "https:" ? 443 : 80)}`;
-        }
-        catch {
-            address = `${config.server.host}:${config.server.port}`;
-        }
-    }
-    else {
-        address = `${config.server.host}:${config.server.port}`;
-    }
-    // Ensure config directory exists
+    const identity = loadOrCreateIdentity(registrationConfig.clientId);
     if (!fs.existsSync(configDir)) {
         fs.mkdirSync(configDir, { recursive: true });
     }
-    // Load existing registration
     const existing = loadRegistration(configDir);
-    // If we have a registration with a matching address and token, validate it
-    if (existing && existing.address === address && existing.hubUrl === hubUrl && existing.token) {
+    if (existing &&
+        existing.hubUrl === hubUrl &&
+        existing.clientId === identity.clientId &&
+        existing.publicKey === identity.publicKey) {
         try {
-            const agent = await lookupAgentByAddress(hubUrl, address);
+            const agent = await lookupAgentByClientId(hubUrl, identity.clientId);
             if (agent && agent.id === existing.agentId) {
                 api.logger.info(`claw-crony: using existing hub registration (agentId=${existing.agentId})`);
                 return {
                     agentId: existing.agentId,
-                    token: existing.token,
-                    address: existing.address,
+                    token: "",
+                    address: "",
                     name: existing.name,
                 };
             }
         }
         catch {
-            // Hub unreachable or agent not found — try re-registering with existing token first
-            api.logger.warn("claw-crony: existing registration invalid, trying with existing token");
-            const existingToken = existing.token;
-            try {
-                const existingPayload = {
-                    name: config.agentCard.name,
-                    description: config.agentCard.description ?? "",
-                    skills: flattenSkills(config.agentCard.skills),
-                    address,
-                    token: existingToken,
-                    username: registrationConfig.username ?? config.agentCard.name,
-                    email: registrationConfig.email ?? "",
-                };
-                const agent = await retryWithBackoff(() => registerWithHub(hubUrl, existingPayload), 3, 1000, 10000);
-                api.logger.info(`claw-crony: re-registered with hub using existing token (agentId=${agent.id})`);
-                // Also register hub user if password is configured
-                if (registrationConfig.password) {
-                    try {
-                        await retryWithBackoff(() => registerHubUser(hubUrl, agent.id, registrationConfig.username ?? config.agentCard.name, registrationConfig.password), 3, 1000, 10000);
-                        api.logger.info(`claw-crony: registered hub user for web login (agentId=${agent.id})`);
-                    }
-                    catch (err) {
-                        api.logger.warn(`claw-crony: hub user registration failed — ${err instanceof Error ? err.message : String(err)}`);
-                    }
-                }
-                // Re-save to update registration file
-                const updatedData = {
-                    ...existing,
-                    registeredAt: new Date().toISOString(),
-                };
-                saveRegistration(configDir, updatedData);
-                return { agentId: agent.id, token: existingToken, address, name: config.agentCard.name };
-            }
-            catch (err) {
-                // Existing token also failed (409 means address conflict from elsewhere)
-                const status = typeof err === "object" && err !== null ? err.status : undefined;
-                if (status === 409) {
-                    api.logger.warn("claw-crony: existing token rejected, generating new token");
-                }
-                else {
-                    api.logger.warn(`claw-crony: re-registration with existing token failed — ${err instanceof Error ? err.message : String(err)}`);
-                }
-                // fall through to generate new token
-            }
+            api.logger.warn("claw-crony: existing registration not confirmed remotely, re-registering");
         }
     }
-    // Generate new token
-    const token = generateToken();
     const name = config.agentCard.name;
     const description = config.agentCard.description ?? "";
     const skills = flattenSkills(config.agentCard.skills);
@@ -210,8 +124,10 @@ export async function runHubRegistration(api, config, hubConfig, registrationCon
         name,
         description,
         skills,
-        address,
-        token,
+        clientId: identity.clientId,
+        publicKey: identity.publicKey,
+        keyVersion: identity.keyVersion,
+        clientVersion: "claw-crony/1.2.4",
         username,
         email,
     };
@@ -220,15 +136,13 @@ export async function runHubRegistration(api, config, hubConfig, registrationCon
         const agent = await retryWithBackoff(() => registerWithHub(hubUrl, payload), 3, 1000, 10000);
         agentId = agent.id;
         api.logger.info(`claw-crony: registered with hub (agentId=${agentId})`);
-        // Also register hub user for web dashboard login (if password provided)
         if (registrationConfig.password) {
             try {
                 await retryWithBackoff(() => registerHubUser(hubUrl, agentId, username, registrationConfig.password), 3, 1000, 10000);
                 api.logger.info(`claw-crony: registered hub user for web login (agentId=${agentId})`);
             }
             catch (err) {
-                api.logger.warn(`claw-crony: hub user registration failed — ${err instanceof Error ? err.message : String(err)}`);
-                // Non-fatal — agent is registered, web login may already exist
+                api.logger.warn(`claw-crony: hub user registration failed - ${err instanceof Error ? err.message : String(err)}`);
             }
         }
         else {
@@ -237,46 +151,33 @@ export async function runHubRegistration(api, config, hubConfig, registrationCon
         }
     }
     catch (err) {
-        // 409 Conflict: address already registered by someone else — try to find our agentId
         if (typeof err === "object" && err !== null && err.status === 409) {
             try {
-                const existingAgent = await lookupAgentByAddress(hubUrl, address);
-                if (existingAgent) {
-                    agentId = existingAgent.id;
-                    api.logger.info(`claw-crony: found existing registration (agentId=${agentId})`);
-                    // Also register hub user if password is configured
-                    if (registrationConfig.password) {
-                        try {
-                            await retryWithBackoff(() => registerHubUser(hubUrl, agentId, registrationConfig.username ?? config.agentCard.name, registrationConfig.password), 3, 1000, 10000);
-                            api.logger.info(`claw-crony: registered hub user for web login (agentId=${agentId})`);
-                        }
-                        catch (err) {
-                            api.logger.warn(`claw-crony: hub user registration failed — ${err instanceof Error ? err.message : String(err)}`);
-                        }
-                    }
-                }
-                else {
-                    api.logger.error("claw-crony: address conflict but could not find existing agent");
+                const existingAgent = await lookupAgentByClientId(hubUrl, identity.clientId);
+                if (!existingAgent) {
+                    api.logger.error("claw-crony: identity conflict but could not find existing agent");
                     return null;
                 }
+                agentId = existingAgent.id;
+                api.logger.info(`claw-crony: found existing registration (agentId=${agentId})`);
             }
             catch {
-                api.logger.error("claw-crony: address conflict and hub lookup failed");
+                api.logger.error("claw-crony: identity conflict and hub lookup failed");
                 return null;
             }
         }
         else {
-            api.logger.warn(`claw-crony: hub registration failed — ${err instanceof Error ? err.message : String(err)}`);
+            api.logger.warn(`claw-crony: hub registration failed - ${err instanceof Error ? err.message : String(err)}`);
             return null;
         }
     }
-    // Save registration file
     const registrationData = {
-        version: 1,
+        version: 2,
         hubUrl,
         agentId,
-        address,
-        token,
+        clientId: identity.clientId,
+        publicKey: identity.publicKey,
+        keyVersion: identity.keyVersion,
         registeredAt: new Date().toISOString(),
         name,
         description,
@@ -286,7 +187,7 @@ export async function runHubRegistration(api, config, hubConfig, registrationCon
         saveRegistration(configDir, registrationData);
     }
     catch (saveErr) {
-        api.logger.warn(`claw-crony: failed to save registration file — ${saveErr instanceof Error ? saveErr.message : String(saveErr)}`);
+        api.logger.warn(`claw-crony: failed to save registration file - ${saveErr instanceof Error ? saveErr.message : String(saveErr)}`);
     }
-    return { agentId, token, address, name };
+    return { agentId, token: "", address: "", name };
 }

package/dist/src/identity-store.d.ts

@@ -0,0 +1,4 @@
+import type { IdentityData } from "./types.js";
+export declare function loadIdentity(configDir?: string): IdentityData | null;
+export declare function saveIdentity(configDir: string, data: IdentityData): void;
+export declare function loadOrCreateIdentity(clientId?: string): IdentityData;

package/dist/src/identity-store.js

@@ -0,0 +1,55 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const IDENTITY_FILENAME = "a2a-identity.json";
+function getConfigDir() {
+    return path.join(os.homedir(), ".openclaw");
+}
+function getIdentityPath(configDir) {
+    return path.join(configDir, IDENTITY_FILENAME);
+}
+function randomClientId() {
+    return crypto.randomUUID();
+}
+export function loadIdentity(configDir) {
+    const identityPath = getIdentityPath(configDir ?? getConfigDir());
+    try {
+        const raw = fs.readFileSync(identityPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function saveIdentity(configDir, data) {
+    const identityPath = getIdentityPath(configDir);
+    const tmpPath = `${identityPath}.tmp`;
+    fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+    fs.renameSync(tmpPath, identityPath);
+}
+export function loadOrCreateIdentity(clientId) {
+    const configDir = getConfigDir();
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    const existing = loadIdentity(configDir);
+    if (existing) {
+        if (clientId && existing.clientId !== clientId) {
+            existing.clientId = clientId;
+            saveIdentity(configDir, existing);
+        }
+        return existing;
+    }
+    const { publicKey, privateKey } = crypto.generateKeyPairSync("x25519");
+    const identity = {
+        version: 1,
+        clientId: clientId?.trim() || randomClientId(),
+        publicKey: publicKey.export({ format: "pem", type: "spki" }).toString(),
+        privateKey: privateKey.export({ format: "pem", type: "pkcs8" }).toString(),
+        keyVersion: 1,
+        createdAt: new Date().toISOString(),
+    };
+    saveIdentity(configDir, identity);
+    return identity;
+}