@silicaclaw/cli 2026.3.19-2 → 2026.3.19-21

package/node_modules/@silicaclaw/core/dist/socialResolver.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSocialConfigSearchPaths = getSocialConfigSearchPaths;
+exports.findSocialMd = findSocialMd;
+exports.loadSocialConfig = loadSocialConfig;
+exports.findOpenClawIdentity = findOpenClawIdentity;
+exports.findOpenClawProfile = findOpenClawProfile;
+exports.resolveIdentityWithSocial = resolveIdentityWithSocial;
+exports.resolveProfileInputWithSocial = resolveProfileInputWithSocial;
+exports.ensureDefaultSocialMd = ensureDefaultSocialMd;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const crypto_1 = require("./crypto");
+const socialConfig_1 = require("./socialConfig");
+function getSocialConfigSearchPaths(rootDir = process.cwd(), homeDir = (0, os_1.homedir)()) {
+    return [
+        (0, path_1.resolve)(rootDir, "social.md"),
+        (0, path_1.resolve)(rootDir, ".openclaw", "social.md"),
+        (0, path_1.resolve)(homeDir, ".openclaw", "social.md"),
+    ];
+}
+function findSocialMd(rootDir = process.cwd()) {
+    const candidates = getSocialConfigSearchPaths(rootDir);
+    for (const path of candidates) {
+        if (!(0, fs_1.existsSync)(path))
+            continue;
+        return {
+            found: true,
+            source_path: path,
+            content: (0, fs_1.readFileSync)(path, "utf8"),
+        };
+    }
+    return {
+        found: false,
+        source_path: null,
+        content: null,
+    };
+}
+function loadSocialConfig(rootDir = process.cwd()) {
+    const lookup = findSocialMd(rootDir);
+    if (!lookup.found || !lookup.content || !lookup.source_path) {
+        return {
+            config: (0, socialConfig_1.normalizeSocialConfig)({}),
+            meta: {
+                found: false,
+                source_path: null,
+                parse_error: null,
+                loaded_at: Date.now(),
+            },
+            raw_frontmatter: null,
+        };
+    }
+    try {
+        const frontmatter = (0, socialConfig_1.extractFrontmatter)(lookup.content);
+        if (!frontmatter) {
+            return {
+                config: (0, socialConfig_1.normalizeSocialConfig)({}),
+                meta: {
+                    found: true,
+                    source_path: lookup.source_path,
+                    parse_error: "frontmatter_not_found",
+                    loaded_at: Date.now(),
+                },
+                raw_frontmatter: null,
+            };
+        }
+        const parsed = (0, socialConfig_1.parseFrontmatterObject)(frontmatter);
+        return {
+            config: (0, socialConfig_1.normalizeSocialConfig)(parsed),
+            meta: {
+                found: true,
+                source_path: lookup.source_path,
+                parse_error: null,
+                loaded_at: Date.now(),
+            },
+            raw_frontmatter: parsed,
+        };
+    }
+    catch (error) {
+        return {
+            config: (0, socialConfig_1.normalizeSocialConfig)({}),
+            meta: {
+                found: true,
+                source_path: lookup.source_path,
+                parse_error: error instanceof Error ? error.message : "social_parse_failed",
+                loaded_at: Date.now(),
+            },
+            raw_frontmatter: null,
+        };
+    }
+}
+function readJson(path) {
+    if (!(0, fs_1.existsSync)(path))
+        return null;
+    try {
+        return JSON.parse((0, fs_1.readFileSync)(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeIdentity(input) {
+    if (typeof input !== "object" || input === null) {
+        return null;
+    }
+    const value = input;
+    if (typeof value.public_key !== "string" || typeof value.private_key !== "string") {
+        return null;
+    }
+    let agentId = typeof value.agent_id === "string" ? value.agent_id : "";
+    if (!agentId) {
+        try {
+            agentId = (0, crypto_1.hashPublicKey)((0, crypto_1.fromBase64)(value.public_key));
+        }
+        catch {
+            return null;
+        }
+    }
+    return {
+        agent_id: agentId,
+        public_key: value.public_key,
+        private_key: value.private_key,
+        created_at: Number.isFinite(value.created_at) ? Number(value.created_at) : Date.now(),
+    };
+}
+function findOpenClawIdentity(rootDir = process.cwd(), homeDir = (0, os_1.homedir)()) {
+    const candidates = [
+        (0, path_1.resolve)(rootDir, ".openclaw", "identity.json"),
+        (0, path_1.resolve)(rootDir, "identity.json"),
+        (0, path_1.resolve)(homeDir, ".openclaw", "identity.json"),
+    ];
+    for (const path of candidates) {
+        const parsed = readJson(path);
+        const identity = normalizeIdentity(parsed);
+        if (identity) {
+            return {
+                identity,
+                source_path: path,
+            };
+        }
+    }
+    return {
+        identity: null,
+        source_path: null,
+    };
+}
+function findOpenClawProfile(rootDir = process.cwd(), homeDir = (0, os_1.homedir)()) {
+    const candidates = [
+        (0, path_1.resolve)(rootDir, ".openclaw", "profile.json"),
+        (0, path_1.resolve)(rootDir, "profile.json"),
+        (0, path_1.resolve)(homeDir, ".openclaw", "profile.json"),
+    ];
+    for (const path of candidates) {
+        const parsed = readJson(path);
+        if (typeof parsed !== "object" || parsed === null)
+            continue;
+        const profile = parsed;
+        return {
+            source_path: path,
+            profile: {
+                display_name: typeof profile.display_name === "string" ? profile.display_name : "",
+                bio: typeof profile.bio === "string" ? profile.bio : "",
+                avatar_url: typeof profile.avatar_url === "string" ? profile.avatar_url : "",
+                tags: Array.isArray(profile.tags)
+                    ? profile.tags.map((tag) => String(tag).trim()).filter(Boolean)
+                    : [],
+            },
+        };
+    }
+    return {
+        profile: null,
+        source_path: null,
+    };
+}
+function resolveIdentityWithSocial(args) {
+    const { socialConfig, existingIdentity, generatedIdentity } = args;
+    if (socialConfig.openclaw.bind_existing_identity) {
+        const openclaw = findOpenClawIdentity(args.rootDir ?? process.cwd());
+        if (openclaw.identity) {
+            return {
+                identity: openclaw.identity,
+                source: "openclaw-existing",
+                openclaw_source_path: openclaw.source_path,
+            };
+        }
+    }
+    if (existingIdentity) {
+        return {
+            identity: existingIdentity,
+            source: "silicaclaw-existing",
+            openclaw_source_path: null,
+        };
+    }
+    return {
+        identity: generatedIdentity,
+        source: "silicaclaw-generated",
+        openclaw_source_path: null,
+    };
+}
+function resolveProfileInputWithSocial(args) {
+    const { socialConfig, agentId, existingProfile } = args;
+    const openclawProfile = socialConfig.openclaw.use_openclaw_profile_if_available
+        ? findOpenClawProfile(args.rootDir ?? process.cwd()).profile
+        : null;
+    const baseDisplayName = existingProfile?.display_name || "";
+    const baseBio = existingProfile?.bio || "";
+    const baseAvatarUrl = existingProfile?.avatar_url || "";
+    const baseTags = existingProfile?.tags || [];
+    // Preserve values saved from local-console first; only fall back to social/openclaw defaults
+    // when local profile fields are empty.
+    const displayName = baseDisplayName || socialConfig.identity.display_name || openclawProfile?.display_name || "";
+    const bio = baseBio || socialConfig.identity.bio || openclawProfile?.bio || "";
+    const avatarUrl = baseAvatarUrl || socialConfig.identity.avatar_url || openclawProfile?.avatar_url || "";
+    const tags = baseTags.length > 0
+        ? baseTags
+        : socialConfig.identity.tags.length > 0
+            ? socialConfig.identity.tags
+            : openclawProfile?.tags || [];
+    return {
+        agent_id: agentId,
+        display_name: displayName,
+        bio,
+        avatar_url: avatarUrl,
+        tags,
+        public_enabled: existingProfile?.public_enabled ?? socialConfig.public_enabled,
+    };
+}
+function ensureDefaultSocialMd(rootDir = process.cwd(), options = {}) {
+    const targetPath = (0, path_1.resolve)(rootDir, "social.md");
+    if ((0, fs_1.existsSync)(targetPath)) {
+        return { path: targetPath, created: false };
+    }
+    (0, fs_1.mkdirSync)(rootDir, { recursive: true });
+    (0, fs_1.writeFileSync)(targetPath, (0, socialConfig_1.generateDefaultSocialMdTemplate)(options), "utf8");
+    return { path: targetPath, created: true };
+}

package/node_modules/@silicaclaw/core/dist/socialTemplate.d.ts

@@ -0,0 +1,2 @@
+import { SocialRuntimeConfig } from "./socialConfig";
+export declare function generateSocialMdTemplate(runtimeConfig: SocialRuntimeConfig | null | undefined): string;

package/node_modules/@silicaclaw/core/dist/socialTemplate.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSocialMdTemplate = generateSocialMdTemplate;
+function asBool(value, fallback) {
+    return typeof value === "boolean" ? value : fallback;
+}
+function asString(value, fallback) {
+    return typeof value === "string" ? value : fallback;
+}
+function asStringArray(value, fallback) {
+    if (!Array.isArray(value))
+        return fallback;
+    return value.map((item) => String(item).trim()).filter(Boolean);
+}
+function yamlString(input) {
+    return JSON.stringify(input ?? "");
+}
+function yamlStringList(values, indent = "  ") {
+    if (!values.length) {
+        return `${indent}[]`;
+    }
+    return values.map((value) => `${indent}- ${yamlString(value)}`).join("\n");
+}
+function generateSocialMdTemplate(runtimeConfig) {
+    const enabled = asBool(runtimeConfig?.enabled, true);
+    const publicEnabled = asBool(runtimeConfig?.public_enabled, false);
+    const profile = runtimeConfig?.resolved_profile ?? null;
+    const network = runtimeConfig?.resolved_network ?? null;
+    const discovery = runtimeConfig?.resolved_discovery ?? null;
+    const visibility = runtimeConfig?.visibility ?? null;
+    const openclaw = runtimeConfig?.openclaw ?? null;
+    const displayName = asString(profile?.display_name, "");
+    const bio = asString(profile?.bio, "");
+    const tags = asStringArray(profile?.tags, ["openclaw", "local-first"]);
+    const mode = network?.mode === "local" || network?.mode === "lan" || network?.mode === "global-preview"
+        ? network.mode
+        : "global-preview";
+    const discoverable = asBool(discovery?.discoverable, true);
+    const allowProfileBroadcast = asBool(discovery?.allow_profile_broadcast, true);
+    const allowPresenceBroadcast = asBool(discovery?.allow_presence_broadcast, true);
+    const allowMessageBroadcast = asBool(discovery?.allow_message_broadcast, true);
+    const showDisplayName = asBool(visibility?.show_display_name, true);
+    const showBio = asBool(visibility?.show_bio, true);
+    const showTags = asBool(visibility?.show_tags, true);
+    const showAgentId = asBool(visibility?.show_agent_id, true);
+    const showLastSeen = asBool(visibility?.show_last_seen, true);
+    const showCapabilitiesSummary = asBool(visibility?.show_capabilities_summary, true);
+    const bindExistingIdentity = asBool(openclaw?.bind_existing_identity, true);
+    const useOpenClawProfile = asBool(openclaw?.use_openclaw_profile_if_available, true);
+    return `---
+enabled: ${enabled}
+public_enabled: ${publicEnabled}
+
+identity:
+  display_name: ${yamlString(displayName)}
+  bio: ${yamlString(bio)}
+  tags:
+${yamlStringList(tags.map((tag) => asString(tag, "")), "    ")}
+
+network:
+  mode: ${yamlString(mode)}
+
+discovery:
+  discoverable: ${discoverable}
+  allow_profile_broadcast: ${allowProfileBroadcast}
+  allow_presence_broadcast: ${allowPresenceBroadcast}
+  allow_message_broadcast: ${allowMessageBroadcast}
+
+visibility:
+  show_display_name: ${showDisplayName}
+  show_bio: ${showBio}
+  show_tags: ${showTags}
+  show_agent_id: ${showAgentId}
+  show_last_seen: ${showLastSeen}
+  show_capabilities_summary: ${showCapabilitiesSummary}
+
+openclaw:
+  bind_existing_identity: ${bindExistingIdentity}
+  use_openclaw_profile_if_available: ${useOpenClawProfile}
+---
+
+# Social
+
+Generated from current SilicaClaw runtime state.
+
+- Save as \`social.md\` in your OpenClaw workspace.
+- This export does not auto-overwrite any existing file.
+- Advanced network fields are intentionally hidden in template and resolved in runtime.
+`;
+}

package/node_modules/@silicaclaw/core/dist/types.d.ts

@@ -0,0 +1,59 @@
+export type AgentIdentity = {
+    agent_id: string;
+    public_key: string;
+    private_key: string;
+    created_at: number;
+};
+export type PublicProfile = {
+    agent_id: string;
+    display_name: string;
+    bio: string;
+    tags: string[];
+    avatar_url?: string;
+    public_enabled: boolean;
+    updated_at: number;
+    signature: string;
+};
+export type SignedProfileRecord = {
+    type: "profile";
+    profile: PublicProfile;
+};
+export type PresenceRecord = {
+    type: "presence";
+    agent_id: string;
+    timestamp: number;
+    signature: string;
+};
+export type IndexRefRecord = {
+    type: "index";
+    key: string;
+    agent_id: string;
+};
+export type SocialMessageRecord = {
+    type: "social.message";
+    message_id: string;
+    agent_id: string;
+    public_key: string;
+    display_name: string;
+    topic: string;
+    body: string;
+    created_at: number;
+    signature: string;
+};
+export type SocialMessageObservationRecord = {
+    type: "social.message.observation";
+    observation_id: string;
+    message_id: string;
+    observed_agent_id: string;
+    observer_agent_id: string;
+    observer_public_key: string;
+    observer_display_name: string;
+    observed_at: number;
+    signature: string;
+};
+export type DirectoryState = {
+    profiles: Record<string, PublicProfile>;
+    presence: Record<string, number>;
+    index: Record<string, string[]>;
+};
+export type ProfileInput = Omit<PublicProfile, "signature" | "updated_at">;

package/node_modules/@silicaclaw/core/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/@silicaclaw/core/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@silicaclaw/core",
+  "version": "0.1.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "tweetnacl": "^1.0.3"
+  }
+}

package/node_modules/@silicaclaw/core/src/crypto.ts

@@ -0,0 +1,55 @@
+import { createHash } from "crypto";
+import nacl from "tweetnacl";
+
+export function toBase64(input: Uint8Array): string {
+  return Buffer.from(input).toString("base64");
+}
+
+export function fromBase64(input: string): Uint8Array {
+  return new Uint8Array(Buffer.from(input, "base64"));
+}
+
+export function hashPublicKey(publicKey: Uint8Array): string {
+  return createHash("sha256").update(publicKey).digest("hex");
+}
+
+export function stableStringify(input: unknown): string {
+  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 as Record<string, unknown>)
+    .filter(([, value]) => value !== undefined)
+    .sort(([a], [b]) => a.localeCompare(b));
+  return `{${entries
+    .map(([key, value]) => `${JSON.stringify(key)}:${stableStringify(value)}`)
+    .join(",")}}`;
+}
+
+export function signPayload(payload: unknown, privateKeyBase64: string): string {
+  const payloadString = stableStringify(payload);
+  const signature = nacl.sign.detached(
+    Buffer.from(payloadString),
+    fromBase64(privateKeyBase64)
+  );
+  return toBase64(signature);
+}
+
+export function verifyPayload(
+  payload: unknown,
+  signatureBase64: string,
+  publicKeyBase64: string
+): boolean {
+  try {
+    const payloadString = stableStringify(payload);
+    return nacl.sign.detached.verify(
+      Buffer.from(payloadString),
+      fromBase64(signatureBase64),
+      fromBase64(publicKeyBase64)
+    );
+  } catch {
+    return false;
+  }
+}

package/node_modules/@silicaclaw/core/src/directory.ts

@@ -0,0 +1,171 @@
+import {
+  DirectoryState,
+  IndexRefRecord,
+  PresenceRecord,
+  PublicProfile,
+  SignedProfileRecord,
+} from "./types";
+import { buildIndexKeys } from "./indexing";
+
+export const DEFAULT_PRESENCE_TTL_MS = 30_000;
+
+export function createEmptyDirectoryState(): DirectoryState {
+  return {
+    profiles: {},
+    presence: {},
+    index: {},
+  };
+}
+
+export function ingestProfileRecord(state: DirectoryState, record: SignedProfileRecord): DirectoryState {
+  const next: DirectoryState = {
+    profiles: { ...state.profiles },
+    presence: { ...state.presence },
+    index: { ...state.index },
+  };
+  next.profiles[record.profile.agent_id] = record.profile;
+  return rebuildIndexForProfile(next, record.profile);
+}
+
+export function ingestPresenceRecord(state: DirectoryState, record: PresenceRecord): DirectoryState {
+  return {
+    profiles: { ...state.profiles },
+    presence: {
+      ...state.presence,
+      [record.agent_id]: record.timestamp,
+    },
+    index: { ...state.index },
+  };
+}
+
+export function ingestIndexRecord(state: DirectoryState, record: IndexRefRecord): DirectoryState {
+  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),
+    },
+  };
+}
+
+export function isAgentOnline(
+  lastSeenAt: number | undefined,
+  now = Date.now(),
+  ttlMs = DEFAULT_PRESENCE_TTL_MS
+): boolean {
+  if (!lastSeenAt) {
+    return false;
+  }
+  return now - lastSeenAt <= ttlMs;
+}
+
+export function cleanupExpiredPresence(
+  state: DirectoryState,
+  now = Date.now(),
+  ttlMs = DEFAULT_PRESENCE_TTL_MS
+): { state: DirectoryState; removed: number } {
+  let removed = 0;
+  const presence: Record<string, number> = {};
+
+  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,
+  };
+}
+
+export function rebuildIndexForProfile(state: DirectoryState, profile: PublicProfile): DirectoryState {
+  const keys = buildIndexKeys(profile);
+  const nextIndex: Record<string, string[]> = {};
+
+  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,
+  };
+}
+
+export function dedupeIndex(state: DirectoryState): DirectoryState {
+  const index: Record<string, string[]> = {};
+  for (const [key, ids] of Object.entries(state.index)) {
+    index[key] = Array.from(new Set(ids));
+  }
+  return {
+    profiles: { ...state.profiles },
+    presence: { ...state.presence },
+    index,
+  };
+}
+
+export function searchDirectory(
+  state: DirectoryState,
+  keyword: string,
+  options?: { now?: number; presenceTTLms?: number }
+): PublicProfile[] {
+  const now = options?.now ?? Date.now();
+  const presenceTTLms = options?.presenceTTLms ?? DEFAULT_PRESENCE_TTL_MS;
+  const normalized = keyword.trim().toLowerCase();
+  const baseList =
+    normalized.length === 0
+      ? Object.values(state.profiles)
+      : Array.from(
+          new Set<string>([
+            ...(state.index[`tag:${normalized}`] ?? []),
+            ...(state.index[`name:${normalized.replace(/[^a-z0-9]+/g, "")}`] ?? []),
+          ])
+        )
+          .map((agentId) => state.profiles[agentId])
+          .filter((profile): profile is PublicProfile => 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/node_modules/@silicaclaw/core/src/identity.ts

@@ -0,0 +1,14 @@
+import nacl from "tweetnacl";
+import { hashPublicKey, toBase64 } from "./crypto";
+import { AgentIdentity } from "./types";
+
+export function createIdentity(now = Date.now()): AgentIdentity {
+  const pair = nacl.sign.keyPair();
+  const publicKey = toBase64(pair.publicKey);
+  return {
+    agent_id: hashPublicKey(pair.publicKey),
+    public_key: publicKey,
+    private_key: toBase64(pair.secretKey),
+    created_at: now,
+  };
+}

package/node_modules/@silicaclaw/core/src/index.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";