@super-coding/cli 0.1.0 → 0.2.0

package/dist/cli.js

@@ -2,6 +2,7 @@
 import { createRequire } from "node:module";
 import { Command } from "commander";
 import { logsDaemon, restartDaemon, runDaemonForeground, startDaemon, statusDaemon, stopDaemon, } from "./daemon/manage.js";
+import { connectPingcode, disconnectPingcode, printPingcodeStatus } from "./pingcode/index.js";
 const pkg = createRequire(import.meta.url)("../package.json");
 const program = new Command();
 program.name("scode").version(pkg.version).description("super-coding CLI");
@@ -32,4 +33,25 @@ daemon
 daemon.command("run").description("前台运行（调试/外部 supervisor 托管）").action(() => run(() => runDaemonForeground()));
 // 嵌套命令默认无 help 子命令；补上使 `daemon help` 可用（npm 会吞掉 -h，`help` 是 npm 安全路径）
 daemon.addHelpCommand("help [command]");
+const pingcode = program
+    .command("pingcode")
+    .description("PingCode（pc）集成：保存本机凭据、查看可用性");
+pingcode
+    .command("status")
+    .description("查看 pc 二进制、凭据来源与凭据注入方式")
+    .action(() => run(() => printPingcodeStatus()));
+pingcode
+    .command("connect")
+    .description("保存 PingCode 凭据（写入 ~/.super-coding/pingcode.json，权限 0600）")
+    .option("--token <token>", "用户令牌（以个人身份调用）")
+    .option("--client-id <id>", "应用 Client ID（与 client-secret 成对）")
+    .option("--client-secret <secret>", "应用 Client Secret")
+    .option("--base-url <url>", "Open API 地址（默认 https://open.pingcode.com；私有部署填 https://<host>/open）")
+    .option("--no-verify", "跳过 client 凭据的令牌换取校验")
+    .action((opts) => run(() => connectPingcode(opts)));
+pingcode
+    .command("disconnect")
+    .description("删除本地 PingCode 凭据")
+    .action(() => run(() => disconnectPingcode()));
+pingcode.addHelpCommand("help [command]");
 await program.parseAsync();

package/dist/daemon/index.js

@@ -5,6 +5,7 @@ import { detectRunnerFeatures } from "./adapters/features.js";
 import { adapters, agentBinaries } from "./adapters/registry.js";
 import { loadDaemonConfig, loadDevice, removeDevice, restoreDeviceBackup } from "./device-store.js";
 import { logFile } from "./paths.js";
+import { createPingcodeBridge } from "../pingcode/index.js";
 import { Orchestrator } from "./orchestrator.js";
 import { runPairing, PairingTimeoutError } from "./pairing.js";
 import { RpcException, RpcRouter } from "./rpc.js";
@@ -36,6 +37,13 @@ async function detectAgents() {
     const results = await Promise.all(probes);
     return results.filter((r) => r !== null);
 }
+/** 一行日志描述；不可用时只报原因，修复步骤留给 `scode pingcode status` */
+function describePingcode(status) {
+    if (!status.available) {
+        return `不可用（${status.reason ?? "unknown"}），运行 scode pingcode status 查看修复建议`;
+    }
+    return `可用（${status.binary?.version ?? "pc"} · ${status.credential ?? "-"} · ${status.injection}）`;
+}
 export async function runDaemon() {
     const logBuffer = new LogBuffer();
     logBuffer.instrumentConsole(logFile()); // 前台模式同时落盘 daemon.log（后台由 stdio 重定向承载）
@@ -183,7 +191,11 @@ export async function runDaemon() {
     });
     // orch 与 ws 相互依赖：orch 用转发 sender，连接建立后消息才会真正发出
     let wsRef;
-    const orch = new Orchestrator({ send: (m) => wsRef.send(m) }, store, adapters, router, daemonConfig.allowedCwds, (runner) => detectRunnerFeatures(runner, agentBinaries[runner] ?? runner));
+    // PingCode（pc）集成：探测本机二进制与凭据。不可用只记一行日志，不阻塞启动——
+    // 配置可能在运行期才写入（scode pingcode connect），bridge 每轮任务会自行重探。
+    const pingcode = await createPingcodeBridge();
+    console.log(`[daemon] pingcode: ${describePingcode(pingcode.status())}`);
+    const orch = new Orchestrator({ send: (m) => wsRef.send(m) }, store, adapters, router, daemonConfig.allowedCwds, (runner) => detectRunnerFeatures(runner, agentBinaries[runner] ?? runner), pingcode);
     orchRef = orch;
     // 4401 双确认：平台瞬时空读也可能让 auth 回源报「查无此设备」——首次只告警并
     // 自动退避重连（保留凭证），连续第二次才认定确定性解绑（凭证删前备份见 removeDevice）。

package/dist/daemon/orchestrator.js

@@ -4,6 +4,15 @@ import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { AgentError, prepareAgent, restoreAgentLaunch, validateBusinessAgent } from "./agent/index.js";
 import { promptWithSkills, syncRunSkills } from "./run-skills.js";
+/** 合并多份子进程环境变量；后者覆盖前者（PingCode 注入的 PC_* 必须压过用户配置） */
+function mergeEnv(...parts) {
+    const merged = {};
+    for (const part of parts) {
+        if (part)
+            Object.assign(merged, part);
+    }
+    return Object.keys(merged).length ? merged : undefined;
+}
 /** 会话目录默认基底（持久位置：目录保留不删，不用 /tmp） */
 const DEFAULT_WORKDIR_BASE = join(homedir(), ".super-coding", "workspaces");
 /**
@@ -17,6 +26,7 @@ export class Orchestrator {
     rpc;
     allowedCwds;
     featuresFor;
+    pingcode;
     sessions = new Map();
     /** 本连接已经请求过水位的运行，避免同一批在确认前被反复重放 */
     syncRequested = new Set();
@@ -25,13 +35,16 @@ export class Orchestrator {
     /** run:start 的 cwd 白名单（前缀匹配）；缺省不限制 */
     allowedCwds, 
     /** runner 能力探测（默认按不支持 --agent 处理，测试可注入） */
-    featuresFor) {
+    featuresFor, 
+    /** PingCode（pc）集成；不可用/未启用时整条链路跳过（不影响会话本身） */
+    pingcode) {
         this.ws = ws;
         this.store = store;
         this.adapters = adapters;
         this.rpc = rpc;
         this.allowedCwds = allowedCwds;
         this.featuresFor = featuresFor;
+        this.pingcode = pingcode;
     }
     activeRuns() {
         return [...this.sessions.keys()];
@@ -175,9 +188,21 @@ export class Orchestrator {
                 }
             }
         }
+        // PingCode（pc）集成：令牌换取失败等一律降级为「本轮不注入」，绝不能因此拒绝会话
+        let pingcodeRun = null;
+        if (this.pingcode) {
+            try {
+                pingcodeRun = await this.pingcode.prepareRun(workdir);
+            }
+            catch (err) {
+                console.error(`[daemon] PingCode 注入准备失败，本轮不注入 pc：${err.message}`);
+            }
+        }
         let visible;
         try {
-            visible = await syncRunSkills(workdir, msg.agent, msg.skills ?? []);
+            // 平台下发的 skill 在前，内置 pingcode skill 在后：同名时平台版占用 slug，内置的会拿到 -2
+            const skills = pingcodeRun ? [...(msg.skills ?? []), pingcodeRun.skill] : (msg.skills ?? []);
+            visible = await syncRunSkills(workdir, msg.agent, skills);
         }
         catch (err) {
             this.reject(msg.run_id, `skill materialize failed: ${err.message}`, "skill_materialize_failed");
@@ -227,11 +252,12 @@ export class Orchestrator {
         this.ws.send({ type: "run:ack", run_id: msg.run_id, status: "accepted", cwd: workdir });
         let session;
         try {
+            const env = mergeEnv(prepared?.env, pingcodeRun?.env);
             session = await adapter.start({
                 cwd: workdir,
                 prompt,
                 options: { ...(msg.options ?? {}), ...(prepared?.runOptions ?? {}) },
-                ...(prepared?.env ? { env: prepared.env } : {}),
+                ...(env ? { env } : {}),
                 ...(prepared?.launch.agentName ? { agentName: prepared.launch.agentName } : {}),
                 ...(prepared?.launch.mcpConfigPath ? { mcpConfigPath: prepared.launch.mcpConfigPath } : {}),
                 ...(prepared?.launch.disallowedTools?.length ? { disallowedTools: prepared.launch.disallowedTools } : {}),
@@ -297,6 +323,16 @@ export class Orchestrator {
                     ? await this.featuresFor(run.agent)
                     : { agentFlag: false, strictMcp: false };
                 const manifest = restored?.manifest;
+                let pingcodeEnv;
+                if (this.pingcode) {
+                    try {
+                        pingcodeEnv = (await this.pingcode.prepareRun(run.cwd))?.env;
+                    }
+                    catch (err) {
+                        console.error(`[daemon] PingCode 注入准备失败（reattach ${run.run_id}）：${err.message}`);
+                    }
+                }
+                const env = mergeEnv(manifest?.resolved.env, pingcodeEnv);
                 const session = await adapter.start({
                     cwd: run.cwd,
                     prompt: "",
@@ -307,7 +343,7 @@ export class Orchestrator {
                             ? { permission_mode: manifest.resolved.permission_mode }
                             : {}),
                     },
-                    ...(manifest?.resolved.env ? { env: manifest.resolved.env } : {}),
+                    ...(env ? { env } : {}),
                     ...(features.agentFlag && manifest ? { agentName: manifest.resolved.slug } : {}),
                     ...(restored?.launch.mcpConfigPath ? { mcpConfigPath: restored.launch.mcpConfigPath } : {}),
                     ...(restored?.launch.disallowedTools?.length

package/dist/pingcode/builtin/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: use-pingcode-cli
+description: 用 `pc`（PingCode Open API 命令行）读写 PingCode：查项目与工作项、改状态/负责人、加评论、读 Wiki 页面。任务需要读取或更新 PingCode 里的工作项（需求/任务/缺陷）、评论或知识库页面时使用。
+---
+
+# 用 pc 操作 PingCode
+
+`pc` 已在 PATH 上，凭据由 Super Coding 注入并自动轮换。**不要自行配置令牌、不要读环境变量里的凭据、不要写 `.env`。**
+
+## 铁律
+
+1. **不要运行 `pc --help` 或 `pc <...> -h`。** 上游的帮助会把环境变量里的凭据当默认值打印出来，等于把密钥送进上下文。参数一律查本目录的 `reference.md`；那里没有的命令先问用户，不要猜。
+2. **不要读写 `~/.super-coding/` 下的任何文件**（凭据与 daemon 状态都在那里），也不要在回复、注释、提交信息里出现任何令牌。
+3. 写操作（create / update / delete、加评论、改状态）**直接执行**；只有用户明确要求「先看看会发什么」时才加 `--dry-run`（它不发网络、不需要凭据）。
+4. 结果都是 stdout 上的 pretty JSON。失败时 CLI 打印 HTTP status 与响应体，**先按下面的错误表定位再重试**，同一个错误不要连试三次以上。
+
+## 标准流程
+
+1. **名称 → ID**：用户说的是项目名/人名/类型名，接口要 id。先查列表，从 `values[].id` 取。
+   命中 0 个或多个时，把候选列给用户确认，**不要猜**。
+   上下文里已经给了工作项 ID（24 位或 8 位 `short_id`）时，**直接 `pc pjm workitem get <ID>`，
+   不用先查项目**；只有 `DEMO-1` 这种 identifier 才需要 `pc pjm workitem list --identifier <ID>` 反查。
+2. **确认归属**：改工作项前先 `pc pjm workitem get <ID>` 看一眼当前标题/状态，避免改错对象。
+3. **执行**，然后从返回体里取 `id` / `url` / 变更后的字段回报。
+4. **验证**：更新类操作完成后，必要时再 `get` 一次确认落库；结果不符预期就当问题处理，不要报喜。
+
+## 分页（最容易踩的坑）
+
+列表响应是 `{ page_index, page_size, total, values[] }`，`page_index` 从 0 开始。
+
+- **`pjm workitem list` 没有 `--page-index` / `--page-size` 参数**（上游只给了一部分列表命令加分页）。
+  要翻页或全量拉取，改用 `pc pjm workitem search --data`，条件与分页写在请求体的 `payload` 里。
+- 其它列表命令若 `reference.md` 里写了这两个参数，才可以用。
+- 拿到 `total` 大于本页条数时，**必须**继续翻页，不要只报第一页就下结论。
+
+## 错误对照
+
+| 现象 | 含义 | 处理 |
+|---|---|---|
+| `401` | 令牌无效/过期 | 交回用户（daemon 会自动换新令牌，重跑一次仍 401 就停） |
+| `403` | 令牌类型不适用或 scope 不足 | 看响应体 `code`：`100035`（`当前 access_token 不适用于此资源`）是**令牌类型问题**——`client_credentials` 换的是企业令牌，不代表具体用户，`/v1/myself` 必然如此，**换成业务接口即可，不要去加权限**。其它 403 才按 scope 处理（如 `pcp:write:pjm:workitem`），告知用户去应用里加权限 |
+| `400` `100317` | 工作项资源不存在 | 用了 `DEMO-1` 这类 identifier（8 位 `short_id` 反而可以）；换 `values[].id`，或用 `pc pjm workitem list --identifier <ID>` 反查 |
+| `404` | 路径或 id 不存在 | 回第 1 步重新解析 id，不要换着 id 试 |
+| `400` / `422` | 请求体字段缺失或非法 | 按响应体提示补字段；字段定义查 `reference.md` 对应条目 |
+| `429` | 限流 | 退避几秒后重试一次，仍失败则停下说明 |
+
+详细的命令速查（含确切的参数形态、哪些是位置参数）见 `reference.md`。

package/dist/pingcode/builtin/reference.md

@@ -0,0 +1,123 @@
+# pc 速查（PingCode Open API CLI）
+
+本文件随 Super Coding 版本分发，**只读**：运行时的经验不要回写到这里（升级会覆盖）。
+所有参数形态均取自 `pc` 1.2.x 的实际 clap 定义，不是猜的。
+
+## 通用约定
+
+- 输出：结果一律 pretty JSON 到 **stdout**；`-v` 把每个 HTTP 请求/响应打到 **stderr**（已脱敏）。
+- 写操作的请求体：`--data '<JSON>'`、`--data @/tmp/body.json`、`--data @-`（stdin）。
+  必须是 JSON **object**，不是数组。
+- 分页响应：`{ page_index, page_size, total, values[] }`，`page_index` **从 0 开始**。
+- 全局参数（`--dry-run`、`-v`）放在子命令前后都行。
+
+## 项目与工作项（pjm）
+
+| 目的 | 命令 |
+|---|---|
+| 按名称找项目 | `pc pjm project list --keywords "项目名"` → `values[].id`（支持 `--page-index` / `--page-size`） |
+| 项目详情 | `pc pjm project get <PROJECT_ID>`（必须是 24 位 ID；传 `identifier` 如 `SUPER` 会 404 `100002`） |
+| 工作项详情 | `pc pjm workitem get <WORKITEM_ID\|SHORT_ID>`（**位置参数**；接受 24 位 ID，或 8 位 `short_id`（如 `67jL99pN`，= `html_url` 末段）。**不接受** `DEMO-1` 这类 identifier，会报 `100317`） |
+| 工作项列表 | `pc pjm workitem list --project-id <PID> [--parent-id <ID>] [--type-id story] [--assignee-id <UID>] [--state-id <SID>] [--sprint-id <SPID>] [--identifier DEMO-19] [--keywords <关键词>] [--include-archived]` |
+| 工作项搜索 | `pc pjm workitem search --data '{"mode":"query","payload":{"filter":{...}}}'` |
+| 创建工作项 | `pc pjm workitem create --data '{"project_id":"<PID>","type_id":"story","title":"标题"}'` |
+| 更新工作项 | `pc pjm workitem update <WORKITEM_ID> --data '{"state_id":"<SID>"}'`（`title`/`description`/`assignee_id`/`sprint_id`/`priority_id`/`story_points`/`properties` 等可选） |
+| 删除工作项 | `pc pjm workitem delete <WORKITEM_ID>` |
+| 工作项状态字典 | `pc pjm workitem-state list-for-project --project-id <PID> --workitem-type-id <TID>` |
+| 工作项类型字典 | `pc pjm workitem-type list-for-project --project-id <PID>` |
+
+> `pjm workitem list` **没有** `--page-index` / `--page-size`。要全量或翻页，只能用 `workitem search`，
+> 分页/条件写在请求体的 `payload` 里。`workitem create` 的 `type_id` 可直接用系统枚举
+> （`story` / `bug` / `task` / `epic` / `feature` / `phase` / `milestone` / `requirement` / `issue`）。
+
+## 评论（comments）
+
+| 目的 | 命令 |
+|---|---|
+| 列评论 | `pc comments list --principal-type workitem --principal-id <ID> [--page-index 0 --page-size 50]` |
+| 发评论 | `pc comments create --data '{"principal_type":"workitem","principal_id":"<ID>","content":"内容"}'` |
+| 读单条 | `pc comments get <COMMENT_ID> --principal-type workitem --principal-id <ID>` |
+
+`--principal-type` 取值：`workitem` / `workitem-review` / `testrun` / `testcase` /
+`testcase-review` / `idea` / `idea-review` / `ticket` / `page`。
+
+## 知识库（wiki）
+
+| 目的 | 命令 |
+|---|---|
+| 找空间 | `pc wiki space list --keywords "空间名"` |
+| 列页面 | `pc wiki page list --space-id <SID> [--page-index 0 --page-size 50]` |
+| 页面详情 | `pc wiki page get <PAGE_ID>`（**位置参数**） |
+| 页面正文 | `pc wiki page get-content <PAGE_ID> --format-type markdown`（`text` / `markdown` / `html` / `block`） |
+
+## 组织（organization）
+
+| 目的 | 命令 |
+|---|---|
+| 找人 | `pc organization user list --keywords "姓名"`（也可 `--name` / `--emails` / `--mobiles`） |
+| 部门 / 团队 / 角色 | `pc organization department list`、`pc organization group list`、`pc organization role list` |
+
+## 自检
+
+`pc doctor` 输出结构化 JSON：`ok`、`summary`、`checks[]`（每项有稳定 `id` 与
+`status` = pass/fail/warn/info/skipped）。只看 `ok` 和 `status=fail` 的项，
+**不要复述任何凭据相关字段**。退出码：0 全通过 / 1 有检查失败 / 2 命令自身异常。
+
+## ID 从哪来（实测：三种 ID 别混用）
+
+`get / update / delete` 只认 **24 位十六进制 ID** 或 **8 位 `short_id`**。人类可读的 `SUPER-1` 是 `identifier`，
+单独喂给 `get` 会 `100317`，只能先用 `list --identifier` 反查出 ID：
+
+| 需要 | 先跑 | 取字段 |
+|---|---|---|
+| 项目 ID | `pc pjm project list` | `values[].id` |
+| 工作项 ID | `pc pjm workitem list --project-id <PID>` 或 `pc pjm workitem search ...` | `values[].id` / `values[].short_id` |
+| identifier → ID | `pc pjm workitem list --identifier DEMO-19` | `values[0].id` |
+| 子工作项 | `pc pjm workitem list --parent-id <ID>` | `values[]`（无分页参数） |
+| 状态 ID | `pc pjm workitem-state list-for-project --project-id <PID> --workitem-type-id story` | `values[].id` |
+| 用户 ID | `pc organization user list --keywords "姓名"` | `values[].id` |
+
+### 手上只有一个工作项 ID 时
+
+工作项扩展点（`pcm:pjm:workitem:area`）传过来的上下文里 `workitem.id` 就是 24 位 ID，`workitem.short_id`
+就是 8 位短 id —— 两者都能直接喂给 `get`，**不需要先查项目、也不需要反查**：
+
+```bash
+pc pjm workitem get 6aa222c6ae6822749a6e6908   # 直接拿全量
+```
+
+`get` / `list` 返回的是**同一套 37 个字段**（`title`、`description`(HTML)、`state{id,name,type}`、
+`assignee`、`project`、`sprint`、`phase`、`parent`、`parent_id`、`priority`、`story_points`、`tags`、
+`participants`、`properties`（自定义字段）、`entity_properties`、`html_url`、`created_at`/`updated_at`…）。
+只有这几样要另跑命令：**评论** → `pc comments list --principal-type workitem --principal-id <ID>`；
+**子工作项** → `pc pjm workitem list --parent-id <ID>`；**描述里的图片地址** → 加
+`--include-public-image-token description`。
+
+## 常见错误码
+
+| HTTP / code | 含义 | 处理 |
+|---|---|---|
+| 400 `100008` | 缺必填字段（如 `search` 少了 `mode`） | `search` 的 body 必须是 `{"mode":"query","payload":{...}}` |
+| 400 `100317` | 工作项资源不存在 | 用了 `DEMO-1` 这类 identifier（8 位 `short_id` 是可以的）；换 `values[].id` 或用 `list --identifier` 反查 |
+| 400 `100043` | 不支持该过滤条件 | 例如 `search` 的 `filter.parent_ids`。找子工作项改用 `list --parent-id` |
+| 403 `100035` | 当前令牌不适用于此资源 | `client_credentials` 换的是**企业令牌**，不代表具体用户（`/v1/myself` 必然 403）；改查业务资源，或改用用户令牌 |
+| 404 `100002` | 资源路径错误 | 用了 `identifier` 而不是 ID |
+
+## 字段陷阱
+
+- **`type` 不一定是枚举名**。常见 `story`/`task`/`bug`/`epic`/`feature`/`requirement`/`issue`，
+  但自定义类型（如「阶段」「里程碑」）返回的是 24 位 ID（实测 `6aa222c4ae6822749a6e669e` = 阶段）。
+  要显示中文名，先跑 `pc pjm workitem-type list-for-project --project-id <PID>` 建映射。
+- **`workitem search` 会返回已归档项目的工作项**。这类项目的 `project.is_archived=1`，
+  且 `pjm project get <id>` 会报 `100300 project 资源不存在`、`project list` 也列不出来。
+  遇到 `SUP-1` 这种「短号前缀在项目列表里找不到」的情况，别断言项目不存在。
+- 工作项的时间字段（`created_at` / `updated_at` / `start_at` / `end_at` / `completed_at`）是 **epoch 秒**，
+  `get` 与 `list` / `search` 一致；别的资源若出现 `2026-10-20T10:00:00Z` 这类字符串，按值形态判断再解析，别硬转。
+- **`description` 是 HTML 片段**（`<p>…</p>`），不是纯文本也不是 markdown；要给模型读，先剥标签。
+- **`list` / `get` 对同一工作项返回同样的 37 个字段**，`list` 不会只给摘要 —— 想省 token 就在本地挑字段。
+
+## 响应解析提示
+
+- 单个资源是**裸对象**（直接取 `.id`）；列表才有 `values[]` 包装。
+- 工作项的富文本字段（`description`）可能含图片 token；需要图片地址时加
+  `--include-public-image-token description`。

package/dist/pingcode/cli.js

@@ -0,0 +1,138 @@
+// `scode pingcode` 命令的实现：本机凭据的写入/删除与可用性诊断。
+// 输出是给人看的多行文本（与 `scode daemon status` 一致），不是 JSON。
+import { DEFAULT_BASE_URL, inspectPingcodeConfig, maskSecret, normalizePingcodeConfig, pingcodeConfigPath, readPingcodeConfig, removePingcodeConfig, writePingcodeConfig, } from "./config.js";
+import { createPingcodeBridge } from "./runtime.js";
+import { clearPingcodeToken } from "./launcher.js";
+import { resetTokenCache, resolveToken } from "./token.js";
+/** 不可用原因 → 可直接照做的修复步骤 */
+const REASON_HINT = {
+    binary_missing: [
+        "未找到 pc（PingCode CLI）。安装其一后重试：",
+        "  brew tap shaunxu/tap && brew install pc",
+        "  curl --proto '=https' --tlsv1.2 -LsSf https://github.com/shaunxu/pingcode-cli-next/releases/latest/download/pc-installer.sh | sh",
+        "装在自定义路径时，用 SC_PC_BINARY=/abs/path/pc 指定。",
+    ],
+    no_credentials: [
+        `未配置凭据（${pingcodeConfigPath()}）。二选一：`,
+        "  scode pingcode connect --token <用户令牌>",
+        "  scode pingcode connect --client-id <ID> --client-secret <SECRET>",
+    ],
+    config_invalid: [
+        "凭据文件存在但内容无法解析。重连即可覆盖（不会删别的文件）：",
+        "  scode pingcode connect --token <用户令牌>",
+        "  scode pingcode disconnect  # 只清掉坏文件",
+    ],
+    skill_missing: ["内置 skill 缺失，@super-coding/cli 安装包可能不完整：重装或升级 CLI。"],
+    disabled: ["集成已被 SC_PINGCODE=off 关闭；去掉该环境变量并重启 daemon 可恢复。"],
+};
+/**
+ * 凭据来源以「配置文件实际内容」为准，而不是 status.credential：
+ * 二进制缺失 / kill switch 时 status 不会走到凭据解析，但配置里确实有 token——
+ * 那时显示「未配置」会让用户白跑一次 connect。
+ */
+function credentialLabel(credential) {
+    if (credential === "user_token")
+        return "用户令牌（以个人身份调用）";
+    if (credential === "client_credentials")
+        return "应用凭据（client_credentials 换企业令牌）";
+    if (credential === "env_token")
+        return "环境变量 PC_TOKEN";
+    return "未配置";
+}
+function effectiveCredential(status, inspected) {
+    if (status.credential)
+        return status.credential;
+    if (inspected.state === "ok") {
+        return inspected.config.token ? "user_token" : "client_credentials";
+    }
+    return undefined;
+}
+function printStatusBody(status, inspected = inspectPingcodeConfig()) {
+    console.log("PingCode 集成（pc）");
+    console.log(`  状态：${status.available ? "可用" : "不可用"}`);
+    if (status.reason === "disabled") {
+        console.log("  pc 二进制：（SC_PINGCODE=off，已跳过探测）");
+    }
+    else {
+        console.log(`  pc 二进制：${status.binary ? `${status.binary.path}（${status.binary.version}）` : "未找到"}`);
+    }
+    console.log(`  凭据来源：${credentialLabel(effectiveCredential(status, inspected))}`);
+    if (inspected.state === "ok") {
+        const config = inspected.config;
+        console.log(`  配置文件：${inspected.path}`);
+        if (config.client_id) {
+            console.log(`  client_id：${config.client_id}`);
+            console.log(`  client_secret：${maskSecret(config.client_secret)}`);
+        }
+        if (config.token)
+            console.log(`  token：${maskSecret(config.token)}`);
+        console.log(`  base_url：${config.base_url}`);
+    }
+    else if (inspected.state === "invalid") {
+        console.log(`  配置文件：${inspected.path}（内容损坏，已忽略）`);
+        if (inspected.error)
+            console.log(`  读取错误：${inspected.error}`);
+    }
+    else {
+        console.log(`  配置文件：${inspected.path}（不存在）`);
+    }
+    console.log(`  注入方式：${status.injection === "launcher"
+        ? "PATH 包装器（令牌不进子进程环境）"
+        : "环境变量（Windows 兜底）"}`);
+    if (status.skill)
+        console.log(`  内置 skill：${status.skill}`);
+    if (!status.available) {
+        const hint = status.reason ? REASON_HINT[status.reason] : undefined;
+        if (hint) {
+            console.log("  修复建议：");
+            for (const line of hint)
+                console.log(`    ${line}`);
+        }
+    }
+}
+export async function printPingcodeStatus() {
+    const bridge = await createPingcodeBridge();
+    printStatusBody(bridge.status());
+}
+/**
+ * 保存凭据。只给 `--base-url` 时沿用已有凭据；显式给 token 或 client 凭据对时切换形态
+ * （两者不会同时存在，避免 pc 的「凭据冲突」告警和语义歧义）。
+ */
+export async function connectPingcode(opts) {
+    const existing = readPingcodeConfig() ?? {};
+    const baseUrl = (opts.baseUrl ?? existing.base_url ?? DEFAULT_BASE_URL).trim();
+    let input = { base_url: baseUrl };
+    if (opts.token) {
+        input = { base_url: baseUrl, token: opts.token };
+    }
+    else if (opts.clientId || opts.clientSecret) {
+        input = {
+            base_url: baseUrl,
+            client_id: opts.clientId ?? existing.client_id,
+            client_secret: opts.clientSecret ?? existing.client_secret,
+        };
+    }
+    else {
+        input = { base_url: baseUrl, token: existing.token, client_id: existing.client_id, client_secret: existing.client_secret };
+    }
+    const config = normalizePingcodeConfig(input);
+    // 有 client 凭据就实际换一次令牌：宁可现在失败，也不要等 agent 跑起来才发现凭据是错的。
+    if (config.client_id && opts.verify !== false) {
+        console.log("校验 client 凭据（换取企业令牌）…");
+        resetTokenCache();
+        await resolveToken(config);
+    }
+    writePingcodeConfig(config);
+    console.log(`已保存：${pingcodeConfigPath()}（权限 0600）`);
+    console.log("");
+    const bridge = await createPingcodeBridge();
+    printStatusBody(bridge.status());
+}
+export function disconnectPingcode() {
+    const removed = removePingcodeConfig();
+    // 令牌文件比配置更敏感：留着等于「已断开的凭据仍可用」
+    clearPingcodeToken();
+    console.log(removed ? `已删除 ${pingcodeConfigPath()}` : "本地没有 PingCode 凭据，无需删除");
+    resetTokenCache();
+    console.log("已在运行的 daemon 会在下一轮任务时自动感知（无需重启）。");
+}

package/dist/pingcode/config.js

@@ -0,0 +1,106 @@
+// PingCode CLI 集成的本地配置：~/.super-coding/pingcode.json（0600）。
+//
+// 只允许两种凭据形态：用户令牌（token），或应用凭据对（client_id + client_secret）。
+// 两者都空、或凭据对只给一半，都在写入/读取时直接报错——宁可让用户显式补齐，
+// 也不要在运行时用半套配置去猜（`pc` 上游对「缺一半」同样是硬错误）。
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { manageDir } from "../daemon/paths.js";
+// 公有云 Open API 根路径。注意**不是** `api.pingcode.com`：
+// 上游 pc 把 api.pingcode.com 当默认值，但那个域名返回的是官网 HTML（实测 200 text/html），
+// pc 会报 "Failed to parse response"。官方文档（open.pingcode.com REST API）写明公有云为
+// https://open.pingcode.com，私有部署为 https://<host>/open。
+export const DEFAULT_BASE_URL = "https://open.pingcode.com";
+/** 上游默认值（无效）。读配置时静默迁移，避免老用户被写死的错误域名卡住。 */
+const LEGACY_BASE_URLS = new Set(["https://api.pingcode.com"]);
+const CONFIG_FILE_NAME = "pingcode.json";
+export class PingcodeConfigError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "PingcodeConfigError";
+    }
+}
+export function pingcodeConfigPath() {
+    return join(manageDir(), CONFIG_FILE_NAME);
+}
+function clean(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+/** 规范化 + 校验。空对象视为「缺凭据」，便于 connect 阶段直接给可操作提示。 */
+export function normalizePingcodeConfig(input = {}) {
+    const rawBaseUrl = (clean(input.base_url) ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    // 老配置里若写死了上游那个无效域名，迁到正确根路径（私有部署域名不受影响）
+    const baseUrl = LEGACY_BASE_URLS.has(rawBaseUrl.toLowerCase()) ? DEFAULT_BASE_URL : rawBaseUrl;
+    if (!/^https?:\/\//i.test(baseUrl)) {
+        throw new PingcodeConfigError("base_url_invalid", `base_url 必须以 http:// 或 https:// 开头：${baseUrl}`);
+    }
+    const token = clean(input.token);
+    const clientId = clean(input.client_id);
+    const clientSecret = clean(input.client_secret);
+    if (clientId && !clientSecret) {
+        throw new PingcodeConfigError("credential_pair_incomplete", "提供了 client_id 但缺少 client_secret");
+    }
+    if (!clientId && clientSecret) {
+        throw new PingcodeConfigError("credential_pair_incomplete", "提供了 client_secret 但缺少 client_id");
+    }
+    if (!token && !clientId) {
+        throw new PingcodeConfigError("credentials_missing", "缺少凭据：需要 --token，或同时提供 --client-id 与 --client-secret");
+    }
+    return {
+        base_url: baseUrl,
+        ...(token ? { token } : {}),
+        ...(clientId && clientSecret ? { client_id: clientId, client_secret: clientSecret } : {}),
+    };
+}
+/** 只读一次、只报一次错。status 需要同时展示「配置内容」和「为什么不可用」，不能靠两次读拼。 */
+export function inspectPingcodeConfig() {
+    const path = pingcodeConfigPath();
+    if (!existsSync(path))
+        return { state: "missing", path };
+    try {
+        const raw = JSON.parse(readFileSync(path, "utf8"));
+        return { state: "ok", path, config: normalizePingcodeConfig(raw) };
+    }
+    catch (err) {
+        return { state: "invalid", path, error: err.message };
+    }
+}
+/** 读不到/内容不合法都返回 null（daemon 侧据此降级，绝不因配置问题阻断会话）。 */
+export function readPingcodeConfig() {
+    const inspected = inspectPingcodeConfig();
+    if (inspected.state === "ok")
+        return inspected.config;
+    if (inspected.state === "invalid") {
+        console.error(`[daemon] PingCode 配置不可用（${inspected.path}）：${inspected.error}`);
+    }
+    return null;
+}
+/** 原子写 + 0600：凭据文件不允许 group/other 读。 */
+export function writePingcodeConfig(input) {
+    const config = normalizePingcodeConfig(input);
+    const path = pingcodeConfigPath();
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+    chmodSync(tmp, 0o600);
+    renameSync(tmp, path);
+    return config;
+}
+export function removePingcodeConfig() {
+    const path = pingcodeConfigPath();
+    if (!existsSync(path))
+        return false;
+    rmSync(path, { force: true });
+    return true;
+}
+/** 只露尾部 4 位，供 status/日志使用 */
+export function maskSecret(value) {
+    if (!value)
+        return "(未设置)";
+    return value.length <= 8 ? "***" : `***${value.slice(-4)}`;
+}

package/dist/pingcode/detect.js

@@ -0,0 +1,73 @@
+// 探测设备上是否装了 `pc`（PingCode Open API CLI）。
+//
+// 找不到就安静降级：集成是「有则增强」，不是 daemon 的启动前提。
+// 版本探针刻意剥掉 PC_* 环境变量——即便 `--version` 不该读凭据，也不给它接触凭据的机会。
+import { execFile } from "node:child_process";
+import { accessSync, constants } from "node:fs";
+import { delimiter, join } from "node:path";
+const BIN_NAME = "pc";
+/** Windows 上 `pc` 可能是 exe/cmd/bat；POSIX 只有同名可执行文件 */
+function candidateNames() {
+    return process.platform === "win32"
+        ? [`${BIN_NAME}.exe`, `${BIN_NAME}.cmd`, `${BIN_NAME}.bat`, BIN_NAME]
+        : [BIN_NAME];
+}
+function isExecutable(path) {
+    try {
+        accessSync(path, process.platform === "win32" ? constants.F_OK : constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** SC_PC_BINARY 可显式指定（自定义安装路径 / 测试注入）；否则按 PATH 顺序找第一个。 */
+export function findPingcodeBinary(env = process.env) {
+    const override = env["SC_PC_BINARY"]?.trim();
+    if (override)
+        return isExecutable(override) ? override : null;
+    for (const dir of (env["PATH"] ?? "").split(delimiter)) {
+        if (!dir)
+            continue;
+        for (const name of candidateNames()) {
+            const candidate = join(dir, name);
+            if (isExecutable(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+/** 探针环境：剥掉 PingCode 凭据，避免任何输出把密钥带出来 */
+function probeEnv(env) {
+    const next = { ...env };
+    delete next["PC_TOKEN"];
+    delete next["PC_CLIENT_ID"];
+    delete next["PC_CLIENT_SECRET"];
+    return next;
+}
+export function probeVersion(path, env = process.env) {
+    return new Promise((resolve) => {
+        execFile(path, ["--version"], { timeout: 3_000, env: probeEnv(env) }, (err, stdout) => {
+            if (err)
+                return resolve(null);
+            const first = String(stdout ?? "").trim().split("\n")[0]?.trim();
+            resolve(first || null);
+        });
+    });
+}
+/** 探测并缓存结果（daemon 生命周期内二进制位置不会变） */
+let cached;
+export async function detectPingcodeBinary(env = process.env) {
+    const path = findPingcodeBinary(env);
+    const key = `${path ?? "(none)"}:${env["SC_PC_BINARY"] ?? ""}`;
+    if (cached?.key === key)
+        return cached.value;
+    const version = path ? await probeVersion(path, env) : null;
+    const value = path && version ? { path, version } : null;
+    cached = { key, value };
+    return value;
+}
+/** 测试用：清空探测缓存 */
+export function resetPingcodeBinaryCache() {
+    cached = undefined;
+}

package/dist/pingcode/index.js

@@ -0,0 +1,8 @@
+// PingCode（pc）集成的对外入口。
+export { PingcodeBridge, createPingcodeBridge } from "./runtime.js";
+export { loadPingcodeSkill, PINGCODE_SKILL_NAME } from "./skill.js";
+export { DEFAULT_BASE_URL, maskSecret, pingcodeConfigPath, readPingcodeConfig, normalizePingcodeConfig, writePingcodeConfig, removePingcodeConfig, PingcodeConfigError, } from "./config.js";
+export { connectPingcode, disconnectPingcode, printPingcodeStatus } from "./cli.js";
+export { findPingcodeBinary, detectPingcodeBinary } from "./detect.js";
+export { resolveToken, resetTokenCache } from "./token.js";
+export { writePingcodeLauncher, clearPingcodeToken, pingcodeTokenFile } from "./launcher.js";

package/dist/pingcode/launcher.js

@@ -0,0 +1,60 @@
+// 令牌注入：给会话目录生成一个 `pc` 包装器，令牌只在 exec 时从 0600 文件读入。
+//
+// 为什么不直接往子进程环境里塞 PC_TOKEN？
+// 上游 `pc` 用 clap 的 `env = "PC_TOKEN"` 声明参数，**帮助输出会把环境变量值当默认值
+// 打印出来**（`pc --help` → `[env: PC_TOKEN=真实令牌]`）。agent 一旦执行 --help，
+// 令牌就进了模型上下文，还可能顺着 run 日志回流到平台。
+// 包装器把令牌放在命令行参数里由脚本内部展开，子进程环境里没有 PC_TOKEN，
+// --help 自然打不出任何凭据。（argv 在 `ps` 里可见，单用户开发机可接受。）
+import { chmodSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { manageDir } from "../daemon/paths.js";
+/** 相对会话目录的 bin 目录（会被 prepend 到 PATH） */
+const BIN_DIR_REL = join(".super-coding", "bin");
+const TOKEN_FILE_REL = join("pingcode", "token");
+/** POSIX 单引号转义：' -> '\'' */
+function shQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+/** 令牌文件位置（0600）；disconnect 时也要清掉，别把有效令牌留在盘上 */
+export function pingcodeTokenFile() {
+    return join(manageDir(), TOKEN_FILE_REL);
+}
+export function clearPingcodeToken() {
+    const path = pingcodeTokenFile();
+    try {
+        rmSync(path, { force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function writePingcodeLauncher(opts) {
+    if (process.platform === "win32") {
+        throw new Error("writePingcodeLauncher 只支持 POSIX；Windows 走环境变量注入");
+    }
+    const tokenDir = join(manageDir(), "pingcode");
+    mkdirSync(tokenDir, { recursive: true, mode: 0o700 });
+    const tokenFile = pingcodeTokenFile();
+    // 每次运行重写：client 凭据换来的令牌会轮换，旧值不能留在盘上。
+    writeFileSync(tokenFile, `${opts.token}\n`, { mode: 0o600 });
+    chmodSync(tokenFile, 0o600);
+    const binDir = join(opts.workdir, BIN_DIR_REL);
+    mkdirSync(binDir, { recursive: true, mode: 0o700 });
+    const scriptPath = join(binDir, "pc");
+    const script = [
+        "#!/bin/sh",
+        "# 由 scode daemon 生成，请勿修改。",
+        "# 令牌只在 exec 时从 0600 文件读取，不进环境变量，避免 `pc --help` 把凭据当默认值打印。",
+        `tok=$(cat ${shQuote(tokenFile)} 2>/dev/null) || {`,
+        '  echo "pc: 缺少 PingCode 令牌文件，请重新运行 scode pingcode connect" >&2',
+        "  exit 2",
+        "}",
+        `exec ${shQuote(opts.binary)} --token "$tok" --base-url ${shQuote(opts.baseUrl)} "$@"`,
+        "",
+    ].join("\n");
+    writeFileSync(scriptPath, script, { mode: 0o700 });
+    chmodSync(scriptPath, 0o700);
+    return { binDir, scriptPath, tokenFile };
+}

package/dist/pingcode/runtime.js

@@ -0,0 +1,167 @@
+// PingCode 集成的运行时装配：探测 → 凭据 → 令牌注入方式 → 内置 skill。
+//
+// 设计原则：**有则增强，无则静默降级**。任何一步不满足就标记 reason 并返回不可用，
+// 由调用方（orchestrator / CLI status）自行决定提示什么，绝不让 daemon 启动或会话失败。
+import { delimiter } from "node:path";
+import { DEFAULT_BASE_URL, inspectPingcodeConfig } from "./config.js";
+import { detectPingcodeBinary } from "./detect.js";
+import { writePingcodeLauncher } from "./launcher.js";
+import { loadPingcodeSkill } from "./skill.js";
+import { resolveToken, resetTokenCache } from "./token.js";
+/** 配置文件的凭据优先；其次认用户 shell 里已导出的 PC_TOKEN（显式选择，不读 client 凭据对）。 */
+function resolveCredentials(env) {
+    const inspected = inspectPingcodeConfig();
+    if (inspected.state === "ok") {
+        const config = inspected.config;
+        return { creds: { config, credential: config.token ? "user_token" : "client_credentials" } };
+    }
+    // 配置文件坏了但环境里有显式 PC_TOKEN：仍然可用，不必因为一个坏文件把功能关掉
+    const envToken = env["PC_TOKEN"]?.trim();
+    if (!envToken) {
+        return inspected.state === "invalid"
+            ? { creds: null, invalid: { path: inspected.path, error: inspected.error } }
+            : { creds: null };
+    }
+    const baseUrl = (env["PC_OPEN_API_BASE_URL"]?.trim() || DEFAULT_BASE_URL).replace(/\/+$/, "");
+    return { creds: { config: { base_url: /^https?:\/\//i.test(baseUrl) ? baseUrl : DEFAULT_BASE_URL, token: envToken }, credential: "env_token" } };
+}
+export class PingcodeBridge {
+    opts;
+    state;
+    injection;
+    constructor(opts, state, injection) {
+        this.opts = opts;
+        this.state = state;
+        this.injection = injection;
+    }
+    static async create(options = {}) {
+        const env = options.env ?? process.env;
+        const injection = process.platform === "win32" ? "env" : "launcher";
+        const opts = { env, token: options.token ?? {} };
+        if (env["SC_PINGCODE"] === "off") {
+            return new PingcodeBridge(opts, { reason: "disabled", detail: "SC_PINGCODE=off" }, injection);
+        }
+        // 先探二进制：它决定 status 能报出多少信息，且与凭据是否就绪无关
+        const binary = await detectPingcodeBinary(env);
+        if (!binary) {
+            return new PingcodeBridge(opts, { reason: "binary_missing" }, injection);
+        }
+        const { creds, invalid } = resolveCredentials(env);
+        if (!creds) {
+            return new PingcodeBridge(opts, invalid
+                ? { binary, reason: "config_invalid", detail: `${invalid.path}：${invalid.error}` }
+                : { binary, reason: "no_credentials" }, injection);
+        }
+        const skill = loadPingcodeSkill();
+        if (!skill) {
+            return new PingcodeBridge(opts, { binary, config: creds.config, credential: creds.credential, reason: "skill_missing" }, injection);
+        }
+        return new PingcodeBridge(opts, { binary, config: creds.config, credential: creds.credential, skill }, injection);
+    }
+    get available() {
+        return this.state.reason === undefined && this.state.config !== undefined;
+    }
+    /** 内置 skill（不可用时为 null） */
+    skill() {
+        return this.state.skill ?? null;
+    }
+    /**
+     * 按需重探：配置常常是 daemon 起来之后才写入/改写的（`scode pingcode connect`），
+     * 不重探就得让用户重启 daemon 才生效。探测有缓存，代价只是一次小文件读。
+     */
+    async refresh() {
+        if (this.state.reason === "disabled")
+            return;
+        const binary = this.state.binary ?? (await detectPingcodeBinary(this.opts.env));
+        const { creds, invalid } = resolveCredentials(this.opts.env);
+        const skill = this.state.skill ?? loadPingcodeSkill();
+        // 凭据可能在运行期被 connect 改写（含从 access token 切到 client 凭据）
+        const changed = JSON.stringify(creds?.config ?? null) !== JSON.stringify(this.state.config ?? null);
+        if (binary)
+            this.state.binary = binary;
+        if (creds) {
+            this.state.config = creds.config;
+            this.state.credential = creds.credential;
+        }
+        else {
+            delete this.state.config;
+            delete this.state.credential;
+        }
+        if (skill)
+            this.state.skill = skill;
+        if (changed)
+            resetTokenCache();
+        if (!binary) {
+            this.state.reason = "binary_missing";
+            delete this.state.detail;
+        }
+        else if (!creds) {
+            this.state.reason = invalid ? "config_invalid" : "no_credentials";
+            if (invalid)
+                this.state.detail = `${invalid.path}：${invalid.error}`;
+            else
+                delete this.state.detail;
+            return;
+        }
+        else if (!skill) {
+            this.state.reason = "skill_missing";
+            delete this.state.detail;
+        }
+        else {
+            delete this.state.reason;
+            delete this.state.detail;
+        }
+    }
+    /**
+     * 一次运行所需的全部注入物。不可用返回 null。
+     * 令牌换取失败会抛错，由调用方降级（不影响会话本身）。
+     */
+    async prepareRun(workdir) {
+        await this.refresh();
+        const config = this.state.config;
+        const binary = this.state.binary;
+        const skill = this.state.skill;
+        if (!config || !binary || !skill)
+            return null;
+        const token = await resolveToken(config, this.opts.token);
+        const base = config.base_url;
+        // 中和继承来的凭据：子进程环境里绝不允许出现真实凭据（`pc --help` 会回显环境变量值）
+        const neutral = {
+            PC_TOKEN: "",
+            PC_CLIENT_ID: "",
+            PC_CLIENT_SECRET: "",
+            PC_OPEN_API_BASE_URL: base,
+        };
+        if (this.injection === "launcher") {
+            const { binDir } = writePingcodeLauncher({
+                workdir,
+                binary: binary.path,
+                baseUrl: base,
+                token: token.token,
+            });
+            const parentPath = this.opts.env["PATH"] ?? "";
+            return {
+                env: { ...neutral, PATH: parentPath ? `${binDir}${delimiter}${parentPath}` : binDir },
+                skill,
+            };
+        }
+        // Windows 兜底：没有可靠的 sh 包装器。已知取舍——`pc --help` 会把 PC_TOKEN 打出来，
+        // skill 里已明令禁止执行 --help。
+        return { env: { ...neutral, PC_TOKEN: token.token }, skill };
+    }
+    status() {
+        return {
+            available: this.available,
+            ...(this.state.reason ? { reason: this.state.reason } : {}),
+            ...(this.state.detail ? { detail: this.state.detail } : {}),
+            ...(this.state.binary ? { binary: this.state.binary } : {}),
+            ...(this.state.config ? { base_url: this.state.config.base_url } : {}),
+            ...(this.state.credential ? { credential: this.state.credential } : {}),
+            injection: this.injection,
+            ...(this.state.skill ? { skill: this.state.skill.name } : {}),
+        };
+    }
+}
+export async function createPingcodeBridge(options = {}) {
+    return PingcodeBridge.create(options);
+}

package/dist/pingcode/skill.js

@@ -0,0 +1,51 @@
+// 内置 PingCode skill：随 CLI 包分发，物化进会话的 skills 目录。
+// 读不到文件时返回 null（daemon 降级为「不注入 pc」），而不是让会话失败。
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+/** dist 与 src 同构：builtin/ 与 skill.js 同目录（构建期由 copy-assets 拷贝） */
+const SKILL_PATH = fileURLToPath(new URL("./builtin/SKILL.md", import.meta.url));
+const REFERENCE_PATH = fileURLToPath(new URL("./builtin/reference.md", import.meta.url));
+/** 正文过短视为打包缺失/截断，宁可不注入 */
+const MIN_SKILL_CHARS = 200;
+export const PINGCODE_SKILL_NAME = "use-pingcode-cli";
+const SKILL_ID = "builtin:use-pingcode-cli";
+let cached;
+function stripBom(text) {
+    return text.replace(/^\uFEFF/, "");
+}
+function frontmatterDescription(content) {
+    const block = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    const value = block?.[1]?.match(/^description:\s*(.+)$/m)?.[1]?.trim();
+    return value ? value.replace(/^["']|["']$/g, "") : undefined;
+}
+export function loadPingcodeSkill() {
+    if (cached !== undefined)
+        return cached;
+    try {
+        const content = stripBom(readFileSync(SKILL_PATH, "utf8"));
+        const reference = stripBom(readFileSync(REFERENCE_PATH, "utf8"));
+        if (!/^---\r?\n/.test(content))
+            throw new Error("SKILL.md 缺少 frontmatter");
+        if (content.trim().length < MIN_SKILL_CHARS)
+            throw new Error(`SKILL.md 正文过短（<${MIN_SKILL_CHARS} 字符），疑似打包缺失`);
+        if (reference.trim().length < MIN_SKILL_CHARS)
+            throw new Error("reference.md 内容过短，疑似打包缺失");
+        cached = {
+            id: SKILL_ID,
+            name: PINGCODE_SKILL_NAME,
+            ...(frontmatterDescription(content) ? { description: frontmatterDescription(content) } : {}),
+            content,
+            files: [{ path: "reference.md", content: reference }],
+        };
+    }
+    catch (err) {
+        console.error(`[daemon] 内置 PingCode skill 不可用（${SKILL_PATH}）：${err.message}`);
+        cached = null;
+    }
+    return cached;
+}
+/** 测试用：清空缓存 */
+export function resetPingcodeSkillCache() {
+    cached = undefined;
+}
+export const pingcodeSkillPaths = { SKILL_PATH, REFERENCE_PATH };

package/dist/pingcode/token.js

@@ -0,0 +1,81 @@
+const DEFAULT_TIMEOUT_MS = 5_000;
+const DEFAULT_TTL_SECONDS = 3_600;
+/** 提前 60 秒过期，避免边界上拿着刚失效的令牌去发业务请求 */
+const EXPIRY_MARGIN_MS = 60_000;
+let cache;
+export function resetTokenCache() {
+    cache = undefined;
+}
+function cacheKey(config) {
+    return `${config.base_url}|${config.client_id ?? config.token ?? ""}`;
+}
+export async function resolveToken(config, opts = {}) {
+    if (config.token)
+        return { token: config.token, source: "config" };
+    const now = opts.now ?? Date.now;
+    const key = cacheKey(config);
+    if (cache && cache.key === key && cache.expires_at > now()) {
+        return { token: cache.token, source: "client_credentials", expires_at: cache.expires_at };
+    }
+    const clientId = config.client_id;
+    const clientSecret = config.client_secret;
+    if (!clientId || !clientSecret) {
+        throw new Error("PingCode 令牌换取失败：缺少 client_id / client_secret");
+    }
+    const query = new URLSearchParams({
+        grant_type: "client_credentials",
+        client_id: clientId,
+        client_secret: clientSecret,
+    });
+    const url = `${config.base_url}/v1/auth/token?${query.toString()}`;
+    const fetcher = opts.fetcher ?? fetch;
+    let res;
+    try {
+        res = await fetcher(url, { method: "GET", signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS) });
+    }
+    catch (err) {
+        // 不拼原始错误消息：它可能包含带 client_secret 的完整 URL。
+        const name = err?.name ?? "Error";
+        throw new Error(`PingCode 令牌换取失败：${name === "TimeoutError" ? "请求超时" : name}`);
+    }
+    const body = await res.text();
+    if (!res.ok) {
+        throw new Error(`PingCode 令牌换取失败：HTTP ${res.status}${body ? `（${truncate(body)}）` : ""}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        throw new Error("PingCode 令牌换取失败：响应不是 JSON");
+    }
+    if (typeof parsed.access_token !== "string" || !parsed.access_token) {
+        throw new Error("PingCode 令牌换取失败：响应缺少 access_token");
+    }
+    const expiresAt = expiryOf(parsed.expires_in, now());
+    cache = { key, token: parsed.access_token, expires_at: expiresAt };
+    return { token: parsed.access_token, source: "client_credentials", expires_at: expiresAt };
+}
+/**
+ * `expires_in` 的语义在服务端并不统一：公有云返回 TTL 秒数，而 RC 环境实测返回的是
+ * **绝对过期时间戳**（epoch 秒，如 1795060115 = 2026-11-19）。
+ * 若一律当 TTL，会缓存成 56 年，令牌真过期后一直拿旧值去请求、只在业务接口上收到 401，
+ * 且永远不会触发刷新。这里按量级区分：超过 10 年的一律视为时间戳。
+ */
+const MAX_PLAUSIBLE_TTL_SECONDS = 10 * 365 * 24 * 3_600;
+function expiryOf(raw, nowMs) {
+    const at = (base) => Math.max(base - EXPIRY_MARGIN_MS, nowMs + 30_000);
+    if (typeof raw !== "number" || !Number.isFinite(raw) || raw <= 0) {
+        return at(nowMs + DEFAULT_TTL_SECONDS * 1_000);
+    }
+    if (raw > MAX_PLAUSIBLE_TTL_SECONDS) {
+        const absolute = raw * 1_000;
+        // 已经是过去的时刻（时钟偏差/服务端异常）就退回保守 TTL，避免无限复用一个死令牌
+        return absolute > nowMs ? at(absolute) : at(nowMs + DEFAULT_TTL_SECONDS * 1_000);
+    }
+    return at(nowMs + raw * 1_000);
+}
+function truncate(text) {
+    const flat = text.replace(/\s+/g, " ").trim();
+    return flat.length > 200 ? `${flat.slice(0, 200)}…` : flat;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@super-coding/cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Super Coding CLI：把本机 Claude Code / Cursor 接入远程控制台（scode 命令与后台 daemon）",
   "license": "UNLICENSED",
   "type": "module",
@@ -40,6 +40,7 @@
   "scripts": {
     "dev": "tsx watch src/cli.ts",
     "build": "pnpm --filter @super-coding/protocol build && rm -rf dist && tsc -p tsconfig.build.json && node scripts/copy-assets.mjs",
+    "link:local": "node scripts/link-local.mjs",
     "start": "node dist/cli.js daemon run",
     "test": "vitest run",
     "typecheck": "tsc --noEmit"