wtt-connect 0.2.63 → 0.2.65

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wtt-connect",
-  "version": "0.2.63",
+  "version": "0.2.65",
   "private": false,
   "description": "WTT-native connector daemon for Codex, Claude Code, Cursor, Gemini, ACP, and other coding agent surfaces.",
   "type": "module",

package/src/main.js

@@ -10,6 +10,7 @@ import { smokeChat, smokeTask } from './smoke.js';
 import { ArtifactManager } from './artifacts.js';
 import { DurableStore } from './store.js';
 import { WTTClient } from './wtt-client.js';
+import { WTTApi } from './wtt-api.js';
 import { log, redact } from './logger.js';
 import { adapterBin, normalizeProfileName } from './adapters/generic-cli.js';
 import { normalizeAdapterName } from './adapters/index.js';
@@ -38,6 +39,7 @@ export async function main(args) {
   if (cmd === 'upload-artifact' || cmd === 'opendesign-upload') return uploadArtifact(loadConfig(argv), argv);
   if (cmd === 'preview-port' || cmd === 'sandbox-preview') return previewPort(loadConfig(argv), argv);
   if (cmd === 'cleanup-previews' || cmd === 'preview-cleanup') return cleanupPreviewsCommand(loadConfig(argv), argv);
+  if (cmd === 'feishu' || cmd === 'lark') return feishuCommand(loadConfig(argv), argv);
   if (cmd === 'start') {
     const config = loadConfig(argv);
     if (!config.agentId) throw new Error('WTT_AGENT_ID is required');
@@ -92,6 +94,9 @@ function parseArgs(args) {
     else if (a === '--source') out.source = args[++i];
     else if (a === '--source-id') out.sourceId = args[++i];
     else if (a === '--title') out.title = args[++i];
+    else if (a === '--content') out.content = args[++i];
+    else if (a === '--folder-token') out.folderToken = args[++i];
+    else if (a === '--max-chars') out.maxChars = Number(args[++i]);
     else if (a === '--entry') out.entry = args[++i];
     else if (a === '--type') out.type = args[++i];
     else if (a === '--port') out.port = Number(args[++i]);
@@ -151,10 +156,62 @@ Commands:
                                   Create a Cloud Sandbox live preview URL; snapshots are opt-in
   cleanup-previews [--keep-last <n>]
                                   Stop preview servers previously registered by this agent
+  feishu read-doc <url-or-token> [--max-chars n]
+                                  Read a Feishu/Lark doc shared with the WTT Bot
+  feishu create-doc --title <title> [--content text|--file path] [--folder-token token]
+                                  Create a Feishu/Lark doc through the WTT Bot
+  feishu append-doc <url-or-token> (--content text|--file path)
+                                  Append text to a Feishu/Lark doc through the WTT Bot
   help                           Show this help
 `);
 }
 
+async function feishuCommand(config, argv) {
+  const subcommand = String(argv._[0] || '').trim().toLowerCase();
+  const api = new WTTApi(config);
+  if (!config.agentId) throw new Error('WTT_AGENT_ID is required');
+  if (!config.token) throw new Error('WTT_TOKEN or WTT_AGENT_TOKEN is required');
+  if (subcommand === 'read-doc' || subcommand === 'read') {
+    const urlOrToken = String(argv._[1] || argv.url || argv.token || '').trim();
+    if (!urlOrToken) throw new Error('feishu read-doc requires <url-or-token>');
+    const result = await api.feishuReadDoc({ urlOrToken, maxChars: argv.maxChars });
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (subcommand === 'create-doc' || subcommand === 'create') {
+    const title = String(argv.title || '').trim();
+    if (!title) throw new Error('feishu create-doc requires --title <title>');
+    const content = readCommandContent(argv);
+    const result = await api.feishuCreateDoc({ title, content, folderToken: argv.folderToken || '' });
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (subcommand === 'append-doc' || subcommand === 'append') {
+    const urlOrToken = String(argv._[1] || argv.url || argv.token || '').trim();
+    if (!urlOrToken) throw new Error('feishu append-doc requires <url-or-token>');
+    const content = readCommandContent(argv);
+    if (!content.trim()) throw new Error('feishu append-doc requires --content <text> or --file <path>');
+    const result = await api.feishuAppendDoc({ urlOrToken, content });
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  throw new Error([
+    'unknown feishu command',
+    'Usage:',
+    '  wtt-connect feishu read-doc <url-or-token> [--max-chars n]',
+    '  wtt-connect feishu create-doc --title <title> [--content text|--file path] [--folder-token token]',
+    '  wtt-connect feishu append-doc <url-or-token> (--content text|--file path)',
+  ].join('\n'));
+}
+
+function readCommandContent(argv) {
+  if (typeof argv.content === 'string') return argv.content;
+  const file = Array.isArray(argv.files) ? argv.files[0] : '';
+  if (!file) return '';
+  const resolved = path.resolve(String(file));
+  return fs.readFileSync(resolved, 'utf8');
+}
+
 async function previewPort(config, argv) {
   const port = Number(argv.port || argv._[0]);
   if (!Number.isInteger(port) || port < 1024 || port > 65535 || port === 3000) {

package/src/runner.js

@@ -228,8 +228,9 @@ export class Runner {
           return;
         }
       }
+      const skillSlashPrompt = isSlashPassthrough ? this.skillSlashPrompt(content, m.metadata) : '';
       const compactSummary = this.store.getSession(sessionKey).compactSummary || '';
-      const prompt = isSlashPassthrough ? content : [
+      const prompt = isSlashPassthrough ? (skillSlashPrompt || content) : [
         'You are replying to a WTT Web conversation. Do not mention implementation internals unless asked.',
         `WTT topic_id: ${topicId}`,
         `WTT topic_type: ${messageTopicType(m) || 'unknown'}`,
@@ -253,6 +254,7 @@ export class Runner {
         staged.promptBlock,
         renderTranscriptBlock(transcripts),
         renderCloudSandboxStorageInstruction(this.config, topicId),
+        renderFeishuToolInstruction(this.config),
         renderGeneratedFileArtifactInstruction(this.config, topicId),
         'Reply naturally and concisely unless the user asks for detail.',
       ].filter(Boolean).join('\n');
@@ -434,6 +436,12 @@ export class Runner {
     return `${adapterDisplayName(adapter.name)} session cleared for this WTT topic. The next turn starts a fresh agent thread/session.`;
   }
 
+  skillSlashPrompt(content, metadata = null) {
+    const runtime = this.runtimeInfo();
+    const commands = Array.isArray(runtime.skill_commands) ? runtime.skill_commands : [];
+    return buildSkillSlashPrompt(content, metadata, commands);
+  }
+
   async compactAdapterSession(adapter, context = {}, command = '/compact', args = '') {
     const sessionKey = context.sessionKey || 'default';
     const topicId = String(context.topicId || '').trim();
@@ -764,6 +772,33 @@ export class Runner {
   }
 }
 
+export function buildSkillSlashPrompt(content, metadata = null, commands = []) {
+  const parsed = parseSlashCommand(content);
+  if (!parsed) return '';
+  const meta = parseMetadata(metadata);
+  const metadataSkillId = String(meta?.skill_id || meta?.skillId || '').trim();
+  const metadataFamily = String(meta?.command_family || meta?.commandFamily || '').trim().toLowerCase();
+  const matched = (Array.isArray(commands) ? commands : []).find((item) => String(item?.cmd || '').trim().toLowerCase() === parsed.command)
+    || (metadataFamily === 'skill' || metadataSkillId ? {
+      cmd: parsed.command,
+      skill_id: metadataSkillId || parsed.command.replace(/^\/+/, ''),
+      name: metadataSkillId || parsed.command.replace(/^\/+/, ''),
+      desc: '',
+    } : null);
+  if (!matched) return '';
+  const skillName = String(matched.name || matched.skill_id || matched.cmd || '').trim().replace(/^\/+/, '');
+  const skillId = String(matched.skill_id || skillName).trim();
+  const args = String(parsed.args || '').trim();
+  return [
+    `Use the ${skillName} skill${skillId && skillId !== skillName ? ` (${skillId})` : ''}.`,
+    matched.desc ? `Skill description: ${matched.desc}` : null,
+    '',
+    args ? `User request: ${args}` : 'User request: Run this skill for the current conversation.',
+    '',
+    `Original slash command: ${content}`,
+  ].filter(Boolean).join('\n');
+}
+
 function adapterDisplayName(name) {
   if (name === 'claude-code') return 'Claude Code';
   if (name === 'codex') return 'Codex';
@@ -1108,6 +1143,21 @@ function renderGeneratedFileArtifactInstruction(config, topicId = '') {
   ].join('\n');
 }
 
+function renderFeishuToolInstruction(config) {
+  if (!config.agentId || !config.token) return '';
+  return [
+    'Feishu/Lark document tool rule, for internal execution only:',
+    '- If the user asks you to read, summarize, analyze, create, or append a Feishu/Lark document, or provides a docs.feishu.cn / feishu.cn / larksuite.com docx/wiki link, call the local WTT Feishu tool instead of guessing from the URL.',
+    '- Read a document: `wtt-connect feishu read-doc "<feishu_doc_or_wiki_url>" --max-chars 50000`.',
+    '- Create a document: `wtt-connect feishu create-doc --title "Title" --content "text"` or put larger content in a file and use `--file path`.',
+    '- Append to a document: `wtt-connect feishu append-doc "<feishu_doc_or_wiki_url>" --content "text"` or `--file path`.',
+    '- The backend only proxies explicit tool calls; do not claim you accessed a Feishu document unless the command succeeds.',
+    '- If the command returns a permission error, tell the user to share the document with the WTT Bot or grant the WTT Feishu app cloud document permissions.',
+    '- The first version intentionally supports read/create/append only. Do not attempt destructive delete, clear, or overwrite operations.',
+    '- When the user explicitly asks to write/create/append a Feishu document, proceed without asking for an extra confirmation.',
+  ].join('\n');
+}
+
 function renderCloudSandboxStorageInstruction(config, topicId = '') {
   if (!config.cloudSandbox) return '';
   const workDir = config.workDir || process.cwd();
@@ -1611,6 +1661,7 @@ function buildTaskPrompt(task, config, staged = { promptBlock: '' }, transcripts
     '',
     config.requireCommitPush ? 'For code changes, commit and push before final response, and include commit id.' : '',
     renderCloudSandboxStorageInstruction(config, task.topic_id || task.topicId || ''),
+    renderFeishuToolInstruction(config),
     renderGeneratedFileArtifactInstruction(config, task.topic_id || task.topicId || ''),
     'Return a concise final summary with evidence, changed files, tests, artifacts, and blockers.',
   ].filter(Boolean).join('\n');

package/src/runtime-info.js

@@ -3,6 +3,9 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { execFileSync } from 'node:child_process';
 
+let skillCommandCache = { at: 0, commands: [] };
+const SKILL_COMMAND_CACHE_MS = 60_000;
+
 export function buildRuntimeInfo(config, runtimeState = {}) {
   const workdir = resolveWorkDir(config.workDir);
   const git = gitInfo(workdir);
@@ -30,10 +33,145 @@ export function buildRuntimeInfo(config, runtimeState = {}) {
     node: process.version,
     mode: config.mode,
     git,
+    skill_commands: discoverSkillCommands(config, workdir),
     updated_at: new Date().toISOString(),
   };
 }
 
+export function discoverSkillCommands(config = {}, workdir = resolveWorkDir(config.workDir)) {
+  const now = Date.now();
+  if (now - skillCommandCache.at < SKILL_COMMAND_CACHE_MS) return skillCommandCache.commands;
+  const roots = skillRoots(config, workdir);
+  const seenCommands = new Set();
+  const commands = [];
+  for (const root of roots) {
+    for (const skillFile of findSkillFiles(root, 5)) {
+      const parsed = parseSkillFile(skillFile);
+      if (!parsed.id) continue;
+      const commandName = normalizeSkillCommandName(parsed.name || parsed.id);
+      if (!commandName) continue;
+      const cmd = `/${commandName}`;
+      const key = cmd.toLowerCase();
+      if (seenCommands.has(key)) continue;
+      seenCommands.add(key);
+      commands.push({
+        cmd,
+        desc: parsed.description || `Use ${parsed.name || parsed.id} skill`,
+        family: 'skill',
+        mode: 'passthrough',
+        skill_id: parsed.id,
+        name: parsed.name || parsed.id,
+        source: parsed.source,
+      });
+      if (commands.length >= 120) break;
+    }
+    if (commands.length >= 120) break;
+  }
+  skillCommandCache = { at: now, commands };
+  return commands;
+}
+
+function skillRoots(config = {}, workdir = '') {
+  const home = os.homedir();
+  const roots = [
+    path.join(home, '.codex', 'skills'),
+    path.join(home, '.agents', 'skills'),
+    path.join(home, '.claude', 'skills'),
+    path.join(home, '.claude', 'mattpocock-skills', 'skills'),
+    workdir ? path.join(workdir, '.codex', 'skills') : '',
+    workdir ? path.join(workdir, '.claude', 'skills') : '',
+    process.cwd() ? path.join(process.cwd(), '.codex', 'skills') : '',
+    process.cwd() ? path.join(process.cwd(), '.claude', 'skills') : '',
+  ];
+  const extra = String(process.env.WTT_CONNECT_SKILL_ROOTS || config.skillRoots || '').split(path.delimiter);
+  return Array.from(new Set(
+    [...roots, ...extra]
+      .map((item) => String(item || '').trim())
+      .filter(Boolean)
+      .map((item) => path.resolve(item))
+  ));
+}
+
+function findSkillFiles(root, maxDepth = 4) {
+  const out = [];
+  if (!root || !fs.existsSync(root)) return out;
+  const visit = (dir, depth) => {
+    if (depth < 0 || out.length >= 160) return;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    if (entries.some((entry) => entry.isFile() && entry.name === 'SKILL.md')) {
+      out.push(path.join(dir, 'SKILL.md'));
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name === 'node_modules' || entry.name.startsWith('.git')) continue;
+      visit(path.join(dir, entry.name), depth - 1);
+      if (out.length >= 160) return;
+    }
+  };
+  visit(root, maxDepth);
+  return out;
+}
+
+function parseSkillFile(file) {
+  try {
+    const text = fs.readFileSync(file, 'utf8');
+    const fallbackId = path.basename(path.dirname(file));
+    const frontmatter = text.match(/^---\s*\n([\s\S]*?)\n---/);
+    const meta = frontmatter ? parseSimpleYaml(frontmatter[1]) : {};
+    const id = String(meta.name || fallbackId || '').trim();
+    return {
+      id,
+      name: id,
+      description: String(meta.description || firstMarkdownSentence(text) || '').trim(),
+      source: sourceForSkillPath(file),
+    };
+  } catch {
+    return { id: '', name: '', description: '', source: 'local' };
+  }
+}
+
+function parseSimpleYaml(text) {
+  const out = {};
+  for (const line of String(text || '').split(/\r?\n/)) {
+    const match = line.match(/^([A-Za-z0-9_-]+)\s*:\s*(.*)$/);
+    if (!match) continue;
+    const key = match[1];
+    let value = match[2].trim();
+    value = value.replace(/^['"]|['"]$/g, '');
+    out[key] = value;
+  }
+  return out;
+}
+
+function firstMarkdownSentence(text) {
+  const body = String(text || '').replace(/^---\s*\n[\s\S]*?\n---/, '').trim();
+  const line = body.split(/\r?\n/).map((item) => item.trim().replace(/^#+\s*/, '')).find(Boolean);
+  return line || '';
+}
+
+function normalizeSkillCommandName(value) {
+  const raw = String(value || '').trim().split(':').pop() || '';
+  return raw
+    .replace(/[^A-Za-z0-9_-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 80)
+    .toLowerCase();
+}
+
+function sourceForSkillPath(file) {
+  const normalized = String(file || '');
+  if (normalized.includes(`${path.sep}.codex${path.sep}`)) return 'codex-local';
+  if (normalized.includes(`${path.sep}.claude${path.sep}`)) return 'claude-local';
+  if (normalized.includes(`${path.sep}.agents${path.sep}`)) return 'agents-local';
+  return 'local';
+}
+
 function runtimeModel(config, adapter, runtimeState = {}) {
   const fromRun = String(runtimeState.current_model || runtimeState.model || '').trim();
   if (fromRun) return fromRun;

package/src/wtt-api.js

@@ -130,4 +130,38 @@ export class WTTApi {
     }
   }
 
+  async feishuReadDoc({ urlOrToken, maxChars } = {}) {
+    return this.request('POST', '/integrations/feishu/agent/doc/read', {
+      headers: this.agentHeaders(),
+      json: {
+        agent_id: this.config.agentId,
+        url_or_token: urlOrToken,
+        ...(maxChars ? { max_chars: Number(maxChars) } : {}),
+      },
+    });
+  }
+
+  async feishuCreateDoc({ title, content = '', folderToken = '' } = {}) {
+    return this.request('POST', '/integrations/feishu/agent/doc/create', {
+      headers: this.agentHeaders(),
+      json: {
+        agent_id: this.config.agentId,
+        title,
+        content,
+        ...(folderToken ? { folder_token: folderToken } : {}),
+      },
+    });
+  }
+
+  async feishuAppendDoc({ urlOrToken, content } = {}) {
+    return this.request('POST', '/integrations/feishu/agent/doc/append', {
+      headers: this.agentHeaders(),
+      json: {
+        agent_id: this.config.agentId,
+        url_or_token: urlOrToken,
+        content,
+      },
+    });
+  }
+
 }