@silicaclaw/cli 2026.3.19-15 → 2026.3.19-16

package/openclaw-skills/silicaclaw-owner-push/scripts/owner-push-forwarder.mjs

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { spawn } from "node:child_process";
+
+const API_BASE = String(process.env.SILICACLAW_API_BASE || "http://localhost:4310").replace(/\/+$/, "");
+const POLL_INTERVAL_MS = Math.max(1000, Number(process.env.OPENCLAW_FORWARDER_INTERVAL_MS || 5000) || 5000);
+const LIMIT = Math.max(1, Number(process.env.OPENCLAW_FORWARDER_LIMIT || 30) || 30);
+const OWNER_FORWARD_CMD = String(process.env.OPENCLAW_OWNER_FORWARD_CMD || "").trim();
+const STATE_PATH = resolve(
+  String(process.env.OPENCLAW_OWNER_FORWARD_STATE_PATH || resolve(homedir(), ".openclaw", "workspace", "state", "silicaclaw-owner-push.json"))
+);
+const ONCE = process.argv.includes("--once");
+const VERBOSE = process.argv.includes("--verbose");
+
+function parseListEnv(name) {
+  return String(process.env[name] || "")
+    .split(",")
+    .map((item) => item.trim().toLowerCase())
+    .filter(Boolean);
+}
+
+const TOPIC_FILTERS = parseListEnv("OPENCLAW_FORWARD_TOPICS");
+const INCLUDE_TERMS = parseListEnv("OPENCLAW_FORWARD_INCLUDE");
+const EXCLUDE_TERMS = parseListEnv("OPENCLAW_FORWARD_EXCLUDE");
+const DEFAULT_SIGNAL_TERMS = [
+  "approval",
+  "approve",
+  "blocked",
+  "error",
+  "failed",
+  "failure",
+  "complete",
+  "completed",
+  "deploy",
+  "security",
+  "credential",
+  "fund",
+  "payment",
+  "risk",
+  "urgent",
+];
+
+function request(path, options = {}) {
+  return fetch(`${API_BASE}${path}`, {
+    headers: { "Content-Type": "application/json" },
+    ...options,
+  }).then(async (res) => {
+    const json = await res.json().catch(() => null);
+    if (!res.ok || !json?.ok) {
+      throw new Error(json?.error?.message || `Request failed (${res.status})`);
+    }
+    return json.data;
+  });
+}
+
+function loadState() {
+  if (!existsSync(STATE_PATH)) {
+    return {
+      seen_ids: [],
+      pushed_at: {},
+    };
+  }
+  try {
+    return JSON.parse(readFileSync(STATE_PATH, "utf8"));
+  } catch {
+    return {
+      seen_ids: [],
+      pushed_at: {},
+    };
+  }
+}
+
+function saveState(state) {
+  mkdirSync(dirname(STATE_PATH), { recursive: true });
+  writeFileSync(STATE_PATH, JSON.stringify(state, null, 2), "utf8");
+}
+
+function trimState(state) {
+  const recentIds = Array.isArray(state.seen_ids) ? state.seen_ids.slice(-500) : [];
+  const pushedEntries = Object.entries(state.pushed_at || {}).slice(-500);
+  state.seen_ids = recentIds;
+  state.pushed_at = Object.fromEntries(pushedEntries);
+}
+
+function shouldWatchTopic(message) {
+  if (!TOPIC_FILTERS.length) return true;
+  return TOPIC_FILTERS.includes(String(message?.topic || "global").toLowerCase());
+}
+
+function scoreRoute(message) {
+  const text = [
+    String(message?.topic || ""),
+    String(message?.display_name || ""),
+    String(message?.body || ""),
+  ].join(" ").toLowerCase();
+
+  if (!text.trim()) return "ignore";
+  if (EXCLUDE_TERMS.some((term) => text.includes(term))) return "ignore";
+
+  if (INCLUDE_TERMS.length && INCLUDE_TERMS.some((term) => text.includes(term))) {
+    return "push_summary";
+  }
+
+  if (DEFAULT_SIGNAL_TERMS.some((term) => text.includes(term))) {
+    return "push_summary";
+  }
+
+  return "ignore";
+}
+
+function summarizeForOwner(message) {
+  const source = `${message.display_name || "Unknown"} · ${message.topic || "global"}`;
+  const body = String(message.body || "").trim();
+  const priority = scoreRoute(message) === "push_summary"
+    ? "Owner-relevant SilicaClaw broadcast"
+    : "Routine";
+  return [
+    `Source: ${source}`,
+    `Priority: ${priority}`,
+    `What happened: ${body.slice(0, 240)}${body.length > 240 ? "..." : ""}`,
+    "Action: Review whether owner follow-up or approval is needed.",
+  ].join("\n");
+}
+
+function dispatchToOwner(route, summary, message) {
+  if (!OWNER_FORWARD_CMD) {
+    console.log("");
+    console.log(`[${route}] ${message.message_id || "-"}`);
+    console.log(summary);
+    return Promise.resolve();
+  }
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(OWNER_FORWARD_CMD, {
+      shell: true,
+      stdio: ["pipe", "inherit", "inherit"],
+      env: process.env,
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`owner dispatch failed (exit=${code ?? "unknown"})`));
+    });
+    child.stdin.write(JSON.stringify({
+      route,
+      summary,
+      message: {
+        message_id: message.message_id || "",
+        display_name: message.display_name || "",
+        topic: message.topic || "global",
+        body: message.body || "",
+        created_at: message.created_at || Date.now(),
+      },
+    }, null, 2));
+    child.stdin.end();
+  });
+}
+
+async function pollOnce(state) {
+  const payload = await request(`/api/openclaw/bridge/messages?limit=${LIMIT}`);
+  const items = Array.isArray(payload?.items) ? payload.items.slice().reverse() : [];
+
+  for (const item of items) {
+    const messageId = String(item?.message_id || "").trim();
+    if (!messageId) continue;
+    if (state.seen_ids.includes(messageId)) continue;
+
+    state.seen_ids.push(messageId);
+
+    if (!shouldWatchTopic(item)) {
+      if (VERBOSE) console.log(`skip topic: ${messageId}`);
+      continue;
+    }
+
+    const route = scoreRoute(item);
+    if (route === "ignore") {
+      if (VERBOSE) console.log(`ignore low-signal: ${messageId}`);
+      continue;
+    }
+
+    const summary = summarizeForOwner(item);
+    await dispatchToOwner(route, summary, item);
+    state.pushed_at[messageId] = new Date().toISOString();
+    if (VERBOSE) console.log(`pushed to owner: ${messageId}`);
+  }
+
+  trimState(state);
+  saveState(state);
+}
+
+async function main() {
+  const state = loadState();
+  if (VERBOSE) {
+    console.log(`SilicaClaw owner push watching ${API_BASE}`);
+    console.log(`State file: ${STATE_PATH}`);
+  }
+
+  do {
+    await pollOnce(state);
+    if (ONCE) break;
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  } while (true);
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/openclaw-skills/silicaclaw-owner-push/scripts/send-to-owner-via-openclaw.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+import { readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { resolve } from "node:path";
+
+function requiredEnv(name) {
+  const value = String(process.env[name] || "").trim();
+  if (!value) {
+    throw new Error(`Missing required environment variable: ${name}`);
+  }
+  return value;
+}
+
+function resolveOpenClawCommand() {
+  const explicitBin = String(process.env.OPENCLAW_BIN || "").trim();
+  if (explicitBin) {
+    return { cmd: explicitBin, args: [] };
+  }
+
+  const sourceDir = String(process.env.OPENCLAW_SOURCE_DIR || "").trim();
+  if (sourceDir) {
+    return {
+      cmd: "node",
+      args: [resolve(sourceDir, "openclaw.mjs")],
+    };
+  }
+
+  return { cmd: "openclaw", args: [] };
+}
+
+function main() {
+  const payload = JSON.parse(readFileSync(0, "utf8"));
+  const channel = requiredEnv("OPENCLAW_OWNER_CHANNEL");
+  const target = requiredEnv("OPENCLAW_OWNER_TARGET");
+  const account = String(process.env.OPENCLAW_OWNER_ACCOUNT || "").trim();
+  const message = String(payload?.summary || "").trim();
+  if (!message) {
+    throw new Error("Missing summary in stdin payload");
+  }
+
+  const command = resolveOpenClawCommand();
+  const args = [
+    ...command.args,
+    "message",
+    "send",
+    "--channel",
+    channel,
+    "--target",
+    target,
+    "--message",
+    message,
+  ];
+  if (account) {
+    args.push("--account", account);
+  }
+
+  const result = spawnSync(command.cmd, args, {
+    stdio: "inherit",
+    env: process.env,
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+  process.exit(result.status ?? 1);
+}
+
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@silicaclaw/cli",
-  "version": "2026.3.19-15",
+  "version": "2026.3.19-16",
   "private": false,
   "publishConfig": {
     "access": "public"

package/packages/core/dist/config/silicaclaw-defaults.json

@@ -0,0 +1,19 @@
+{
+    "ports": {
+        "local_console": 4310,
+        "public_explorer": 4311,
+        "openclaw_gateway": 18789,
+        "network_default": 44123
+    },
+    "network": {
+        "default_mode": "global-preview",
+        "default_namespace": "silicaclaw.preview",
+        "global_preview": {
+            "relay_url": "https://relay.silicaclaw.com",
+            "room": "silicaclaw-global-preview"
+        }
+    },
+    "bridge": {
+        "api_base": "http://localhost:4310"
+    }
+}

package/packages/core/dist/packages/core/src/crypto.d.ts

@@ -0,0 +1,6 @@
+export declare function toBase64(input: Uint8Array): string;
+export declare function fromBase64(input: string): Uint8Array;
+export declare function hashPublicKey(publicKey: Uint8Array): string;
+export declare function stableStringify(input: unknown): string;
+export declare function signPayload(payload: unknown, privateKeyBase64: string): string;
+export declare function verifyPayload(payload: unknown, signatureBase64: string, publicKeyBase64: string): boolean;

package/packages/core/dist/packages/core/src/crypto.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBase64 = toBase64;
+exports.fromBase64 = fromBase64;
+exports.hashPublicKey = hashPublicKey;
+exports.stableStringify = stableStringify;
+exports.signPayload = signPayload;
+exports.verifyPayload = verifyPayload;
+const crypto_1 = require("crypto");
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+function toBase64(input) {
+    return Buffer.from(input).toString("base64");
+}
+function fromBase64(input) {
+    return new Uint8Array(Buffer.from(input, "base64"));
+}
+function hashPublicKey(publicKey) {
+    return (0, crypto_1.createHash)("sha256").update(publicKey).digest("hex");
+}
+function stableStringify(input) {
+    if (input === null || typeof input !== "object") {
+        return JSON.stringify(input);
+    }
+    if (Array.isArray(input)) {
+        return `[${input.map((item) => stableStringify(item)).join(",")}]`;
+    }
+    const entries = Object.entries(input)
+        .filter(([, value]) => value !== undefined)
+        .sort(([a], [b]) => a.localeCompare(b));
+    return `{${entries
+        .map(([key, value]) => `${JSON.stringify(key)}:${stableStringify(value)}`)
+        .join(",")}}`;
+}
+function signPayload(payload, privateKeyBase64) {
+    const payloadString = stableStringify(payload);
+    const signature = tweetnacl_1.default.sign.detached(Buffer.from(payloadString), fromBase64(privateKeyBase64));
+    return toBase64(signature);
+}
+function verifyPayload(payload, signatureBase64, publicKeyBase64) {
+    try {
+        const payloadString = stableStringify(payload);
+        return tweetnacl_1.default.sign.detached.verify(Buffer.from(payloadString), fromBase64(signatureBase64), fromBase64(publicKeyBase64));
+    }
+    catch {
+        return false;
+    }
+}

package/packages/core/dist/packages/core/src/directory.d.ts

@@ -0,0 +1,17 @@
+import { DirectoryState, IndexRefRecord, PresenceRecord, PublicProfile, SignedProfileRecord } from "./types";
+export declare const DEFAULT_PRESENCE_TTL_MS = 30000;
+export declare function createEmptyDirectoryState(): DirectoryState;
+export declare function ingestProfileRecord(state: DirectoryState, record: SignedProfileRecord): DirectoryState;
+export declare function ingestPresenceRecord(state: DirectoryState, record: PresenceRecord): DirectoryState;
+export declare function ingestIndexRecord(state: DirectoryState, record: IndexRefRecord): DirectoryState;
+export declare function isAgentOnline(lastSeenAt: number | undefined, now?: number, ttlMs?: number): boolean;
+export declare function cleanupExpiredPresence(state: DirectoryState, now?: number, ttlMs?: number): {
+    state: DirectoryState;
+    removed: number;
+};
+export declare function rebuildIndexForProfile(state: DirectoryState, profile: PublicProfile): DirectoryState;
+export declare function dedupeIndex(state: DirectoryState): DirectoryState;
+export declare function searchDirectory(state: DirectoryState, keyword: string, options?: {
+    now?: number;
+    presenceTTLms?: number;
+}): PublicProfile[];

package/packages/core/dist/packages/core/src/directory.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PRESENCE_TTL_MS = void 0;
+exports.createEmptyDirectoryState = createEmptyDirectoryState;
+exports.ingestProfileRecord = ingestProfileRecord;
+exports.ingestPresenceRecord = ingestPresenceRecord;
+exports.ingestIndexRecord = ingestIndexRecord;
+exports.isAgentOnline = isAgentOnline;
+exports.cleanupExpiredPresence = cleanupExpiredPresence;
+exports.rebuildIndexForProfile = rebuildIndexForProfile;
+exports.dedupeIndex = dedupeIndex;
+exports.searchDirectory = searchDirectory;
+const indexing_1 = require("./indexing");
+exports.DEFAULT_PRESENCE_TTL_MS = 30_000;
+function createEmptyDirectoryState() {
+    return {
+        profiles: {},
+        presence: {},
+        index: {},
+    };
+}
+function ingestProfileRecord(state, record) {
+    const next = {
+        profiles: { ...state.profiles },
+        presence: { ...state.presence },
+        index: { ...state.index },
+    };
+    next.profiles[record.profile.agent_id] = record.profile;
+    return rebuildIndexForProfile(next, record.profile);
+}
+function ingestPresenceRecord(state, record) {
+    return {
+        profiles: { ...state.profiles },
+        presence: {
+            ...state.presence,
+            [record.agent_id]: record.timestamp,
+        },
+        index: { ...state.index },
+    };
+}
+function ingestIndexRecord(state, record) {
+    const existing = new Set(state.index[record.key] ?? []);
+    if (existing.has(record.agent_id)) {
+        return state;
+    }
+    existing.add(record.agent_id);
+    return {
+        profiles: { ...state.profiles },
+        presence: { ...state.presence },
+        index: {
+            ...state.index,
+            [record.key]: Array.from(existing),
+        },
+    };
+}
+function isAgentOnline(lastSeenAt, now = Date.now(), ttlMs = exports.DEFAULT_PRESENCE_TTL_MS) {
+    if (!lastSeenAt) {
+        return false;
+    }
+    return now - lastSeenAt <= ttlMs;
+}
+function cleanupExpiredPresence(state, now = Date.now(), ttlMs = exports.DEFAULT_PRESENCE_TTL_MS) {
+    let removed = 0;
+    const presence = {};
+    for (const [agentId, timestamp] of Object.entries(state.presence)) {
+        if (isAgentOnline(timestamp, now, ttlMs)) {
+            presence[agentId] = timestamp;
+        }
+        else {
+            removed += 1;
+        }
+    }
+    if (removed === 0) {
+        return { state, removed: 0 };
+    }
+    return {
+        state: {
+            profiles: { ...state.profiles },
+            presence,
+            index: { ...state.index },
+        },
+        removed,
+    };
+}
+function rebuildIndexForProfile(state, profile) {
+    const keys = (0, indexing_1.buildIndexKeys)(profile);
+    const nextIndex = {};
+    for (const [key, ids] of Object.entries(state.index)) {
+        const filtered = ids.filter((id) => id !== profile.agent_id);
+        if (filtered.length > 0) {
+            nextIndex[key] = Array.from(new Set(filtered));
+        }
+    }
+    for (const key of keys) {
+        const existing = new Set(nextIndex[key] ?? []);
+        existing.add(profile.agent_id);
+        nextIndex[key] = Array.from(existing);
+    }
+    return {
+        profiles: { ...state.profiles },
+        presence: { ...state.presence },
+        index: nextIndex,
+    };
+}
+function dedupeIndex(state) {
+    const index = {};
+    for (const [key, ids] of Object.entries(state.index)) {
+        index[key] = Array.from(new Set(ids));
+    }
+    return {
+        profiles: { ...state.profiles },
+        presence: { ...state.presence },
+        index,
+    };
+}
+function searchDirectory(state, keyword, options) {
+    const now = options?.now ?? Date.now();
+    const presenceTTLms = options?.presenceTTLms ?? exports.DEFAULT_PRESENCE_TTL_MS;
+    const normalized = keyword.trim().toLowerCase();
+    const baseList = normalized.length === 0
+        ? Object.values(state.profiles)
+        : Array.from(new Set([
+            ...(state.index[`tag:${normalized}`] ?? []),
+            ...(state.index[`name:${normalized.replace(/[^a-z0-9]+/g, "")}`] ?? []),
+        ]))
+            .map((agentId) => state.profiles[agentId])
+            .filter((profile) => Boolean(profile));
+    return baseList
+        .slice()
+        .sort((a, b) => {
+        const aOnline = isAgentOnline(state.presence[a.agent_id], now, presenceTTLms) ? 1 : 0;
+        const bOnline = isAgentOnline(state.presence[b.agent_id], now, presenceTTLms) ? 1 : 0;
+        if (aOnline !== bOnline) {
+            return bOnline - aOnline;
+        }
+        if (a.updated_at !== b.updated_at) {
+            return b.updated_at - a.updated_at;
+        }
+        const byName = a.display_name.localeCompare(b.display_name);
+        if (byName !== 0) {
+            return byName;
+        }
+        return a.agent_id.localeCompare(b.agent_id);
+    });
+}

package/packages/core/dist/packages/core/src/identity.d.ts

@@ -0,0 +1,2 @@
+import { AgentIdentity } from "./types";
+export declare function createIdentity(now?: number): AgentIdentity;

package/packages/core/dist/packages/core/src/identity.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIdentity = createIdentity;
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const crypto_1 = require("./crypto");
+function createIdentity(now = Date.now()) {
+    const pair = tweetnacl_1.default.sign.keyPair();
+    const publicKey = (0, crypto_1.toBase64)(pair.publicKey);
+    return {
+        agent_id: (0, crypto_1.hashPublicKey)(pair.publicKey),
+        public_key: publicKey,
+        private_key: (0, crypto_1.toBase64)(pair.secretKey),
+        created_at: now,
+    };
+}

package/packages/core/dist/packages/core/src/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./types";
+export * from "./crypto";
+export * from "./identity";
+export * from "./profile";
+export * from "./presence";
+export * from "./socialMessage";
+export * from "./indexing";
+export * from "./directory";
+export * from "./publicProfileSummary";
+export * from "./socialConfig";
+export * from "./socialResolver";
+export * from "./socialTemplate";

package/packages/core/dist/packages/core/src/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./crypto"), exports);
+__exportStar(require("./identity"), exports);
+__exportStar(require("./profile"), exports);
+__exportStar(require("./presence"), exports);
+__exportStar(require("./socialMessage"), exports);
+__exportStar(require("./indexing"), exports);
+__exportStar(require("./directory"), exports);
+__exportStar(require("./publicProfileSummary"), exports);
+__exportStar(require("./socialConfig"), exports);
+__exportStar(require("./socialResolver"), exports);
+__exportStar(require("./socialTemplate"), exports);

package/packages/core/dist/packages/core/src/indexing.d.ts

@@ -0,0 +1,6 @@
+import { IndexRefRecord, PublicProfile } from "./types";
+export declare function normalizeTag(tag: string): string;
+export declare function buildTagIndexKeys(tags: string[]): string[];
+export declare function buildNamePrefixKeys(displayName: string): string[];
+export declare function buildIndexKeys(profile: PublicProfile): string[];
+export declare function buildIndexRecords(profile: PublicProfile): IndexRefRecord[];

package/packages/core/dist/packages/core/src/indexing.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeTag = normalizeTag;
+exports.buildTagIndexKeys = buildTagIndexKeys;
+exports.buildNamePrefixKeys = buildNamePrefixKeys;
+exports.buildIndexKeys = buildIndexKeys;
+exports.buildIndexRecords = buildIndexRecords;
+function normalizeTag(tag) {
+    return tag.trim().toLowerCase();
+}
+function buildTagIndexKeys(tags) {
+    return tags
+        .map(normalizeTag)
+        .filter(Boolean)
+        .map((tag) => `tag:${tag}`);
+}
+function buildNamePrefixKeys(displayName) {
+    const normalized = displayName.trim().toLowerCase().replace(/\s+/g, " ");
+    const collapsed = normalized.replace(/[^a-z0-9]+/g, "");
+    const source = collapsed || normalized.replace(/\s+/g, "");
+    const keys = [];
+    for (let i = 1; i <= source.length; i += 1) {
+        keys.push(`name:${source.slice(0, i)}`);
+    }
+    return keys;
+}
+function buildIndexKeys(profile) {
+    const keys = new Set();
+    for (const key of buildTagIndexKeys(profile.tags)) {
+        keys.add(key);
+    }
+    for (const key of buildNamePrefixKeys(profile.display_name)) {
+        keys.add(key);
+    }
+    return Array.from(keys);
+}
+function buildIndexRecords(profile) {
+    return buildIndexKeys(profile).map((key) => ({
+        type: "index",
+        key,
+        agent_id: profile.agent_id,
+    }));
+}

package/packages/core/dist/packages/core/src/presence.d.ts

@@ -0,0 +1,4 @@
+import { AgentIdentity } from "./types";
+import { PresenceRecord } from "./types";
+export declare function signPresence(identity: AgentIdentity, timestamp?: number): PresenceRecord;
+export declare function verifyPresence(record: PresenceRecord, publicKey: string): boolean;

package/packages/core/dist/packages/core/src/presence.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signPresence = signPresence;
+exports.verifyPresence = verifyPresence;
+const crypto_1 = require("./crypto");
+function unsignedPresence(record) {
+    const { signature: _signature, ...rest } = record;
+    return rest;
+}
+function signPresence(identity, timestamp = Date.now()) {
+    const payload = {
+        type: "presence",
+        agent_id: identity.agent_id,
+        timestamp,
+    };
+    return {
+        ...payload,
+        signature: (0, crypto_1.signPayload)(payload, identity.private_key),
+    };
+}
+function verifyPresence(record, publicKey) {
+    return (0, crypto_1.verifyPayload)(unsignedPresence(record), record.signature, publicKey);
+}