openclaw-weiyuan-init 1.0.0

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

@@ -0,0 +1,45 @@
+import { bodyHashBase64, canonicalRequest, signEd25519Base64 } from "./signing"
+
+export async function signedRequest(opts: {
+  serverBaseUrl: string
+  method: "GET" | "POST"
+  pathWithQuery: string
+  lobsterId: string
+  secretKeyBase64: string
+  body?: unknown
+}): Promise<any> {
+  const timestampMs = String(Date.now())
+  const nonce = `nonce_${Math.random().toString(16).slice(2)}`
+  const bodySha = bodyHashBase64(opts.body)
+  const canonical = canonicalRequest({
+    method: opts.method,
+    pathWithQuery: opts.pathWithQuery,
+    timestampMs,
+    nonce,
+    bodySha256Base64: bodySha,
+  })
+  const signature = signEd25519Base64(canonical, opts.secretKeyBase64)
+
+  const headers: Record<string, string> = {
+    "X-Weiyuan-Lobster-Id": opts.lobsterId,
+    "X-Weiyuan-Timestamp": timestampMs,
+    "X-Weiyuan-Nonce": nonce,
+    "X-Weiyuan-Signature": signature,
+  }
+  if (opts.body) headers["Content-Type"] = "application/json"
+
+  const res = await fetch(`${opts.serverBaseUrl}${opts.pathWithQuery}`, {
+    method: opts.method,
+    headers,
+    body: opts.body ? JSON.stringify(opts.body) : undefined,
+  })
+  const text = await res.text()
+  let json: any
+  try {
+    json = JSON.parse(text)
+  } catch {
+    json = { raw: text }
+  }
+  return { status: res.status, json }
+}
+

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

@@ -0,0 +1,38 @@
+import naclImport from "tweetnacl"
+import { sha256Base64, sha256Hex } from "./crypto"
+
+const nacl = (naclImport as unknown as any).default ?? naclImport
+
+function b64(u8: Uint8Array): string {
+  return Buffer.from(u8).toString("base64")
+}
+
+export function canonicalRequest(opts: {
+  method: string
+  pathWithQuery: string
+  timestampMs: string
+  nonce: string
+  bodySha256Base64: string
+}): string {
+  return [opts.method.toUpperCase(), opts.pathWithQuery, opts.timestampMs, opts.nonce, opts.bodySha256Base64].join("\n")
+}
+
+export function signEd25519Base64(messageUtf8: string, secretKeyBase64: string): string {
+  const sk = Buffer.from(secretKeyBase64, "base64")
+  const sig = nacl.sign.detached(new Uint8Array(Buffer.from(messageUtf8, "utf8")), new Uint8Array(sk))
+  return b64(sig)
+}
+
+export function newKeyPair(): { publicKeyBase64: string; secretKeyBase64: string; lobsterId: string } {
+  const kp = nacl.sign.keyPair()
+  const publicKeyBase64 = b64(kp.publicKey)
+  const secretKeyBase64 = b64(kp.secretKey)
+  const lobsterId = `lob_${sha256Hex(kp.publicKey).slice(0, 12)}`
+  return { publicKeyBase64, secretKeyBase64, lobsterId }
+}
+
+export function bodyHashBase64(body: unknown | undefined): string {
+  const bodyStr = body ? JSON.stringify(body) : ""
+  return sha256Base64(bodyStr)
+}
+

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

@@ -0,0 +1,173 @@
+import { runCli } from "./cli"
+
+type SkillInput = {
+  action?: string
+  text?: string
+  identity?: string
+  projectId?: string
+  taskId?: string
+  code?: string
+  role?: string
+  summary?: string
+  severity?: string
+  capsuleId?: string
+  query?: string
+  hash?: string
+  title?: string
+}
+
+type SkillSuccess = {
+  ok: true
+  data: unknown
+}
+
+type SkillError = {
+  ok: false
+  errorCode: string
+  message: string
+  rawError?: string
+}
+
+function readAllStdin(): Promise<string> {
+  return new Promise((resolve) => {
+    const chunks: Buffer[] = []
+    process.stdin.on("data", (c) => chunks.push(Buffer.from(c)))
+    process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")))
+  })
+}
+
+function fromText(input: SkillInput): string[] {
+  const text = (input.text ?? "").trim()
+  const lower = text.toLowerCase()
+  const identity = input.identity ?? ".weiyuan"
+
+  if (!text) throw new Error("missing_text")
+
+  if (lower.includes("我能做什么") || lower.includes("任务列表") || lower.includes("还有啥活")) {
+    if (!input.projectId) throw new Error("missing_projectId")
+    return ["task", "list", "--identity", identity, "--project", input.projectId]
+  }
+  if (lower.includes("我领") || lower.includes("我来")) {
+    if (!input.projectId || !input.taskId) throw new Error("missing_projectId_or_taskId")
+    return ["task", "take", "--identity", identity, "--project", input.projectId, "--task", input.taskId]
+  }
+  if (lower.includes("搞定") || lower.includes("完事") || lower.includes("看图") || lower.includes("已修好")) {
+    if (!input.projectId || !input.taskId) throw new Error("missing_projectId_or_taskId")
+    const hash = input.hash ?? "hash-auto"
+    return ["task", "submit", "--identity", identity, "--project", input.projectId, "--task", input.taskId, "--hash", hash]
+  }
+  if (lower.includes("卡住") || lower.includes("帮忙")) {
+    if (!input.projectId) throw new Error("missing_projectId")
+    const summary = input.summary ?? text
+    return ["risk", "report", "--identity", identity, "--project", input.projectId, "--severity", input.severity ?? "warn", "--summary", summary]
+  }
+  if (lower.includes("进度") || lower.includes("现在怎么样")) {
+    if (!input.projectId) throw new Error("missing_projectId")
+    return ["status", "--identity", identity, "--project", input.projectId]
+  }
+  if (lower.includes("老规矩") || lower.includes("上次那套")) {
+    return ["capsule", "search", "--identity", identity, "--query", input.query ?? ""]
+  }
+
+  if (input.projectId) {
+    return ["task", "list", "--identity", identity, "--project", input.projectId]
+  }
+  throw new Error("cannot_map_text_without_project_context")
+}
+
+function fromAction(input: SkillInput): string[] {
+  const identity = input.identity ?? ".weiyuan"
+  switch (input.action) {
+    case "init":
+      return ["init", "--server", "http://127.0.0.1:8787", "--out", identity]
+    case "create":
+      if (!input.title) throw new Error("missing_title")
+      return ["create", "--identity", identity, "--name", input.title, "--goal", "MVP", "--dna", "稳当第一"]
+    case "join":
+      if (!input.projectId || !input.code) throw new Error("missing_projectId_or_code")
+      return ["join", "--identity", identity, "--project", input.projectId, "--code", input.code]
+    case "task.take":
+      if (!input.projectId || !input.taskId) throw new Error("missing_projectId_or_taskId")
+      return ["task", "take", "--identity", identity, "--project", input.projectId, "--task", input.taskId]
+    case "task.submit":
+      if (!input.projectId || !input.taskId) throw new Error("missing_projectId_or_taskId")
+      return ["task", "submit", "--identity", identity, "--project", input.projectId, "--task", input.taskId, "--hash", input.hash ?? "hash-auto"]
+    case "task.list":
+      if (!input.projectId) throw new Error("missing_projectId")
+      return ["task", "list", "--identity", identity, "--project", input.projectId]
+    case "status":
+      if (!input.projectId) throw new Error("missing_projectId")
+      return ["status", "--identity", identity, "--project", input.projectId]
+    case "risk.report":
+      if (!input.projectId || !input.summary) throw new Error("missing_projectId_or_summary")
+      return ["risk", "report", "--identity", identity, "--project", input.projectId, "--severity", input.severity ?? "warn", "--summary", input.summary]
+    case "capsule.search":
+      return ["capsule", "search", "--identity", identity, "--query", input.query ?? ""]
+    default:
+      throw new Error("unknown_action")
+  }
+}
+
+async function main(): Promise<void> {
+  const raw = await readAllStdin()
+  if (!raw.trim()) throw new Error("missing_input")
+  const input = JSON.parse(raw) as SkillInput
+  const argv = input.action ? fromAction(input) : fromText(input)
+
+  let captured = ""
+  const originalWrite = process.stdout.write.bind(process.stdout)
+  ;(process.stdout as any).write = (chunk: any, ...rest: any[]) => {
+    captured += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk)
+    return true
+  }
+
+  try {
+    await runCli(argv)
+  } finally {
+    ;(process.stdout as any).write = originalWrite
+  }
+
+  let data: unknown = captured.trim()
+  try {
+    data = JSON.parse(captured)
+  } catch {}
+  const out: SkillSuccess = { ok: true, data }
+  process.stdout.write(`${JSON.stringify(out, null, 2)}\n`)
+}
+
+function mapError(err: unknown): SkillError {
+  const rawError = String(err instanceof Error ? err.message : err)
+  if (rawError.includes("missing_input")) {
+    return { ok: false, errorCode: "MISSING_INPUT", message: "Missing skill JSON input.", rawError }
+  }
+  if (rawError.includes("Unexpected token") || rawError.includes("JSON")) {
+    return { ok: false, errorCode: "INVALID_JSON", message: "Invalid JSON input.", rawError }
+  }
+  if (rawError.includes("unknown_action")) {
+    return { ok: false, errorCode: "UNKNOWN_ACTION", message: "Unknown action for skill adapter.", rawError }
+  }
+  if (rawError.includes("cannot_map_text")) {
+    return { ok: false, errorCode: "CANNOT_MAP_TEXT", message: "Cannot map text intent. Add project/task context.", rawError }
+  }
+  if (rawError.includes("missing_project")) {
+    return { ok: false, errorCode: "MISSING_PROJECT", message: "Missing projectId.", rawError }
+  }
+  if (rawError.includes("taskId")) {
+    return { ok: false, errorCode: "MISSING_TASK", message: "Missing taskId.", rawError }
+  }
+  if (rawError.includes("missing_projectId_or_code") || rawError.includes("missing_code")) {
+    return { ok: false, errorCode: "MISSING_CODE", message: "Missing invitation code.", rawError }
+  }
+  if (rawError.includes("missing_projectId_or_summary")) {
+    return { ok: false, errorCode: "MISSING_SUMMARY", message: "Missing risk summary.", rawError }
+  }
+  if (rawError.includes("unknown_") || rawError.includes("missing_")) {
+    return { ok: false, errorCode: "CLI_ERROR", message: "CLI arguments are incomplete or unsupported.", rawError }
+  }
+  return { ok: false, errorCode: "UNKNOWN", message: "Skill execution failed.", rawError }
+}
+
+main().catch((e) => {
+  process.stdout.write(`${JSON.stringify(mapError(e), null, 2)}\n`)
+  process.exit(1)
+})

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

@@ -0,0 +1,10 @@
+export type WeiyuanIdentityFileV1 = {
+  version: 1
+  serverBaseUrl: string
+  lobsterId: string
+  publicKeyBase64: string
+  secretKeyBase64: string
+  identityHash: string
+  projectCursors: Record<string, number>
+}
+

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

@@ -0,0 +1,25 @@
+import * as fs from "node:fs/promises"
+import * as path from "node:path"
+import type { WeiyuanIdentityFileV1 } from "./types"
+
+export const DEFAULT_IDENTITY_PATH = ".weiyuan"
+
+export async function readIdentity(filePath: string): Promise<WeiyuanIdentityFileV1> {
+  const raw = await fs.readFile(filePath, "utf8")
+  const parsed = JSON.parse(raw) as WeiyuanIdentityFileV1
+  if (parsed.version !== 1) {
+    throw new Error("unsupported_identity_version")
+  }
+  return parsed
+}
+
+export async function writeIdentity(filePath: string, data: WeiyuanIdentityFileV1): Promise<void> {
+  await fs.mkdir(path.dirname(path.resolve(filePath)), { recursive: true })
+  const tmp = `${filePath}.tmp`
+  await fs.writeFile(tmp, JSON.stringify(data, null, 2), "utf8")
+  try {
+    await fs.unlink(filePath)
+  } catch {}
+  await fs.rename(tmp, filePath)
+}
+