velaclaw-dev 0.2.0

package/members/member-template/runtime/config/local-plugins/shared-asset-injector/index.js

@@ -0,0 +1,548 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+
+let definePluginEntry = (entry) => entry;
+try {
+  const runtimeRequire = createRequire("/app/package.json");
+  ({ definePluginEntry } = runtimeRequire("openclaw/plugin-sdk/plugin-entry"));
+} catch {}
+
+const DEFAULT_WORKSPACE_ROOT = "/home/node/.openclaw/workspace";
+const DEFAULT_STATE_PATH = "/home/node/.openclaw/shared-assets-state.json";
+const DEFAULT_SYNC_TTL_MS = 30000;
+const DEFAULT_RESOLVE_LIMIT_PER_KIND = 2;
+const ASSET_KINDS = ["skills", "memory", "workflows", "docs"];
+
+function asTrimmedString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+async function safeReadJson(filePath, fallback) {
+  try {
+    return JSON.parse(await fs.readFile(filePath, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+async function safeWriteJson(filePath, value) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+function slugify(value) {
+  return String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 80) || "asset";
+}
+
+function wrapSkillDoc(name, description, content) {
+  const trimmed = String(content || "").trim();
+  if (trimmed.startsWith("---")) {
+    return `${trimmed}\n`;
+  }
+  return `---\nname: ${name}\ndescription: ${description}\n---\n\n${trimmed}\n`;
+}
+
+function summarize(content, fallback) {
+  const line = String(content || "")
+    .split("\n")
+    .map((entry) => entry.trim())
+    .find(Boolean);
+  return (line || fallback || "").replace(/^#+\s*/, "").slice(0, 160);
+}
+
+function isCommandOnly(text) {
+  return String(text || "").trim().startsWith("/");
+}
+
+function flattenMessageText(messageLike) {
+  if (!messageLike) {
+    return "";
+  }
+  if (typeof messageLike === "string") {
+    return messageLike.trim();
+  }
+
+  const nestedMessage = flattenMessageText(messageLike.message);
+  if (nestedMessage) {
+    return nestedMessage;
+  }
+
+  const directText = asTrimmedString(messageLike.text || messageLike.body || messageLike.content);
+  if (directText) {
+    return directText;
+  }
+
+  const content = Array.isArray(messageLike.content) ? messageLike.content : [];
+  const parts = content
+    .filter((entry) => entry && entry.type === "text" && typeof entry.text === "string")
+    .map((entry) => entry.text.trim())
+    .filter(Boolean);
+  if (parts.length) {
+    return parts.join("\n");
+  }
+
+  return "";
+}
+
+function extractEventText(event) {
+  const direct = flattenMessageText(event);
+  if (direct) {
+    return direct;
+  }
+
+  const message = flattenMessageText(event?.message);
+  if (message) {
+    return message;
+  }
+
+  const messages = Array.isArray(event?.messages) ? event.messages : [];
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const candidate = messages[index];
+    const role = candidate?.role || candidate?.message?.role;
+    if (role && role !== "user") {
+      continue;
+    }
+    const text = flattenMessageText(candidate);
+    if (text) {
+      return text;
+    }
+  }
+
+  return "";
+}
+
+function selectionHash(manifestHash, query, matches) {
+  return crypto
+    .createHash("sha256")
+    .update(
+      JSON.stringify({
+        manifestHash,
+        query,
+        matches: Object.fromEntries(
+          ASSET_KINDS.map((kind) => [kind, Array.isArray(matches?.[kind]) ? matches[kind].map((item) => item.id) : []])
+        )
+      })
+    )
+    .digest("hex");
+}
+
+async function fetchJson(url, token, init = {}) {
+  const response = await fetch(url, {
+    method: init.method || "GET",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json",
+      ...(init.body ? { "Content-Type": "application/json" } : {}),
+      ...(init.headers || {})
+    },
+    body: init.body,
+    signal: init.signal
+  });
+
+  const text = await response.text();
+  let payload;
+  try {
+    payload = JSON.parse(text);
+  } catch {
+    payload = text;
+  }
+  if (!response.ok) {
+    throw new Error(typeof payload === "string" ? payload : JSON.stringify(payload));
+  }
+  return payload;
+}
+
+async function ensureDir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+
+async function resetPath(dirPath) {
+  await fs.rm(dirPath, { recursive: true, force: true });
+  await ensureDir(dirPath);
+}
+
+function normalizeManifest(manifest) {
+  return {
+    team: manifest?.team || { slug: "unknown", name: "Unknown Team" },
+    generatedAt: manifest?.generatedAt || new Date().toISOString(),
+    manifestHash: String(manifest?.manifestHash || ""),
+    counts: manifest?.counts || {},
+    items: Array.isArray(manifest?.items) ? manifest.items : []
+  };
+}
+
+async function writeCatalog(manifest, workspaceRoot) {
+  const normalized = normalizeManifest(manifest);
+  const catalogRoot = path.join(workspaceRoot, "docs", "team-shared", "catalog");
+  const catalogSkillRoot = path.join(workspaceRoot, "skills", "team-shared-catalog");
+
+  await resetPath(catalogRoot);
+  await resetPath(catalogSkillRoot);
+
+  await safeWriteJson(path.join(catalogRoot, "manifest.json"), normalized);
+
+  const catalogIndexLines = [
+    `# Team Shared Asset Catalog`,
+    ``,
+    `Team: ${normalized.team.name} (${normalized.team.slug})`,
+    `Generated: ${normalized.generatedAt}`,
+    `Published assets: ${normalized.items.length}`,
+    ``
+  ];
+
+  const skillLines = [
+    "---",
+    "name: team-shared-catalog",
+    "description: Browse the shared team asset catalog. Relevant assets for the current task will be materialized into active shared directories.",
+    "---",
+    "",
+    `Team: ${normalized.team.name} (${normalized.team.slug})`,
+    "",
+    "Use this catalog to discover team-shared assets without loading every asset into context.",
+    "Relevant assets for the current task, when selected by the injector, are placed under:",
+    "- /home/node/.openclaw/workspace/skills/team-shared-active-<skill>",
+    "- /home/node/.openclaw/workspace/docs/team-shared/active",
+    "",
+    "Published counts:"
+  ];
+
+  for (const kind of ASSET_KINDS) {
+    const count = Number(normalized.counts?.[kind] || 0);
+    skillLines.push(`- ${kind}: ${count}`);
+  }
+  skillLines.push("");
+
+  for (const kind of ASSET_KINDS) {
+    const items = normalized.items.filter((item) => item.kind === kind);
+    if (!items.length) {
+      continue;
+    }
+    catalogIndexLines.push(`## ${kind}`);
+    skillLines.push(`${kind.toUpperCase()}:`);
+    for (const item of items) {
+      const keywords = Array.isArray(item.keywords) && item.keywords.length ? ` | keywords: ${item.keywords.slice(0, 6).join(", ")}` : "";
+      catalogIndexLines.push(`- ${item.title}: ${item.summary}${keywords}`);
+      skillLines.push(`- ${item.title}: ${item.summary}`);
+    }
+    catalogIndexLines.push("");
+    skillLines.push("");
+  }
+
+  await fs.writeFile(path.join(catalogRoot, "INDEX.md"), `${catalogIndexLines.join("\n")}\n`, "utf8");
+  await fs.writeFile(path.join(catalogSkillRoot, "SKILL.md"), `${skillLines.join("\n")}\n`, "utf8");
+}
+
+async function clearActiveSelection(workspaceRoot) {
+  const skillsRoot = path.join(workspaceRoot, "skills");
+  await ensureDir(skillsRoot);
+  const entries = await fs.readdir(skillsRoot, { withFileTypes: true }).catch(() => []);
+  for (const entry of entries) {
+    if (entry.isDirectory() && entry.name.startsWith("team-shared-active-")) {
+      await fs.rm(path.join(skillsRoot, entry.name), { recursive: true, force: true });
+    }
+  }
+  await resetPath(path.join(workspaceRoot, "docs", "team-shared", "active"));
+}
+
+async function writeBootstrapContext(workspaceRoot, content) {
+  const bootstrapPath = path.join(workspaceRoot, "BOOTSTRAP.md");
+  const text = String(content || "").trim();
+  if (!text) {
+    await fs.rm(bootstrapPath, { force: true });
+    return;
+  }
+  await fs.writeFile(bootstrapPath, `${text}\n`, "utf8");
+}
+
+async function writeActiveSelection(manifest, query, matches, itemsById, workspaceRoot) {
+  const skillsRoot = path.join(workspaceRoot, "skills");
+  const sharedDocsRoot = path.join(workspaceRoot, "docs", "team-shared", "active");
+
+  await clearActiveSelection(workspaceRoot);
+  await ensureDir(skillsRoot);
+
+  const selectionSummary = {
+    team: manifest.team,
+    manifestHash: manifest.manifestHash,
+    query,
+    generatedAt: new Date().toISOString(),
+    matches: Object.fromEntries(
+      ASSET_KINDS.map((kind) => [
+        kind,
+        (matches?.[kind] || []).map((item) => ({
+          id: item.id,
+          title: item.title,
+          score: item.score,
+          matchedTerms: item.matchedTerms
+        }))
+      ])
+    )
+  };
+
+  const overviewLines = [
+    `# Active Team Shared Assets`,
+    ``,
+    `Team: ${manifest.team.name} (${manifest.team.slug})`,
+    `Query: ${query}`,
+    `Generated: ${selectionSummary.generatedAt}`,
+    ``
+  ];
+
+  for (const kind of ASSET_KINDS) {
+    const targetDir = kind === "skills" ? skillsRoot : path.join(sharedDocsRoot, kind);
+    await ensureDir(targetDir);
+    const activeItems = Array.isArray(matches?.[kind]) ? matches[kind] : [];
+    if (!activeItems.length) {
+      continue;
+    }
+
+    overviewLines.push(`## ${kind}`);
+    for (const match of activeItems) {
+      const item = itemsById.get(match.id);
+      if (!item) {
+        continue;
+      }
+      overviewLines.push(`- ${item.title}: ${item.summary}`);
+      if (kind === "skills") {
+        const skillDir = path.join(skillsRoot, `team-shared-active-${slugify(item.title)}`);
+        await ensureDir(skillDir);
+        await fs.writeFile(
+          path.join(skillDir, "SKILL.md"),
+          wrapSkillDoc(slugify(item.title), item.summary || item.title, item.content),
+          "utf8"
+        );
+      } else {
+        await fs.writeFile(path.join(targetDir, item.filename), `${String(item.content || "").trim()}\n`, "utf8");
+      }
+    }
+    overviewLines.push("");
+  }
+
+  await safeWriteJson(path.join(sharedDocsRoot, "selection.json"), selectionSummary);
+  await fs.writeFile(path.join(sharedDocsRoot, "README.md"), `${overviewLines.join("\n")}\n`, "utf8");
+}
+
+function buildPromptAdditionFromSelection(selection, itemsById) {
+  if (!selection?.query) {
+    return "";
+  }
+
+  const lines = [
+    "<team_shared_active_context>",
+    "Use the following shared team context only when it is relevant to the user's current task.",
+    "If a workflow block matches the task, follow its required structure exactly.",
+    "If a memory block contains a team preference, required phrase, or standing rule that matches the task, honor it exactly.",
+    `Current task query: ${selection.query}`,
+    ""
+  ];
+
+  const orderedKinds = ["memory", "workflows", "docs"];
+  for (const kind of orderedKinds) {
+    const items = Array.isArray(selection?.matches?.[kind]) ? selection.matches[kind] : [];
+    if (!items.length) {
+      continue;
+    }
+    lines.push(`${kind.toUpperCase()}:`);
+    for (const match of items) {
+      const item = itemsById.get(match.id);
+      if (!item) {
+        continue;
+      }
+      lines.push(`- ${item.title}: ${item.summary}`);
+      if (Array.isArray(item.capability?.activationHints) && item.capability.activationHints.length) {
+        lines.push(`  Activation: ${item.capability.activationHints.join(" ")}`);
+      }
+      if (kind === "memory" || kind === "workflows") {
+        const excerpt = String(item.content || "").trim().split("\n").slice(0, 24).join("\n");
+        if (excerpt) {
+          lines.push(kind === "memory" ? "  Required memory content:" : "  Required workflow content:");
+          lines.push(...excerpt.split("\n").map((line) => `    ${line}`));
+        }
+      }
+    }
+    lines.push("");
+  }
+
+  if (lines.length <= 3) {
+    return "";
+  }
+  lines.push("</team_shared_active_context>");
+  return `${lines.join("\n").trim()}\n`;
+}
+
+async function ensureManifestSynced(config) {
+  const assetServerBaseUrl = config?.assetServerBaseUrl;
+  const assetServerToken = config?.assetServerToken;
+  if (!assetServerBaseUrl || !assetServerToken) {
+    return null;
+  }
+
+  const workspaceRoot = config?.workspaceRoot || DEFAULT_WORKSPACE_ROOT;
+  const statePath = config?.statePath || DEFAULT_STATE_PATH;
+  const syncTtlMs = Number(config?.syncTtlMs || DEFAULT_SYNC_TTL_MS);
+  const now = Date.now();
+  const state = await safeReadJson(statePath, {
+    manifestHash: null,
+    manifest: null,
+    lastCheckedAt: 0,
+    lastAppliedAt: null,
+    activeSelectionHash: null,
+    activeSelectionQuery: null,
+    activeSelectionAt: null
+  });
+
+  if (state.manifest && Number(state.lastCheckedAt || 0) > 0 && now - Number(state.lastCheckedAt) < syncTtlMs) {
+    return {
+      workspaceRoot,
+      statePath,
+      state,
+      manifest: normalizeManifest(state.manifest)
+    };
+  }
+
+  const manifest = normalizeManifest(await fetchJson(`${assetServerBaseUrl}/manifest`, assetServerToken));
+  state.lastCheckedAt = now;
+
+  if (state.manifestHash !== manifest.manifestHash) {
+    await writeCatalog(manifest, workspaceRoot);
+    state.manifestHash = manifest.manifestHash;
+    state.manifest = manifest;
+    state.lastAppliedAt = new Date().toISOString();
+    state.activeSelectionHash = null;
+  } else if (!state.manifest) {
+    state.manifest = manifest;
+  }
+
+  await safeWriteJson(statePath, state);
+  return {
+    workspaceRoot,
+    statePath,
+    state,
+    manifest
+  };
+}
+
+export async function syncSharedAssetsForEvent(config, eventText) {
+  const synced = await ensureManifestSynced(config);
+  if (!synced) {
+    return null;
+  }
+
+  const { workspaceRoot, statePath, state, manifest } = synced;
+  const assetServerBaseUrl = config?.assetServerBaseUrl;
+  const assetServerToken = config?.assetServerToken;
+  const query = String(eventText || "").trim();
+
+  if (!query || isCommandOnly(query)) {
+    await writeBootstrapContext(workspaceRoot, "");
+    return { manifest, selection: null };
+  }
+
+  const resolveLimitPerKind = Math.max(1, Math.min(6, Number(config?.resolveLimitPerKind || DEFAULT_RESOLVE_LIMIT_PER_KIND)));
+  const resolveResult = await fetchJson(`${assetServerBaseUrl}/resolve`, assetServerToken, {
+    method: "POST",
+    body: JSON.stringify({
+      query,
+      limitPerKind: resolveLimitPerKind
+    })
+  });
+
+  const nextSelectionHash = selectionHash(manifest.manifestHash, query, resolveResult.matches);
+  if (state.activeSelectionHash === nextSelectionHash) {
+    return {
+      manifest,
+      selection: resolveResult
+    };
+  }
+
+  const selectedIds = Array.from(
+    new Set(
+      ASSET_KINDS.flatMap((kind) =>
+        Array.isArray(resolveResult?.matches?.[kind]) ? resolveResult.matches[kind].map((item) => item.id) : []
+      )
+    )
+  );
+
+  const itemsById = new Map();
+  for (const itemId of selectedIds) {
+    const item = await fetchJson(`${assetServerBaseUrl}/items/${encodeURIComponent(itemId)}`, assetServerToken);
+    itemsById.set(itemId, item);
+  }
+
+  await writeActiveSelection(manifest, query, resolveResult.matches, itemsById, workspaceRoot);
+  const bootstrapContext = buildPromptAdditionFromSelection(
+    {
+      query,
+      matches: resolveResult.matches
+    },
+    itemsById
+  );
+  await writeBootstrapContext(workspaceRoot, bootstrapContext);
+  state.activeSelectionHash = nextSelectionHash;
+  state.activeSelectionQuery = query;
+  state.activeSelectionAt = new Date().toISOString();
+  await safeWriteJson(statePath, state);
+
+  return {
+    manifest,
+    selection: resolveResult,
+    itemsById
+  };
+}
+
+export async function syncSharedAssetCatalog(config) {
+  return ensureManifestSynced(config);
+}
+
+export default definePluginEntry({
+  id: "shared-asset-injector",
+  name: "Shared Asset Injector",
+  description: "Sync the shared team asset catalog and materialize task-relevant assets into the member workspace.",
+  register(api) {
+    const register = typeof api.on === "function" ? api.on.bind(api) : api.registerHook.bind(api);
+
+    async function syncCatalogOnly() {
+      try {
+        await syncSharedAssetCatalog(api.pluginConfig || {});
+      } catch (error) {
+        console.error("[shared-asset-injector] catalog sync failed:", error instanceof Error ? error.message : String(error));
+      }
+    }
+
+    async function syncForEvent(event) {
+      try {
+        const text = extractEventText(event);
+        const result = await syncSharedAssetsForEvent(api.pluginConfig || {}, text);
+        if (result?.selection && result?.itemsById) {
+          const systemPromptAddition = buildPromptAdditionFromSelection(result.selection, result.itemsById);
+          if (systemPromptAddition) {
+            return {
+              prependSystemContext: systemPromptAddition
+            };
+          }
+        }
+      } catch (error) {
+        console.error("[shared-asset-injector] active sync failed:", error instanceof Error ? error.message : String(error));
+      }
+    }
+
+    register("before_prompt_build", async (event) => {
+      return syncForEvent(event);
+    });
+
+    register("before_dispatch", async (event) => {
+      await syncForEvent(event);
+    });
+
+    register("before_tool_call", async () => {
+      await syncCatalogOnly();
+    });
+  }
+});

package/members/member-template/runtime/config/local-plugins/shared-asset-injector/openclaw.plugin.json

@@ -0,0 +1,33 @@
+{
+  "id": "shared-asset-injector",
+  "name": "Shared Asset Injector",
+  "description": "Pulls published shared team assets from the Velaclaw asset server into the member runtime workspace.",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "assetServerBaseUrl": {
+        "type": "string"
+      },
+      "assetServerToken": {
+        "type": "string"
+      },
+      "workspaceRoot": {
+        "type": "string",
+        "default": "/home/node/.openclaw/workspace"
+      },
+      "statePath": {
+        "type": "string",
+        "default": "/home/node/.openclaw/shared-assets-state.json"
+      },
+      "syncTtlMs": {
+        "type": "integer",
+        "default": 30000
+      },
+      "resolveLimitPerKind": {
+        "type": "integer",
+        "default": 2
+      }
+    }
+  }
+}

package/members/member-template/runtime/config/local-plugins/shared-asset-injector/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@local/shared-asset-injector",
+  "version": "0.1.0",
+  "type": "module",
+  "openclaw": {
+    "extensions": [
+      "./index.js"
+    ]
+  }
+}

package/members/member-template/runtime/config/openclaw.json

@@ -0,0 +1,104 @@
+{
+  "agents": {
+    "defaults": {
+      "workspace": "/home/node/.openclaw/workspace",
+      "model": {
+        "primary": "saymycode/gpt-5.1-codex-mini"
+      },
+      "compaction": {
+        "mode": "safeguard"
+      },
+      "sandbox": {
+        "mode": "off",
+        "scope": "agent"
+      }
+    },
+    "list": [
+      {
+        "id": "main",
+        "default": true,
+        "workspace": "/home/node/.openclaw/workspace",
+        "model": "saymycode/gpt-5.4",
+        "thinkingDefault": "low",
+        "identity": {
+          "name": "小虾-member",
+          "emoji": "🦐",
+          "theme": "member runtime"
+        }
+      }
+    ]
+  },
+  "gateway": {
+    "mode": "local",
+    "auth": {
+      "mode": "token",
+      "token": "REPLACE_WITH_RANDOM_GATEWAY_TOKEN"
+    },
+    "port": 18789,
+    "bind": "loopback"
+  },
+  "tools": {
+    "profile": "minimal",
+    "alsoAllow": [
+      "read"
+    ],
+    "deny": [
+      "cron",
+      "sessions_spawn",
+      "subagents",
+      "lobster"
+    ],
+    "fs": {
+      "workspaceOnly": true
+    },
+    "exec": {
+      "host": "gateway",
+      "security": "allowlist",
+      "ask": "always"
+    },
+    "elevated": {
+      "enabled": false
+    }
+  },
+  "messages": {
+    "queue": {
+      "mode": "collect",
+      "debounceMs": 1000,
+      "cap": 20,
+      "drop": "summarize"
+    },
+    "inbound": {
+      "debounceMs": 0
+    }
+  },
+  "session": {
+    "dmScope": "per-channel-peer"
+  },
+  "channels": {
+    "telegram": {
+      "enabled": true,
+      "tokenFile": "/home/node/.openclaw/secrets/telegram-bot-token",
+      "dmPolicy": "allowlist",
+      "allowFrom": [
+        "REPLACE_WITH_USER_ID"
+      ],
+      "groupPolicy": "disabled"
+    }
+  },
+  "plugins": {
+    "entries": {
+      "member-quota-guard": {
+        "enabled": true,
+        "config": {
+          "policyPath": "/home/node/.openclaw/team-policy.json",
+          "usagePath": "/home/node/.openclaw/team-usage.json"
+        }
+      }
+    },
+    "load": {
+      "paths": [
+        "/home/node/.openclaw/local-plugins/member-quota-guard"
+      ]
+    }
+  }
+}