skyloom 1.23.0 → 1.25.0

package/src/cli/main.ts

@@ -10,9 +10,8 @@ import { createSystemContext, orchestrateTask } from "../core/factory";
 import { loadConfig, USER_CONFIG_DIR } from "../core/config";
 import { listProviders, modelsFor, providerLabel, validateModel } from "../core/catalog";
 import { agentTheme } from "../core/theme";
-import { classify } from "../core/router";
 import { InteractiveMode, ModeController } from "./mode";
-import { readLine, renderPalette, StreamRenderer, stripMarkdown } from "./tui";
+import { readLine, renderPalette, StreamRenderer } from "./tui";
 import { loomChat } from "./loom_chat";
 
 const MODE = new ModeController();
@@ -38,6 +37,8 @@ program.command("mcp").action(() => { import("../core/mcp_server").then(m => m.s
 program.command("gateway").description("Run the channel gateway (Feishu / WeCom / QQ)")
   .option("-p,--port <p>", "port", "8848")
   .action((o: { port?: string }) => { import("../gateway/gateway").then(m => m.startGateway({ port: parseInt(o.port || "8848") })); });
+program.command("channels").description("Configure a chat channel (Feishu / WeCom / QQ) with QR shortcuts")
+  .action(async () => { await channelsWizard(); });
 program.command("config").action(() => { const c = loadConfig(); process.stdout.write(chalk.cyan("\nConfig: ") + USER_CONFIG_DIR + "\n"); for (const [n, a] of Object.entries(c.agents || {})) process.stdout.write(`  ${chalk.bold(n)}: ${(a as any).model || "default"}\n`); });
 program.command("init").action(() => { if (!fs.existsSync(USER_CONFIG_DIR)) fs.mkdirSync(USER_CONFIG_DIR, { recursive: true }); process.stdout.write(chalk.green("✓ ") + USER_CONFIG_DIR + "\n"); });
 program.command("apikey").description("Manage API keys (persisted to ~/.skyloom/config.yaml)")
@@ -71,18 +72,6 @@ function welcome(agent: any) {
   process.stdout.write(chalk.dim("  /help for commands  ·  /quit to exit\n\n"));
 }
 
-function statusBar(agent: any, ctx: any): string {
-  try {
-    const cu = agent.contextUsage();
-    const pct = cu.pct || 0;
-    const bar = pct < 50 ? chalk.green : pct < 80 ? chalk.yellow : chalk.red;
-    const filled = Math.round(pct / 10);
-    const ctxBar = `${bar("█".repeat(filled) + "░".repeat(10 - filled))} ${pct}%`;
-    const cost = formatCost(ctx.llm.getTotalCost());
-    return chalk.dim(`${ctxBar}  ·  ${cost}  ·  ${cu.model || "?"}`);
-  } catch { return ""; }
-}
-
 function formatCost(c: number): string {
   if (c >= 1) return chalk.yellow(`$${c.toFixed(2)}`);
   if (c >= 0.01) return chalk.yellow(`$${c.toFixed(4)}`);
@@ -117,11 +106,6 @@ async function streamResponse(agent: any, input: string): Promise<void> {
   const header = () => { if (!headerShown) { out.write("\n  " + chalk.bold.hex(theme.hex)(`${theme.symbol} ${theme.kanji}`) + chalk.hex(theme.hex)(` ${theme.name}`) + "\n\n"); headerShown = true; } };
   const endBlock = () => { if (renderer) { renderer.flush(); renderer = null; out.write("\n"); } };
 
-  // All content passes through this cleaner before display
-  const writeClean = (text: string) => {
-    if (renderer) renderer.write(text);
-  };
-
   // ── Ctrl-C interrupts this turn (keeps partial output); a 2nd Ctrl-C exits. ──
   const controller = new AbortController();
   let interrupted = false;
@@ -275,6 +259,65 @@ async function setupWizard(): Promise<{ provider: string; key: string; model: st
   return { provider: prov.id, key: key.trim(), model };
 }
 
+/* ═══════════════════════════════════════
+   Channel setup wizard (sky channels)
+   ═══════════════════════════════════════ */
+async function channelsWizard(): Promise<void> {
+  const { CHANNEL_SETUP, SETUP_CHANNEL_IDS, callbackUrl, saveChannelConfig, missingRequired } = require("../gateway/setup");
+  const { renderQR } = require("../gateway/qr");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q: string): Promise<string> => new Promise(r => rl.question(q, r));
+
+  try {
+    process.stdout.write("\n" + chalk.cyan("  ✦ 渠道接入向导 · sky channels ✦\n\n"));
+    process.stdout.write(chalk.dim("  选择要配置的聊天软件:\n\n"));
+    SETUP_CHANNEL_IDS.forEach((id: string, i: number) => {
+      process.stdout.write(chalk.dim(`  ${i + 1}. ${CHANNEL_SETUP[id].name}\n`));
+    });
+    const choice = await ask(chalk.cyan(`\n  编号 (1-${SETUP_CHANNEL_IDS.length}, q 退出): `));
+    if (choice.trim().toLowerCase() === "q") return;
+    const idx = parseInt(choice) - 1;
+    if (isNaN(idx) || idx < 0 || idx >= SETUP_CHANNEL_IDS.length) { process.stdout.write(chalk.dim("  已取消\n")); return; }
+    const spec = CHANNEL_SETUP[SETUP_CHANNEL_IDS[idx]];
+
+    // Steps + QR to the platform console.
+    process.stdout.write("\n" + chalk.bold(`  配置 ${spec.name}\n\n`));
+    spec.steps.forEach((s: string, i: number) => process.stdout.write(chalk.dim(`  ${i + 1}. ${s}\n`)));
+    process.stdout.write(chalk.dim(`\n  📱 扫码打开管理后台:  `) + chalk.cyan(spec.consoleUrl) + "\n");
+    const consoleQR = renderQR(spec.consoleUrl);
+    if (consoleQR) process.stdout.write("\n" + consoleQR.split("\n").map((l: string) => "    " + l).join("\n") + "\n");
+    if (spec.docsUrl) process.stdout.write(chalk.dim(`  📖 文档: ${spec.docsUrl}\n`));
+
+    // Collect credential fields.
+    process.stdout.write("\n" + chalk.dim("  逐项填入凭据(回车跳过可选项):\n\n"));
+    const values: Record<string, string> = {};
+    for (const f of spec.fields) {
+      const req = f.required ? chalk.red("*") : chalk.dim("(可选)");
+      if (f.hint) process.stdout.write(chalk.dim(`    ↳ ${f.hint}\n`));
+      const v = await ask(chalk.cyan(`  ${f.label} ${req}: `));
+      if (v.trim()) values[f.key] = v.trim();
+    }
+    const missing = missingRequired(spec.id, values);
+    if (missing.length) {
+      process.stdout.write(chalk.yellow(`\n  ⚠ 缺少必填项: ${missing.join(", ")} — 已保存现有项,可再次运行补全。\n`));
+    }
+
+    const cfgPath = saveChannelConfig(spec.id, values);
+    process.stdout.write(chalk.green(`\n  ✓ 已保存到 ${cfgPath} 的 channels.${spec.id}\n`));
+
+    // Callback URL + QR to paste into the platform console.
+    const base = (await ask(chalk.cyan("\n  你的网关公网地址(如 https://bot.example.com,回车用 http://localhost:8848): "))).trim()
+      || "http://localhost:8848";
+    const cb = callbackUrl(base, spec.id);
+    process.stdout.write(chalk.dim("\n  把下面的回调 URL 填入平台后台的事件/接收配置:\n  ") + chalk.cyan(cb) + "\n");
+    const cbQR = renderQR(cb);
+    if (cbQR) process.stdout.write("\n" + cbQR.split("\n").map((l: string) => "    " + l).join("\n") + "\n");
+    process.stdout.write(chalk.dim(`\n  完成后运行  sky gateway  启动网关。\n\n`));
+  } finally {
+    rl.close();
+  }
+}
+
 async function chat(agentName: string, modelOverride?: string, classic?: boolean): Promise<void> {
   const haveKey = checkApiKeys();
   if (!haveKey) {
@@ -313,7 +356,7 @@ async function chat(agentName: string, modelOverride?: string, classic?: boolean
 
   // Wire up security approval — prompt user for HIGH/CRITICAL operations
   try {
-    const { getSecurity, DangerLevel, PERMISSION_MODE_ALIASES } = require("../core/security");
+    const { getSecurity, PERMISSION_MODE_ALIASES } = require("../core/security");
     const sec = getSecurity();
     // Honor a configured permission mode (config.yaml cli.approvalMode), mapped
     // through the same aliases as /perm.
@@ -344,7 +387,6 @@ async function chat(agentName: string, modelOverride?: string, classic?: boolean
     return; // loomChat exits the process itself
   }
 
-  // eslint-disable-next-line prefer-const
   let currentAgent = agent; // mutable for agent switching
   let lastSessions: any[] = []; // index→session map for /resume <n>
   welcome(agent);
@@ -508,6 +550,7 @@ async function chat(agentName: string, modelOverride?: string, classic?: boolean
     }
     if (cmdL.startsWith("/task ")) { const g = inp.slice(6); process.stdout.write(chalk.cyan("\n  ✦ " + g + "\n\n")); await runTask(g); continue; }
     if (cmdL === "/setup") { const r = await setupWizard(); if (r) process.stdout.write(chalk.green(`  ${r.provider} · ${r.model} — Ready!\n`)); continue; }
+    if (cmdL === "/channels") { await channelsWizard(); continue; }
     if (cmdL === "/model" || cmdL.startsWith("/model ")) {
       const { setAgentModel, setUnifiedModel, clearAgentModel, setAgentApiKey, describeAgentLLM } = require("../core/model_config");
       const cfg = (ctx as any).config;
@@ -537,7 +580,7 @@ async function chat(agentName: string, modelOverride?: string, classic?: boolean
       continue;
     }
     if (cmdL === "/models" || cmdL.startsWith("/models ")) {
-      const { listProviders, modelsFor, providerLabel, allModels } = require("../core/catalog");
+      const { listProviders, modelsFor, providerLabel } = require("../core/catalog");
       const args = inp.split(/\s+/).slice(1);
       const filter = args[0]?.toLowerCase() || "";
       process.stdout.write(chalk.bold("\n  ✦ 模型目录 · Model Catalog\n"));

package/src/cli/tui.ts

@@ -14,8 +14,6 @@ import chalk from "chalk";
 import { agentTheme, PALETTE } from "../core/theme";
 import { registry } from "../core/commands";
 
-const TUI_VERSION = (() => { try { return require("../../package.json").version; } catch { return ""; } })();
-
 export interface TUIContext {
   agent: any;
   agents: Map<string, any>;

package/src/core/commands.ts

@@ -482,6 +482,16 @@ export const BUILTIN_COMMANDS: CommandInfo[] = [
     takesArgs: false,
     source: 'builtin',
   },
+  {
+    name: 'channels',
+    aliases: [],
+    description: 'Configure a chat channel (Feishu / WeCom / QQ) with QR shortcuts',
+    label: '渠道接入向导（飞书/企业微信/QQ · 含二维码）',
+    category: 'config',
+    hints: [],
+    takesArgs: false,
+    source: 'builtin',
+  },
   {
     name: 'apikey',
     aliases: [],

package/src/core/diff.ts

@@ -60,7 +60,6 @@ export function unifiedDiff(oldStr: string, newStr: string, opts: DiffOptions =
   // Context window bounds.
   const ctxStart = Math.max(0, pre - context);
   const oldCtxAfterStart = oldLines.length - suf;
-  const newCtxAfterStart = newLines.length - suf;
   const oldCtxAfter = oldLines.slice(oldCtxAfterStart, oldCtxAfterStart + context);
   const leading = oldLines.slice(ctxStart, pre);
 

package/src/core/evolve.ts

@@ -121,12 +121,6 @@ export function analyzeFailures(
     }
   }
 
-  // General rule: if failure rate > 20%, suggest self-review
-  const recentExperiences = recent.filter(e => {
-    try { return new Date(e.lastSeen).getTime() > Date.now() - 3 * 86400000; }
-    catch { return false; }
-  });
-
   // Deduplicate suggestions
   const seen = new Set<string>();
   const uniqueDiffs = suggestedDiffs.filter(d => {

package/src/core/graph.ts

@@ -140,7 +140,7 @@ const RELATION_PATTERNS: Array<[RegExp, string]> = [
   [/(\w+) (?:file|path|文件|路径) (?:在|为|at) (.+?)(?:[。，,.\n]|$)/gi, "located_at"],
 ];
 
-export function extractFacts(text: string, agent: string): Array<[string, string, string]> {
+export function extractFacts(text: string, _agent: string): Array<[string, string, string]> {
   const facts: Array<[string, string, string]> = [];
   for (const [pattern, pred] of RELATION_PATTERNS) {
     let match;

package/src/core/llm.ts

@@ -355,37 +355,6 @@ const FALLBACK_CHAINS: Map<string, string[]> = new Map([
 /**
  * HTTP status codes that are considered transient errors (worth retrying).
  */
-const RETRYABLE_STATUSES = new Set([408, 425, 429, 500, 502, 503, 504]);
-
-/**
- * Check if an exception is worth retrying.
- */
-function isTransientError(err: unknown): boolean {
-  if (err instanceof Error) {
-    const status =
-      (err as any).status_code || (err as any).http_status || 0;
-    if (status && RETRYABLE_STATUSES.has(status)) {
-      return true;
-    }
-
-    if (err.name === "TimeoutError") {
-      return true;
-    }
-
-    const errName = err.constructor.name.toLowerCase();
-    return [
-      "ratelimiterror",
-      "apitimeouterror",
-      "apiconnectionerror",
-      "serviceunavailableerror",
-      "internalservererror",
-      "timeout",
-    ].includes(errName);
-  }
-
-  return false;
-}
-
 /**
  * Estimate cost for LLM API call.
  */
@@ -704,7 +673,7 @@ export class LLMClient {
     messages: Record<string, unknown>[],
     agentName?: string,
     tools?: string[],
-    stream: boolean = false,
+    _stream: boolean = false,
     overrides?: Record<string, unknown>
   ): Promise<LLMResponse> {
     const temperature = (overrides?.temperature as number) ?? 0.7;
@@ -867,7 +836,9 @@ export class LLMClient {
   private async *callOpenAIStream(
     m: string, messages: Record<string, unknown>[], tools?: string[], temp?: number, maxTok?: number, signal?: AbortSignal, agentName?: string
   ): AsyncGenerator<StreamEvent> {
-    const apiKey = this.getApiKey(m);
+    // Honor a per-agent API key override (agents.<name>.api_key) on the
+    // streaming path too — previously only the non-streaming path passed it.
+    const apiKey = this.getApiKey(m, agentName);
     const baseUrl = this.getBaseUrl(m);
     const body: Record<string, unknown> = {
       model: m, messages, temperature: temp ?? 0.7, max_tokens: maxTok ?? 4096,

package/src/core/sandbox.ts

@@ -6,15 +6,12 @@
  * limits, and dangerous command detection BEFORE execution.
  */
 
-import { execSync, exec } from "child_process";
+import { execSync } from "child_process";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
-import { getLogger } from "./logger";
 import { REDLINE_PATTERNS, REDLINE_COMMANDS } from "./security";
 
-const log = getLogger("sandbox");
-
 /* ═══════════════════════════════════════
    Configuration
    ═══════════════════════════════════════ */

package/src/core/schemas.ts

@@ -78,30 +78,6 @@ export interface MessageSchema {
   tool_call_id?: string;
 }
 
-/**
- * Coerce a value to a target type with best-effort conversion
- */
-function coerceType(value: unknown, targetType: string): unknown {
-  if (value === null || value === undefined) {
-    return value;
-  }
-
-  switch (targetType) {
-    case "string":
-      return String(value);
-    case "number":
-      return Number(value);
-    case "boolean":
-      return Boolean(value);
-    case "array":
-      return Array.isArray(value) ? value : [];
-    case "object":
-      return typeof value === "object" ? value : {};
-    default:
-      return value;
-  }
-}
-
 /**
  * Extract JSON object/array from a potentially malformed string
  */
@@ -170,7 +146,7 @@ function repairJSON(text: string): string {
  */
 export function parseSchema<T extends Record<string, unknown>>(
   raw: string,
-  schemaType?: new () => T
+  _schemaType?: new () => T
 ): T {
   if (!raw || !raw.trim()) {
     throw new SchemaValidationError("empty response", raw);

package/src/core/skill.ts

@@ -245,7 +245,6 @@ function extractSkillHead(body: string, maxChars: number): string {
 // Patterns for auto-deriving triggers
 const TRIGGER_QUOTED = /["'"'""]([^"'""\n]{1,40})["'""']/g;
 const TRIGGER_EXT = /(?<![A-Za-z0-9])\.[A-Za-z0-9]{2,6}\b/g;
-const TRIGGER_STRIP = " \t,.;:!?，。、；：！？、。";
 
 /**
  * Pull candidate trigger phrases out of a skill description.

package/src/gateway/qr.ts

@@ -0,0 +1,20 @@
+/**
+ * Terminal QR rendering — a thin, dependency-isolated wrapper over
+ * qrcode-terminal (single file, zero transitive deps). Returns the QR as a
+ * string so callers control where it's written (and so it's testable).
+ */
+
+// qrcode-terminal ships no types; declare the tiny surface we use.
+const qrcode: { generate: (text: string, opts: { small?: boolean }, cb: (s: string) => void) => void } =
+  require('qrcode-terminal');
+
+/** Render `text` as a scannable QR code (compact) into a string. */
+export function renderQR(text: string): string {
+  let out = '';
+  try {
+    qrcode.generate(text, { small: true }, (s: string) => { out = s; });
+  } catch {
+    return '';
+  }
+  return out;
+}

package/src/gateway/setup.ts

@@ -0,0 +1,145 @@
+/**
+ * Channel setup metadata + persistence — the data behind the `sky channels`
+ * wizard. Each channel declares the credential fields it needs, where to create
+ * the bot (a platform console URL we render as a QR for quick mobile access),
+ * and a short how-to. Kept pure/testable; the interactive prompts live in the
+ * CLI, and QR rendering is a thin wrapper over qrcode-terminal.
+ *
+ * Note: Feishu / WeCom / QQ are all official-bot APIs — credentials are created
+ * in each platform's developer console, there is no "scan to log in" the way
+ * personal WeChat works. So the QR here is a convenience link to the console
+ * (scan on your phone → open the console → create the bot → copy the keys), plus
+ * a QR of the gateway callback URL to paste back into the console.
+ */
+
+export interface ChannelField {
+  /** Config key under channels.<id>. */
+  key: string;
+  /** Human label shown in the wizard. */
+  label: string;
+  /** Whether the wizard must collect it (some are optional). */
+  required: boolean;
+  /** Treat as a secret (mask input / store as env-ref suggestion). */
+  secret?: boolean;
+  /** Env var that also supplies this value. */
+  env?: string;
+  /** One-line hint on where to find it. */
+  hint?: string;
+}
+
+export interface ChannelSetupSpec {
+  id: string;
+  name: string;
+  /** Platform console where the bot/app is created (rendered as a QR). */
+  consoleUrl: string;
+  /** Docs link for the full setup walkthrough. */
+  docsUrl?: string;
+  /** Webhook path the platform must call back. */
+  webhookPath: string;
+  /** Ordered credential fields to collect. */
+  fields: ChannelField[];
+  /** Short, numbered how-to shown before collecting fields. */
+  steps: string[];
+}
+
+export const CHANNEL_SETUP: Record<string, ChannelSetupSpec> = {
+  feishu: {
+    id: 'feishu',
+    name: '飞书 / Lark',
+    consoleUrl: 'https://open.feishu.cn/app',
+    docsUrl: 'https://open.feishu.cn/document/home/index',
+    webhookPath: '/webhook/feishu',
+    fields: [
+      { key: 'appId', label: 'App ID', required: true, env: 'FEISHU_APP_ID', hint: '开发者后台 → 凭证与基础信息 → App ID' },
+      { key: 'appSecret', label: 'App Secret', required: true, secret: true, env: 'FEISHU_APP_SECRET', hint: '同页 App Secret' },
+      { key: 'verificationToken', label: 'Verification Token', required: false, secret: true, env: 'FEISHU_VERIFICATION_TOKEN', hint: '事件订阅 → Verification Token(可选)' },
+      { key: 'encryptKey', label: 'Encrypt Key', required: false, secret: true, env: 'FEISHU_ENCRYPT_KEY', hint: '事件订阅 → Encrypt Key(开启加密时填)' },
+    ],
+    steps: [
+      '扫码或打开 https://open.feishu.cn/app 创建「企业自建应用」',
+      '在「凭证与基础信息」复制 App ID / App Secret',
+      '开启「机器人」能力,在「权限管理」添加 im:message 等权限',
+      '「事件订阅」填入下方回调 URL,订阅 im.message.receive_v1',
+    ],
+  },
+  wecom: {
+    id: 'wecom',
+    name: '企业微信 WeCom',
+    consoleUrl: 'https://work.weixin.qq.com/wework_admin/frame',
+    docsUrl: 'https://developer.work.weixin.qq.com/document/path/90664',
+    webhookPath: '/webhook/wecom',
+    fields: [
+      { key: 'corpId', label: 'CorpID（企业ID）', required: true, env: 'WECOM_CORP_ID', hint: '管理后台 → 我的企业 → 企业ID' },
+      { key: 'corpSecret', label: 'Secret（应用Secret）', required: true, secret: true, env: 'WECOM_CORP_SECRET', hint: '应用管理 → 自建应用 → Secret' },
+      { key: 'agentId', label: 'AgentId', required: true, env: 'WECOM_AGENT_ID', hint: '同应用页 AgentId' },
+      { key: 'token', label: 'Token', required: true, secret: true, env: 'WECOM_TOKEN', hint: '应用 → 接收消息 → API 接收 → Token' },
+      { key: 'encodingAesKey', label: 'EncodingAESKey', required: true, secret: true, env: 'WECOM_AES_KEY', hint: '同页 EncodingAESKey(43 位)' },
+    ],
+    steps: [
+      '扫码或打开企业微信管理后台,进入「应用管理 → 自建 → 创建应用」',
+      '复制企业ID、应用 Secret、AgentId',
+      '「接收消息」选 API 接收,设置 Token 与 EncodingAESKey',
+      '把下方回调 URL 填入「URL」,保存时企业微信会回调验证',
+    ],
+  },
+  qq: {
+    id: 'qq',
+    name: 'QQ 机器人',
+    consoleUrl: 'https://q.qq.com/#/app/bot',
+    docsUrl: 'https://bot.q.qq.com/wiki/',
+    webhookPath: '/webhook/qq',
+    fields: [
+      { key: 'appId', label: 'AppID（机器人ID）', required: true, env: 'QQ_BOT_APPID', hint: 'QQ 开放平台 → 机器人 → 开发设置 → AppID' },
+      { key: 'secret', label: 'AppSecret', required: true, secret: true, env: 'QQ_BOT_SECRET', hint: '同页 AppSecret' },
+    ],
+    steps: [
+      '扫码或打开 https://q.qq.com 创建机器人,完成开发者认证',
+      '在「开发设置」复制 AppID 与 AppSecret',
+      '「回调配置」选择 Webhook,填入下方回调 URL',
+      '在沙箱里把机器人加为好友 / 拉进群进行测试',
+    ],
+  },
+};
+
+export const SETUP_CHANNEL_IDS = Object.keys(CHANNEL_SETUP);
+
+/** Build the full webhook callback URL for a channel from a public base. */
+export function callbackUrl(base: string, channelId: string): string {
+  const spec = CHANNEL_SETUP[channelId];
+  if (!spec) return '';
+  const trimmed = base.replace(/\/+$/, '');
+  return `${trimmed}${spec.webhookPath}`;
+}
+
+/**
+ * Persist a channel's collected values into ~/.skyloom/config.yaml under
+ * channels.<id>, merging with any existing block. Secret-looking values are
+ * stored as-is (the file is chmod 0600); callers may instead keep secrets in
+ * env and store an { source: env, id } ref. Returns the config path written.
+ */
+export function saveChannelConfig(
+  channelId: string,
+  values: Record<string, string>,
+  opts?: { configPath?: string },
+): string {
+  const path = require('path');
+  const fs = require('fs');
+  const yaml = require('yaml');
+  const cfgPath = opts?.configPath || path.join(require('os').homedir(), '.skyloom', 'config.yaml');
+  const dir = path.dirname(cfgPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  let cfg: any = {};
+  if (fs.existsSync(cfgPath)) { try { cfg = yaml.parse(fs.readFileSync(cfgPath, 'utf-8')) || {}; } catch { cfg = {}; } }
+  if (!cfg.channels) cfg.channels = {};
+  cfg.channels[channelId] = { ...(cfg.channels[channelId] || {}), ...values, enabled: true };
+  fs.writeFileSync(cfgPath, yaml.stringify(cfg), { encoding: 'utf-8', mode: 0o600 });
+  try { fs.chmodSync(cfgPath, 0o600); } catch { /* best-effort on Windows */ }
+  return cfgPath;
+}
+
+/** Which required fields are still missing from a values map. */
+export function missingRequired(channelId: string, values: Record<string, string>): string[] {
+  const spec = CHANNEL_SETUP[channelId];
+  if (!spec) return [];
+  return spec.fields.filter((f) => f.required && !values[f.key]?.trim()).map((f) => f.key);
+}

package/src/tools/computer.ts

@@ -5,11 +5,11 @@
  * processes and services, and install/uninstall software.
  */
 
-import { execSync, execFileSync, spawn } from 'child_process';
+import { execSync, execFileSync } from 'child_process';
 import * as os from 'os';
 import * as fs from 'fs';
 import * as path from 'path';
-import type { ToolRegistry, ToolDefinition } from '../core/tool';
+import type { ToolRegistry } from '../core/tool';
 
 const MAX_OUT = 8000;
 

package/src/web/server.ts

@@ -8,11 +8,8 @@
 
 import { createServer, IncomingMessage, ServerResponse } from "http";
 import { createSystemContext } from "../core/factory";
-import { getLogger } from "../core/logger";
 import { renderInkWashUI, SKYLOOM_FAVICON_SVG } from "./ui";
 
-const log = getLogger("web-server");
-
 /* ──────────────────────────────────────────────
    Server
    ────────────────────────────────────────────── */

package/tests/channel_setup.test.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import {
+  CHANNEL_SETUP,
+  SETUP_CHANNEL_IDS,
+  callbackUrl,
+  saveChannelConfig,
+  missingRequired,
+} from "../src/gateway/setup";
+import { renderQR } from "../src/gateway/qr";
+
+describe("channel setup · metadata", () => {
+  it("covers the three channels with console URLs and webhook paths", () => {
+    expect(SETUP_CHANNEL_IDS.sort()).toEqual(["feishu", "qq", "wecom"]);
+    for (const id of SETUP_CHANNEL_IDS) {
+      const s = CHANNEL_SETUP[id];
+      expect(s.consoleUrl).toMatch(/^https:\/\//);
+      expect(s.webhookPath).toBe(`/webhook/${id}`);
+      expect(s.fields.length).toBeGreaterThan(0);
+      expect(s.steps.length).toBeGreaterThan(0);
+    }
+  });
+
+  it("each channel marks its credential fields with env fallbacks", () => {
+    const feishu = CHANNEL_SETUP.feishu;
+    const appId = feishu.fields.find((f) => f.key === "appId")!;
+    expect(appId.required).toBe(true);
+    expect(appId.env).toBe("FEISHU_APP_ID");
+    const secret = feishu.fields.find((f) => f.key === "appSecret")!;
+    expect(secret.secret).toBe(true);
+  });
+});
+
+describe("channel setup · callbackUrl", () => {
+  it("joins base + webhook path, trimming trailing slash", () => {
+    expect(callbackUrl("https://bot.example.com", "feishu")).toBe("https://bot.example.com/webhook/feishu");
+    expect(callbackUrl("https://bot.example.com/", "wecom")).toBe("https://bot.example.com/webhook/wecom");
+    expect(callbackUrl("http://localhost:8848", "qq")).toBe("http://localhost:8848/webhook/qq");
+  });
+});
+
+describe("channel setup · missingRequired", () => {
+  it("reports unfilled required fields, ignores optional", () => {
+    expect(missingRequired("feishu", { appId: "a" })).toEqual(["appSecret"]);
+    expect(missingRequired("feishu", { appId: "a", appSecret: "s" })).toEqual([]);
+    // optional fields (verificationToken/encryptKey) never reported
+    expect(missingRequired("feishu", { appId: "a", appSecret: "s" })).not.toContain("encryptKey");
+  });
+});
+
+describe("channel setup · saveChannelConfig", () => {
+  let cfgPath: string;
+  beforeEach(() => { cfgPath = path.join(fs.mkdtempSync(path.join(os.tmpdir(), "sky-chcfg-")), "config.yaml"); });
+  afterEach(() => { try { fs.rmSync(path.dirname(cfgPath), { recursive: true, force: true }); } catch {} });
+
+  it("writes channels.<id> and merges on re-save", () => {
+    saveChannelConfig("feishu", { appId: "a", appSecret: "s" }, { configPath: cfgPath });
+    const yaml = require("yaml");
+    let cfg = yaml.parse(fs.readFileSync(cfgPath, "utf8"));
+    expect(cfg.channels.feishu).toMatchObject({ appId: "a", appSecret: "s", enabled: true });
+
+    // re-save adds a field without dropping the old ones
+    saveChannelConfig("feishu", { encryptKey: "k" }, { configPath: cfgPath });
+    cfg = yaml.parse(fs.readFileSync(cfgPath, "utf8"));
+    expect(cfg.channels.feishu).toMatchObject({ appId: "a", appSecret: "s", encryptKey: "k" });
+  });
+
+  it("preserves other top-level config when writing a channel", () => {
+    const yaml = require("yaml");
+    fs.mkdirSync(path.dirname(cfgPath), { recursive: true });
+    fs.writeFileSync(cfgPath, yaml.stringify({ default_model: "gpt-4o", api_keys: { openai: "sk" } }));
+    saveChannelConfig("qq", { appId: "1", secret: "x" }, { configPath: cfgPath });
+    const cfg = yaml.parse(fs.readFileSync(cfgPath, "utf8"));
+    expect(cfg.default_model).toBe("gpt-4o");
+    expect(cfg.api_keys.openai).toBe("sk");
+    expect(cfg.channels.qq.appId).toBe("1");
+  });
+});
+
+describe("channel setup · QR rendering", () => {
+  it("renders a non-empty scannable block for a URL", () => {
+    const qr = renderQR("https://open.feishu.cn/app");
+    expect(qr.length).toBeGreaterThan(50);
+    expect(qr).toMatch(/[█▀▄ ]/); // block-drawing characters
+  });
+});