openclaw-weiyuan-init 1.0.0

package/workspace-weiyuan/weiyuan/examples/action-task-list.json

@@ -0,0 +1,6 @@
+{
+  "action": "task.list",
+  "identity": ".weiyuan.dev2",
+  "projectId": "prj_demo"
+}
+

package/workspace-weiyuan/weiyuan/examples/risk-report.json

@@ -0,0 +1,8 @@
+{
+  "action": "risk.report",
+  "identity": ".weiyuan.dev2",
+  "projectId": "prj_demo",
+  "severity": "warn",
+  "summary": "3号库信号不稳"
+}
+

package/workspace-weiyuan/weiyuan/examples/text-what-can-i-do.json

@@ -0,0 +1,6 @@
+{
+  "text": "我能做什么",
+  "identity": ".weiyuan.dev2",
+  "projectId": "prj_demo"
+}
+

package/workspace-weiyuan/weiyuan/manifest.json

@@ -0,0 +1,45 @@
+{
+  "name": "weiyuan-openclaw-skill",
+  "displayName": "微元协作 Skill",
+  "version": "0.1.1",
+  "description": "通过结构化 action 或自然语言 text 调用微元云服务。",
+  "entry": {
+    "type": "command",
+    "command": "npm run weiyuan:skill"
+  },
+  "ioSchema": "./schema.json",
+  "capabilities": {
+    "modes": [
+      "action",
+      "text"
+    ],
+    "actions": [
+      "init",
+      "create",
+      "join",
+      "task.list",
+      "task.take",
+      "task.submit",
+      "status",
+      "risk.report",
+      "capsule.search"
+    ]
+  },
+  "examples": [
+    "./examples/action-task-list.json",
+    "./examples/text-what-can-i-do.json",
+    "./examples/risk-report.json"
+  ],
+  "output": {
+    "success": {
+      "ok": true,
+      "data": {}
+    },
+    "error": {
+      "ok": false,
+      "errorCode": "UNKNOWN_ACTION",
+      "message": "",
+      "rawError": ""
+    }
+  }
+}

package/workspace-weiyuan/weiyuan/schema.json

@@ -0,0 +1,104 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "weiyuan-skill-schema-v1",
+  "title": "Weiyuan OpenClaw Skill IO Schema",
+  "type": "object",
+  "properties": {
+    "input": {
+      "oneOf": [
+        {
+          "title": "ActionInput",
+          "type": "object",
+          "required": ["action"],
+          "properties": {
+            "action": {
+              "type": "string",
+              "enum": [
+                "init",
+                "create",
+                "join",
+                "task.list",
+                "task.take",
+                "task.submit",
+                "status",
+                "risk.report",
+                "capsule.search"
+              ]
+            },
+            "identity": { "type": "string" },
+            "projectId": { "type": "string" },
+            "taskId": { "type": "string" },
+            "code": { "type": "string" },
+            "role": { "type": "string", "enum": ["founder", "member", "guest"] },
+            "summary": { "type": "string" },
+            "severity": { "type": "string", "enum": ["info", "warn", "urgent"] },
+            "capsuleId": { "type": "string" },
+            "query": { "type": "string" },
+            "hash": { "type": "string" },
+            "title": { "type": "string" }
+          },
+          "additionalProperties": false
+        },
+        {
+          "title": "TextInput",
+          "type": "object",
+          "required": ["text"],
+          "properties": {
+            "text": { "type": "string", "minLength": 1 },
+            "identity": { "type": "string" },
+            "projectId": { "type": "string" },
+            "taskId": { "type": "string" },
+            "summary": { "type": "string" },
+            "severity": { "type": "string", "enum": ["info", "warn", "urgent"] },
+            "hash": { "type": "string" },
+            "query": { "type": "string" }
+          },
+          "additionalProperties": false
+        }
+      ]
+    },
+    "output": {
+      "oneOf": [
+        {
+          "title": "SuccessOutput",
+          "type": "object",
+          "required": ["ok"],
+          "properties": {
+            "ok": { "const": true },
+            "data": {}
+          },
+          "additionalProperties": true
+        },
+        {
+          "title": "ErrorOutput",
+          "type": "object",
+          "required": ["ok", "errorCode", "message"],
+          "properties": {
+            "ok": { "const": false },
+            "errorCode": {
+              "type": "string",
+              "enum": [
+                "MISSING_INPUT",
+                "INVALID_JSON",
+                "UNKNOWN_ACTION",
+                "CANNOT_MAP_TEXT",
+                "MISSING_PROJECT",
+                "MISSING_TASK",
+                "MISSING_CODE",
+                "MISSING_SUMMARY",
+                "CLI_ERROR",
+                "UNKNOWN"
+              ]
+            },
+            "message": { "type": "string" },
+            "rawError": { "type": "string" }
+          },
+          "additionalProperties": true
+        }
+      ]
+    }
+  },
+  "required": ["input", "output"],
+  "additionalProperties": false
+}
+

package/workspace-weiyuan/weiyuan/src/cli.ts

@@ -0,0 +1,453 @@
+import * as fs from "node:fs/promises"
+import { DEFAULT_IDENTITY_PATH, readIdentity, writeIdentity } from "./weiyuanFile"
+import { sha256Hex } from "./crypto"
+import { signedRequest } from "./http"
+import { bodyHashBase64, canonicalRequest, newKeyPair, signEd25519Base64 } from "./signing"
+
+type Argv = { _: string[]; flags: Record<string, string | boolean> }
+
+function parseArgv(argv: string[]): Argv {
+  const out: Argv = { _: [], flags: {} }
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]!
+    if (a.startsWith("--")) {
+      const key = a.slice(2)
+      const next = argv[i + 1]
+      if (next && !next.startsWith("-")) {
+        out.flags[key] = next
+        i++
+      } else {
+        out.flags[key] = true
+      }
+    } else {
+      out._.push(a)
+    }
+  }
+  return out
+}
+
+function mustString(flags: Record<string, string | boolean>, key: string): string {
+  const v = flags[key]
+  if (typeof v !== "string" || !v) throw new Error(`missing_${key}`)
+  return v
+}
+
+function optString(flags: Record<string, string | boolean>, key: string): string | undefined {
+  const v = flags[key]
+  return typeof v === "string" ? v : undefined
+}
+
+function print(obj: unknown): void {
+  process.stdout.write(`${JSON.stringify(obj, null, 2)}\n`)
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+async function cmdInit(args: Argv): Promise<void> {
+  const serverBaseUrl = optString(args.flags, "server") ?? "http://127.0.0.1:8787"
+  const filePath = optString(args.flags, "out") ?? DEFAULT_IDENTITY_PATH
+  const kp = newKeyPair()
+  const identityHash = sha256Hex(JSON.stringify({ lobsterId: kp.lobsterId, publicKeyBase64: kp.publicKeyBase64 }))
+
+  const body = { lobsterId: kp.lobsterId, publicKeyBase64: kp.publicKeyBase64, identityHash }
+  const timestampMs = String(Date.now())
+  const nonce = `nonce_${Math.random().toString(16).slice(2)}`
+  const bodySha = bodyHashBase64(body)
+  const canonical = canonicalRequest({
+    method: "POST",
+    pathWithQuery: "/v1/init",
+    timestampMs,
+    nonce,
+    bodySha256Base64: bodySha,
+  })
+  const signature = signEd25519Base64(canonical, kp.secretKeyBase64)
+
+  const res = await fetch(`${serverBaseUrl}/v1/init`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Weiyuan-Lobster-Id": kp.lobsterId,
+      "X-Weiyuan-Timestamp": timestampMs,
+      "X-Weiyuan-Nonce": nonce,
+      "X-Weiyuan-Signature": signature,
+    },
+    body: JSON.stringify(body),
+  })
+  const json = await res.json().catch(() => ({}))
+  if (res.status !== 200) throw new Error(JSON.stringify(json))
+
+  await writeIdentity(filePath, {
+    version: 1,
+    serverBaseUrl,
+    lobsterId: kp.lobsterId,
+    publicKeyBase64: kp.publicKeyBase64,
+    secretKeyBase64: kp.secretKeyBase64,
+    identityHash,
+    projectCursors: {},
+  })
+
+  print({ ok: true, lobsterId: kp.lobsterId, file: filePath, welcome: json.data?.welcome })
+}
+
+async function cmdCreateProject(args: Argv): Promise<void> {
+  const filePath = optString(args.flags, "identity") ?? DEFAULT_IDENTITY_PATH
+  const identity = await readIdentity(filePath)
+  const name = mustString(args.flags, "name")
+  const goal = optString(args.flags, "goal") ?? ""
+  const dna = mustString(args.flags, "dna")
+  const dnaHash = sha256Hex(dna)
+
+  const { status, json } = await signedRequest({
+    serverBaseUrl: identity.serverBaseUrl,
+    method: "POST",
+    pathWithQuery: "/v1/projects",
+    lobsterId: identity.lobsterId,
+    secretKeyBase64: identity.secretKeyBase64,
+    body: { name, goal, dnaHash },
+  })
+  if (status !== 200) throw new Error(JSON.stringify(json))
+  print({ ok: true, projectId: json.data.projectId })
+}
+
+async function cmdInvite(args: Argv): Promise<void> {
+  const filePath = optString(args.flags, "identity") ?? DEFAULT_IDENTITY_PATH
+  const identity = await readIdentity(filePath)
+  const projectId = mustString(args.flags, "project")
+  const role = mustString(args.flags, "role")
+  const { status, json } = await signedRequest({
+    serverBaseUrl: identity.serverBaseUrl,
+    method: "POST",
+    pathWithQuery: "/v1/invites",
+    lobsterId: identity.lobsterId,
+    secretKeyBase64: identity.secretKeyBase64,
+    body: { projectId, role },
+  })
+  if (status !== 200) throw new Error(JSON.stringify(json))
+  print({ ok: true, code: json.data.code })
+}
+
+async function cmdJoin(args: Argv): Promise<void> {
+  const filePath = optString(args.flags, "identity") ?? DEFAULT_IDENTITY_PATH
+  const identity = await readIdentity(filePath)
+  const projectId = mustString(args.flags, "project")
+  const code = mustString(args.flags, "code")
+  const { status, json } = await signedRequest({
+    serverBaseUrl: identity.serverBaseUrl,
+    method: "POST",
+    pathWithQuery: `/v1/projects/${projectId}/join`,
+    lobsterId: identity.lobsterId,
+    secretKeyBase64: identity.secretKeyBase64,
+    body: { code },
+  })
+  if (status !== 200) throw new Error(JSON.stringify(json))
+  print({ ok: true, welcome: json.data?.welcome })
+}
+
+async function cmdTaskList(args: Argv): Promise<void> {
+  const filePath = optString(args.flags, "identity") ?? DEFAULT_IDENTITY_PATH
+  const identity = await readIdentity(filePath)
+  const projectId = mustString(args.flags, "project")
+  const { status, json } = await signedRequest({
+    serverBaseUrl: identity.serverBaseUrl,
+    method: "GET",
+    pathWithQuery: `/v1/projects/${projectId}/tasks`,
+    lobsterId: identity.lobsterId,
+    secretKeyBase64: identity.secretKeyBase64,
+  })
+  if (status !== 200) throw new Error(JSON.stringify(json))
+  print(json.data)
+}
+
+async function cmdTaskCreate(args: Argv): Promise<void> {
+  const filePath = optString(args.flags, "identity") ?? DEFAULT_IDENTITY_PATH
+  const identity = await readIdentity(filePath)
+  const projectId = mustString(args.flags, "project")
+  const title = mustString(args.flags, "title")
+  const desc = optString(args.flags, "desc")
+  const { status, json } = await signedRequest({
+    serverBaseUrl: identity.serverBaseUrl,
+    method: "POST",
+    pathWithQuery: `/v1/projects/${projectId}/tasks`,
+    lobsterId: identity.lobsterId,
+    secretKeyBase64: identity.secretKeyBase64,
+    body: { title, desc },
+  })
+  if (status !== 200) throw new Error(JSON.stringify(json))
+  print({ ok: true, taskId: json.data.taskId })
+}
+
+async function cmdTaskTake(args: Argv): Promise<void> {
+  const filePath = optString(args.flags, "identity") ?? DEFAULT_IDENTITY_PATH
+  const identity = await readIdentity(filePath)
+  const projectId = mustString(args.flags, "project")
+  const taskId = mustString(args.flags, "task")
+  const { status, json } = await signedRequest({
+    serverBaseUrl: identity.serverBaseUrl,
+    method: "POST",
+    pathWithQuery: `/v1/projects/${projectId}/tasks/${taskId}/take`,
+    lobsterId: identity.lobsterId,
+    secretKeyBase64: identity.secretKeyBase64,
+    body: {},
+  })
+  if (status !== 200) throw new Error(JSON.stringify(json))
+  print({ ok: true })
+}
+
+async function cmdTaskAbandon(args: Argv): Promise<void> {
+  const filePath = optString(args.flags, "identity") ?? DEFAULT_IDENTITY_PATH
+  const identity = await readIdentity(filePath)
+  const projectId = mustString(args.flags, "project")
+  const taskId = mustString(args.flags, "task")
+  const { status, json } = await signedRequest({
+    serverBaseUrl: identity.serverBaseUrl,
+    method: "POST",
+    pathWithQuery: `/v1/projects/${projectId}/tasks/${taskId}/abandon`,
+    lobsterId: identity.lobsterId,
+    secretKeyBase64: identity.secretKeyBase64,
+    body: {},
+  })
+  if (status !== 200) throw new Error(JSON.stringify(json))
+  print({ ok: true })
+}
+
+async function cmdTaskSubmit(args: Argv): Promise<void> {
+  const filePath = optString(args.flags, "identity") ?? DEFAULT_IDENTITY_PATH
+  const identity = await readIdentity(filePath)
+  const projectId = mustString(args.flags, "project")
+  const taskId = mustString(args.flags, "task")
+  const contentHash = mustString(args.flags, "hash")
+  const contentType = optString(args.flags, "type") ?? "text/markdown"
+  const { status, json } = await signedRequest({
+    serverBaseUrl: identity.serverBaseUrl,
+    method: "POST",
+    pathWithQuery: `/v1/projects/${projectId}/tasks/${taskId}/submit`,
+    lobsterId: identity.lobsterId,
+    secretKeyBase64: identity.secretKeyBase64,
+    body: { artifacts: [{ contentHash, contentType }] },
+  })
+  if (status !== 200) throw new Error(JSON.stringify(json))
+  print({ ok: true })
+}
+
+async function cmdStatus(args: Argv): Promise<void> {
+  const filePath = optString(args.flags, "identity") ?? DEFAULT_IDENTITY_PATH
+  const identity = await readIdentity(filePath)
+  const projectId = mustString(args.flags, "project")
+  const { status, json } = await signedRequest({
+    serverBaseUrl: identity.serverBaseUrl,
+    method: "GET",
+    pathWithQuery: `/v1/projects/${projectId}/status`,
+    lobsterId: identity.lobsterId,
+    secretKeyBase64: identity.secretKeyBase64,
+  })
+  if (status !== 200) throw new Error(JSON.stringify(json))
+  print(json.data)
+}
+
+async function cmdMemberList(args: Argv): Promise<void> {
+  const filePath = optString(args.flags, "identity") ?? DEFAULT_IDENTITY_PATH
+  const identity = await readIdentity(filePath)
+  const projectId = mustString(args.flags, "project")
+  const { status, json } = await signedRequest({
+    serverBaseUrl: identity.serverBaseUrl,
+    method: "GET",
+    pathWithQuery: `/v1/projects/${projectId}/members`,
+    lobsterId: identity.lobsterId,
+    secretKeyBase64: identity.secretKeyBase64,
+  })
+  if (status !== 200) throw new Error(JSON.stringify(json))
+  print(json.data)
+}
+
+async function cmdSync(args: Argv): Promise<void> {
+  const filePath = optString(args.flags, "identity") ?? DEFAULT_IDENTITY_PATH
+  const identity = await readIdentity(filePath)
+  const projectId = mustString(args.flags, "project")
+  const follow = Boolean(args.flags.follow)
+  const intervalMs = Number(optString(args.flags, "interval") ?? 2000)
+
+  const runOnce = async (): Promise<void> => {
+    const cursor = identity.projectCursors[projectId] ?? 0
+    const { status, json } = await signedRequest({
+      serverBaseUrl: identity.serverBaseUrl,
+      method: "GET",
+      pathWithQuery: `/v1/projects/${projectId}/events?cursor=${cursor}`,
+      lobsterId: identity.lobsterId,
+      secretKeyBase64: identity.secretKeyBase64,
+    })
+    if (status !== 200) throw new Error(JSON.stringify(json))
+    identity.projectCursors[projectId] = Number(json.data.cursor ?? cursor)
+    await writeIdentity(filePath, identity)
+    print({ ok: true, cursor: identity.projectCursors[projectId], events: json.data.events })
+  }
+
+  await runOnce()
+  if (!follow) return
+  while (true) {
+    await sleep(intervalMs)
+    await runOnce()
+  }
+}
+
+async function cmdRiskReport(args: Argv): Promise<void> {
+  const filePath = optString(args.flags, "identity") ?? DEFAULT_IDENTITY_PATH
+  const identity = await readIdentity(filePath)
+  const projectId = mustString(args.flags, "project")
+  const severity = mustString(args.flags, "severity")
+  const summary = mustString(args.flags, "summary")
+  const taskId = optString(args.flags, "task")
+  const { status, json } = await signedRequest({
+    serverBaseUrl: identity.serverBaseUrl,
+    method: "POST",
+    pathWithQuery: `/v1/projects/${projectId}/risks`,
+    lobsterId: identity.lobsterId,
+    secretKeyBase64: identity.secretKeyBase64,
+    body: { severity, summary, taskId },
+  })
+  if (status !== 200) throw new Error(JSON.stringify(json))
+  print({ ok: true, riskId: json.data.riskId })
+}
+
+async function cmdRiskList(args: Argv): Promise<void> {
+  const filePath = optString(args.flags, "identity") ?? DEFAULT_IDENTITY_PATH
+  const identity = await readIdentity(filePath)
+  const projectId = mustString(args.flags, "project")
+  const { status, json } = await signedRequest({
+    serverBaseUrl: identity.serverBaseUrl,
+    method: "GET",
+    pathWithQuery: `/v1/projects/${projectId}/risks`,
+    lobsterId: identity.lobsterId,
+    secretKeyBase64: identity.secretKeyBase64,
+  })
+  if (status !== 200) throw new Error(JSON.stringify(json))
+  print(json.data)
+}
+
+async function cmdCapsulePublish(args: Argv): Promise<void> {
+  const filePath = optString(args.flags, "identity") ?? DEFAULT_IDENTITY_PATH
+  const identity = await readIdentity(filePath)
+  const name = mustString(args.flags, "name")
+  const kind = mustString(args.flags, "kind")
+  const version = optString(args.flags, "version") ?? "v1"
+  const packagePath = mustString(args.flags, "file")
+  const bytes = await fs.readFile(packagePath)
+  const packageHash = sha256Hex(bytes)
+  const manifest = {
+    name,
+    kind,
+    version,
+    dnaTags: optString(args.flags, "dnaTags")?.split(",").map((x) => x.trim()).filter(Boolean) ?? [],
+    projectTags: optString(args.flags, "projectTags")?.split(",").map((x) => x.trim()).filter(Boolean) ?? [],
+  }
+  const manifestHash = sha256Hex(JSON.stringify(manifest))
+  const packageBytesBase64 = Buffer.from(bytes).toString("base64")
+
+  const { status, json } = await signedRequest({
+    serverBaseUrl: identity.serverBaseUrl,
+    method: "POST",
+    pathWithQuery: "/v1/capsules",
+    lobsterId: identity.lobsterId,
+    secretKeyBase64: identity.secretKeyBase64,
+    body: { ...manifest, manifestHash, packageHash, packageBytesBase64 },
+  })
+  if (status !== 200) throw new Error(JSON.stringify(json))
+  print({ ok: true, capsuleId: json.data.capsuleId, manifestHash, packageHash })
+}
+
+async function cmdCapsuleSearch(args: Argv): Promise<void> {
+  const filePath = optString(args.flags, "identity") ?? DEFAULT_IDENTITY_PATH
+  const identity = await readIdentity(filePath)
+  const query = optString(args.flags, "query") ?? ""
+  const { status, json } = await signedRequest({
+    serverBaseUrl: identity.serverBaseUrl,
+    method: "GET",
+    pathWithQuery: `/v1/capsules?query=${encodeURIComponent(query)}`,
+    lobsterId: identity.lobsterId,
+    secretKeyBase64: identity.secretKeyBase64,
+  })
+  if (status !== 200) throw new Error(JSON.stringify(json))
+  print(json.data)
+}
+
+async function cmdCapsulePull(args: Argv): Promise<void> {
+  const filePath = optString(args.flags, "identity") ?? DEFAULT_IDENTITY_PATH
+  const identity = await readIdentity(filePath)
+  const capsuleId = mustString(args.flags, "id")
+  const out = optString(args.flags, "out")
+  const { status, json } = await signedRequest({
+    serverBaseUrl: identity.serverBaseUrl,
+    method: "POST",
+    pathWithQuery: `/v1/capsules/${capsuleId}/pull`,
+    lobsterId: identity.lobsterId,
+    secretKeyBase64: identity.secretKeyBase64,
+    body: {},
+  })
+  if (status !== 200) throw new Error(JSON.stringify(json))
+  const capsule = json.data.capsule
+  if (out && capsule?.packageBytesBase64) {
+    await fs.writeFile(out, Buffer.from(capsule.packageBytesBase64, "base64"))
+  }
+  print({ ok: true, capsule })
+}
+
+async function cmdCapsuleReport(args: Argv): Promise<void> {
+  const filePath = optString(args.flags, "identity") ?? DEFAULT_IDENTITY_PATH
+  const identity = await readIdentity(filePath)
+  const capsuleId = mustString(args.flags, "id")
+  const success = (optString(args.flags, "success") ?? "true").toLowerCase() !== "false"
+  const { status, json } = await signedRequest({
+    serverBaseUrl: identity.serverBaseUrl,
+    method: "POST",
+    pathWithQuery: `/v1/capsules/${capsuleId}/report`,
+    lobsterId: identity.lobsterId,
+    secretKeyBase64: identity.secretKeyBase64,
+    body: { success },
+  })
+  if (status !== 200) throw new Error(JSON.stringify(json))
+  print({ ok: true, capsuleId })
+}
+
+export async function runCli(argv: string[]): Promise<void> {
+  const args = parseArgv(argv)
+  const [cmd, sub] = args._.length ? [args._[0], args._[1]] : [undefined, undefined]
+
+  if (!cmd) throw new Error("missing_command")
+
+  if (cmd === "init") return await cmdInit(args)
+  if (cmd === "create") return await cmdCreateProject(args)
+  if (cmd === "invite") return await cmdInvite(args)
+  if (cmd === "join") return await cmdJoin(args)
+  if (cmd === "status") return await cmdStatus(args)
+  if (cmd === "sync") return await cmdSync(args)
+  if (cmd === "member") {
+    if (sub === "list") return await cmdMemberList(args)
+    throw new Error("unknown_member_subcommand")
+  }
+
+  if (cmd === "risk") {
+    if (sub === "report") return await cmdRiskReport(args)
+    if (sub === "list") return await cmdRiskList(args)
+    throw new Error("unknown_risk_subcommand")
+  }
+
+  if (cmd === "capsule") {
+    if (sub === "publish") return await cmdCapsulePublish(args)
+    if (sub === "search") return await cmdCapsuleSearch(args)
+    if (sub === "pull") return await cmdCapsulePull(args)
+    if (sub === "report") return await cmdCapsuleReport(args)
+    throw new Error("unknown_capsule_subcommand")
+  }
+
+  if (cmd === "task") {
+    if (sub === "list") return await cmdTaskList(args)
+    if (sub === "create") return await cmdTaskCreate(args)
+    if (sub === "take") return await cmdTaskTake(args)
+    if (sub === "abandon") return await cmdTaskAbandon(args)
+    if (sub === "submit") return await cmdTaskSubmit(args)
+    throw new Error("unknown_task_subcommand")
+  }
+
+  throw new Error("unknown_command")
+}

package/workspace-weiyuan/weiyuan/src/cliMain.ts

@@ -0,0 +1,7 @@
+import { runCli } from "./cli"
+
+runCli(process.argv.slice(2)).catch((e) => {
+  process.stderr.write(String(e instanceof Error ? e.stack ?? e.message : e))
+  process.exit(1)
+})
+

package/workspace-weiyuan/weiyuan/src/crypto.ts

@@ -0,0 +1,14 @@
+import * as crypto from "node:crypto"
+
+export function sha256Base64(input: string | Uint8Array): string {
+  const h = crypto.createHash("sha256")
+  h.update(input)
+  return h.digest("base64")
+}
+
+export function sha256Hex(input: string | Uint8Array): string {
+  const h = crypto.createHash("sha256")
+  h.update(input)
+  return h.digest("hex")
+}
+