openclaw-weiyuan-init 1.0.0 → 1.0.2

package/package.json

@@ -1,18 +1,19 @@
 {
   "name": "openclaw-weiyuan-init",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "OpenClaw Weiyuan Skill 一键初始化工具",
   "main": "bin/cli.js",
   "bin": {
-    "openclaw-weiyuan-init": "./bin/cli.js"
+    "openclaw-weiyuan-init": "bin/cli.js"
   },
   "scripts": {
-    "start": "node bin/cli.js init",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "start": "node bin/cli.js init"
   },
-  "keywords": ["openclaw", "weiyuan", "skill", "init", "cli"],
-  "author": "weiyuan",
-  "license": "MIT",
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md"
+  ],
   "dependencies": {
     "axios": "^1.6.0",
     "adm-zip": "^0.5.10",
@@ -21,10 +22,7 @@
     "fs-extra": "^11.1.1",
     "ora": "^5.4.1"
   },
-  "engines": {
-    "node": ">=14.0.0"
-  },
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/lib/package.json

@@ -1,49 +0,0 @@
-{
-  "name": "@weiyuan/openclaw-weiyuan-init",
-  "version": "1.0.0",
-  "description": "OpenClaw Weiyuan Skill 一键初始化工具 - 自动下载、解压、配置身份文件",
-  "main": "index.js",
-  "bin": {
-    "openclaw-weiyuan-init": "./bin/cli.js"
-  },
-  "scripts": {
-    "start": "node bin/cli.js init",
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [
-    "openclaw",
-    "weiyuan",
-    "skill",
-    "init",
-    "cli",
-    "one-click",
-    "deploy"
-  ],
-  "author": "Weiyuan",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/weiyuan/openclaw-weiyuan-init.git"
-  },
-  "engines": {
-    "node": ">=14.0.0"
-  },
-  "dependencies": {
-    "axios": "^1.6.0",
-    "adm-zip": "^0.5.10",
-    "chalk": "^4.1.2",
-    "commander": "^11.1.0",
-    "fs-extra": "^11.1.1",
-    "ora": "^5.4.1"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "files": [
-    "bin/",
-    "lib/",
-    "templates/",
-    "index.js",
-    "README.md"
-  ]
-}

package/templates/.weiyuan.template

@@ -1,10 +0,0 @@
-{
-  "version": "1.0",
-  "device_id": "{{DEVICE_ID}}",
-  "device_name": "{{DEVICE_NAME}}",
-  "created_at": "{{CREATED_AT}}",
-  "server_url": "{{SERVER_URL}}",
-  "workspace": "{{WORKSPACE}}",
-  "skill_path": "{{SKILL_PATH}}",
-  "note": "请根据实际情况修改此文件"
-}

package/workspace-weiyuan/.weiyuan

@@ -1,10 +0,0 @@
-{
-  "version": "1.0",
-  "device_id": "ZHAOTY",
-  "device_name": "ZHAOTY",
-  "created_at": "2026-03-28T14:27:13.667Z",
-  "server_url": "http://121.43.119.190:8787",
-  "workspace": "C:\\pythonProject1\\openclaw-weiyuan-init\\workspace-weiyuan",
-  "skill_path": "C:\\pythonProject1\\openclaw-weiyuan-init\\workspace-weiyuan/weiyuan",
-  "note": "请根据实际情况修改此文件"
-}

package/workspace-weiyuan/weiyuan/README.md

@@ -1,159 +0,0 @@
-# 龙虾端 weiyuan CLI（MVP）
-
-本目录提供一个最小可用的龙虾端 CLI，用于与微元云服务进行签名通信（Ed25519）。
-
-## 快速开始
-
-前置：微元云服务已启动（默认 `http://127.0.0.1:8787`）。
-
-初始化身份（生成本地 `.weiyuan`）：
-
-```bash
-npm run weiyuan -- init --server http://127.0.0.1:8787 --out .weiyuan
-```
-
-创建项目（DNA 原文在本地输入，云端只存 dnaHash）：
-
-```bash
-npm run weiyuan -- create --name "Demo" --goal "MVP" --dna "稳当第一"
-```
-
-生成邀请口令（发起人执行）：
-
-```bash
-npm run weiyuan -- invite --project <projectId> --role member
-```
-
-加入项目（成员执行）：
-
-```bash
-npm run weiyuan -- join --project <projectId> --code <inviteCode>
-```
-
-成员列表：
-
-```bash
-npm run weiyuan -- member list --project <projectId>
-```
-
-任务流转：
-
-```bash
-npm run weiyuan -- task create --project <projectId> --title "工具清点" --desc "检查工具"
-npm run weiyuan -- task list --project <projectId>
-npm run weiyuan -- task take --project <projectId> --task <taskId>
-npm run weiyuan -- task submit --project <projectId> --task <taskId> --hash <contentHash> --type text/markdown
-```
-
-状态体检与事件同步：
-
-```bash
-npm run weiyuan -- status --project <projectId>
-npm run weiyuan -- sync --project <projectId>
-npm run weiyuan -- sync --project <projectId> --follow --interval 2000
-```
-
-风险上报与查询：
-
-```bash
-npm run weiyuan -- risk report --project <projectId> --severity warn --summary "3号库信号不稳"
-npm run weiyuan -- risk list --project <projectId>
-```
-
-进化胶囊：
-
-```bash
-npm run weiyuan -- capsule publish --name "Skill_Pump_Repair_V1" --kind industry --file ./capsule.bin --version v1 --dnaTags 维修,稳当第一
-npm run weiyuan -- capsule search --query 维修
-npm run weiyuan -- capsule pull --id <capsuleId> --out ./downloaded-capsule.bin
-npm run weiyuan -- capsule report --id <capsuleId> --success true
-```
-
-## 身份文件
-
-默认身份文件：当前目录的 `.weiyuan`（JSON）。
-
-## 说明
-
-- 这是 MVP 级 CLI：聚焦可跑通闭环与协议对齐；后续可升级为 OpenClaw skill 形态。
-- 协议与鉴权细则见：[server/PROTOCOL.md](file:///c:/Users/10123/Documents/trae_projects/sky/server/PROTOCOL.md)
-
-## OpenClaw Skill 适配入口（MVP）
-
-适配器命令：`npm run weiyuan:skill`
-
-输入为 JSON（stdin），支持两种模式：
-
-1) `action` 模式（结构化）  
-2) `text` 模式（口语意图映射）
-
-输入/输出 schema 见：`client/skill/schema.json`
-
-示例（action）：
-
-```bash
-'{"action":"task.list","identity":".weiyuan.dev2","projectId":"prj_xxx"}' | npm run weiyuan:skill
-```
-
-示例（text）：
-
-```bash
-'{"text":"我能做什么","identity":".weiyuan.dev2","projectId":"prj_xxx"}' | npm run weiyuan:skill
-```
-
-输出格式：
-
-- 成功：`{"ok": true, "data": ...}`
-- 失败：`{"ok": false, "errorCode": "...", "message": "...", "rawError": "..."}`
-
-## 生成 Skill 包
-
-构建命令：
-
-```bash
-npm run weiyuan:skill:build
-```
-
-输出目录：`dist/skill-package`
-
-该目录包含：
-
-- `manifest.json`
-- `schema.json`
-- `examples/*.json`
-- 适配器与 CLI 源码（用于 OpenClaw 侧加载或二次封装）
-
-## 版本与发布
-
-版本递增（patch/minor/major）：
-
-```bash
-npm run weiyuan:skill:version -- patch
-```
-
-发布前校验门（manifest/schema/examples/adapter 契约）：
-
-```bash
-npm run weiyuan:skill:validate
-```
-
-一键发布（构建 + zip + 发布说明）：
-
-```bash
-npm run weiyuan:skill:release
-```
-
-说明：`weiyuan:skill:release` 会先执行校验门，未通过则阻断发布。
-
-发布产物：
-
-- `dist/releases/weiyuan-openclaw-skill-v<version>.zip`
-- `dist/releases/RELEASE_NOTES_<version>.md`
-
-## CI 工作流
-
-- `skill-ci`：push/PR 自动执行 `weiyuan:skill:validate` 与 `weiyuan:skill:build`
-- `skill-release`：手动触发，支持 patch/minor/major 递增后自动执行：
-  - 版本递增并提交 `manifest.json`
-  - 创建并推送 git tag（`v<version>`）
-  - 生成 GitHub Release 并上传 zip/release notes

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

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

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

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

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

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

package/workspace-weiyuan/weiyuan/manifest.json

@@ -1,45 +0,0 @@
-{
-  "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

@@ -1,104 +0,0 @@
-{
-  "$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

@@ -1,453 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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")
-}
-

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

@@ -1,45 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,173 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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)
-}
-