wtt-connect 0.1.6 → 0.1.8

package/package.json

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

package/src/artifacts.js

@@ -47,6 +47,39 @@ export class ArtifactManager {
     return { file, asset: await this.uploadFile(file) };
   }
 
+  async uploadDirectory(dirPath, options = {}) {
+    const dir = path.resolve(dirPath);
+    const files = await collectFiles(dir);
+    if (!files.length) throw new Error(`artifact directory has no files: ${dir}`);
+    const payloadFiles = [];
+    for (const file of files) {
+      const rel = path.relative(dir, file).split(path.sep).join('/');
+      const bytes = await fs.readFile(file);
+      payloadFiles.push({
+        path: rel,
+        content_base64: bytes.toString('base64'),
+        mime_type: lookupMime(file),
+      });
+    }
+    const artifact = await this.fetchJson('/artifacts', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', ...this.authHeaders(), ...this.agentHeaders() },
+      body: JSON.stringify({
+        source: options.source || 'feed',
+        source_id: options.sourceId || '',
+        agent_id: this.config.agentId || '',
+        title: options.title || path.basename(dir),
+        type: options.type || 'opendesign',
+        entry_file: options.entry || inferEntry(files, dir),
+        metadata: options.metadata || {},
+        files: payloadFiles,
+      }),
+    });
+    this.store?.addArtifact({ filePath: dir, asset: artifact });
+    log('info', 'artifact directory uploaded', { dir, files: files.length, preview: artifact.preview_url });
+    return artifact;
+  }
+
   async fetchJson(url, options) {
     const r = await fetch(absoluteUrl(this.config.wttBaseUrl, url), options);
     if (!r.ok) throw new Error(`WTT media API failed: ${r.status} ${await r.text()}`);
@@ -56,6 +89,10 @@ export class ArtifactManager {
   authHeaders() {
     return this.config.httpToken ? { Authorization: `Bearer ${this.config.httpToken}` } : {};
   }
+
+  agentHeaders() {
+    return this.config.token ? { 'X-Agent-Token': this.config.token } : {};
+  }
 }
 
 function absoluteUrl(base, maybeRelative) {
@@ -66,3 +103,29 @@ function absoluteUrl(base, maybeRelative) {
 function safeName(name) {
   return String(name || 'artifact.txt').replace(/[^a-zA-Z0-9._-]+/g, '-').slice(0, 120) || 'artifact.txt';
 }
+
+async function collectFiles(root) {
+  const out = [];
+  async function walk(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith('.')) continue;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else if (entry.isFile()) {
+        out.push(full);
+      }
+    }
+  }
+  await walk(root);
+  return out;
+}
+
+function inferEntry(files, root) {
+  const rels = files.map((file) => path.relative(root, file).split(path.sep).join('/'));
+  return rels.find((file) => file === 'index.html')
+    || rels.find((file) => file.endsWith('/index.html'))
+    || rels.find((file) => file.toLowerCase().endsWith('.html'))
+    || rels[0];
+}

package/src/main.js

@@ -5,6 +5,8 @@ import { Runner } from './runner.js';
 import { PermissionBroker } from './permissions.js';
 import { setup } from './setup.js';
 import { smokeChat, smokeTask } from './smoke.js';
+import { ArtifactManager } from './artifacts.js';
+import { DurableStore } from './store.js';
 import { log, redact } from './logger.js';
 import { adapterBin, normalizeProfileName } from './adapters/generic-cli.js';
 import { normalizeAdapterName } from './adapters/index.js';
@@ -27,6 +29,7 @@ export async function main(args) {
   if (cmd === 'claim-code') return setup(loadConfig(argv), { ...argv, noRegister: true, claimCode: true });
   if (cmd === 'smoke-task') return smokeTask(loadConfig(argv), argv);
   if (cmd === 'smoke-chat') return smokeChat(loadConfig(argv), argv);
+  if (cmd === 'upload-artifact' || cmd === 'opendesign-upload') return uploadArtifact(loadConfig(argv), argv);
   if (cmd === 'start') {
     const config = loadConfig(argv);
     if (!config.agentId) throw new Error('WTT_AGENT_ID is required');
@@ -68,6 +71,12 @@ function parseArgs(args) {
     else if (a === '--expected') out.expected = args[++i];
     else if (a === '--prompt') out.prompt = args[++i];
     else if (a === '--message') out.message = args[++i];
+    else if (a === '--dir') out.dir = args[++i];
+    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 === '--entry') out.entry = args[++i];
+    else if (a === '--type') out.type = args[++i];
     else if (a === '--timeout') out.timeout = Number(args[++i]) * 1000;
     else if (a === '--sender-agent-id') out.senderAgentId = args[++i];
     else if (a === '--sender-token') out.senderToken = args[++i];
@@ -98,10 +107,29 @@ Commands:
   smoke-task                     Create/run a WTT task and wait for connector result
   smoke-chat                     Send P2P chat from smoke sender and wait for reply
   claim-code                     Print claim code for current WTT_AGENT_ID/TOKEN
+  upload-artifact --dir <path>  Upload an OpenDesign/artifact directory to WTT
+  opendesign-upload --dir <path>
+                                  Alias for upload-artifact
   help                           Show this help
 `);
 }
 
+async function uploadArtifact(config, argv) {
+  const dir = argv.dir || argv._[0];
+  if (!dir) throw new Error('upload-artifact requires --dir <path>');
+  const store = new DurableStore(config.storeFile).load();
+  const artifacts = new ArtifactManager(config, store);
+  const artifact = await artifacts.uploadDirectory(dir, {
+    source: argv.source || 'feed',
+    sourceId: argv.sourceId || '',
+    title: argv.title || 'OpenDesign artifact',
+    entry: argv.entry || '',
+    type: argv.type || 'opendesign',
+    metadata: { uploaded_by: 'wtt-connect', command: 'upload-artifact' },
+  });
+  console.log(JSON.stringify(artifact, null, 2));
+}
+
 
 function doctor(config) {
   log('info', 'wtt-connect doctor', {

package/src/opendesign.js

@@ -0,0 +1,68 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const DESIGN_KEYWORDS = /动画|动效|原理图|流程图|架构图|可视化|页面|UI|界面|原型|设计|白板|公式|推导|diagram|animation|visual|prototype|wireframe|design|ui|dashboard|deck|formula|architecture/i;
+
+export function shouldRenderOpenDesignArtifact(message, reply) {
+  const meta = parseMetadata(message?.metadata);
+  if (meta?.opendesign_render === true || meta?.open_design_render === true) return true;
+  if (meta?.whiteboard_required === true || meta?.whiteboard_require_html === true) return true;
+  const text = `${message?.content || ''}\n${reply || ''}`;
+  return DESIGN_KEYWORDS.test(text);
+}
+
+export async function prepareOpenDesignDir(config, topicId) {
+  const dir = path.join(config.artifactDir, 'opendesign', `${Date.now()}-${safeSegment(topicId || 'topic')}`);
+  await fs.mkdir(dir, { recursive: true });
+  return dir;
+}
+
+export function buildOpenDesignPrompt({ outputDir, userMessage, reply, topicId, locale = 'zh' }) {
+  const zh = locale === 'zh';
+  return [
+    'You are running the OpenDesign workflow inside wtt-connect.',
+    'Use OpenDesign skills as the governing design rules: senior designer role, HTML as output medium, context-first, anti-slop, committed aesthetic direction, artifact-first delivery.',
+    '',
+    'OpenDesign rules to follow strictly:',
+    '- Output a real design artifact, not chat prose.',
+    '- Avoid generic AI gradients, emoji icons, unearned cards, and vague placeholder copy.',
+    '- Use distinctive typography and a committed visual direction.',
+    '- Build a self-contained HTML artifact with CSS/SVG animation when explaining principles, formulas, flows, architecture, or UI.',
+    '- Every visible control or animation must have a purpose.',
+    '- Use labeled placeholders only when a real asset is unavailable.',
+    '- Close every non-void tag and keep the page runnable without network access.',
+    '',
+    `Write the artifact files directly into this directory: ${outputDir}`,
+    'Required files:',
+    '- index.html',
+    '- style.css if useful',
+    '- main.js only if interaction/state is genuinely needed',
+    '',
+    'Hard requirements:',
+    '- index.html must be complete and runnable in a sandbox iframe.',
+    '- Do not use external CDNs, remote images, external fonts, forms, cookies, localStorage, or network calls.',
+    '- Use inline SVG or local CSS/JS only.',
+    '- For formula/principle explanations include: a main diagram, step animation, symbol/metric table, minimal concrete example, explanatory text beside visuals, and final compact summary.',
+    '- For UI/prototype requests include realistic fake data, hover states, and meaningful state transitions.',
+    '',
+    `WTT topic_id: ${topicId || 'unknown'}`,
+    '',
+    zh ? '用户原始消息：' : 'Original user message:',
+    String(userMessage || '').slice(0, 5000),
+    '',
+    zh ? 'Agent 正文回答，OpenDesign artifact 必须基于这段内容重新设计，不要照抄：' : 'Agent answer to transform into the artifact:',
+    String(reply || '').slice(0, 12000),
+    '',
+    'After writing the files, reply with only a short one-line summary and the relative entry file name.',
+  ].join('\n');
+}
+
+function parseMetadata(metadata) {
+  if (!metadata) return null;
+  if (typeof metadata === 'object') return metadata;
+  try { return JSON.parse(String(metadata)); } catch { return null; }
+}
+
+function safeSegment(value) {
+  return String(value || 'artifact').replace(/[^a-zA-Z0-9._-]+/g, '-').slice(0, 80) || 'artifact';
+}

package/src/runner.js

@@ -13,6 +13,7 @@ import { log } from './logger.js';
 import { buildRuntimeInfo } from './runtime-info.js';
 import { runShellCommand } from './shell-runner.js';
 import { TerminalSessionManager } from './terminal-session.js';
+import { buildOpenDesignPrompt, prepareOpenDesignDir, shouldRenderOpenDesignArtifact } from './opendesign.js';
 
 const TERMINAL_STATUSES = new Set(['review', 'done', 'approved', 'cancelled']);
 
@@ -35,6 +36,7 @@ export class Runner {
     this.queuedTasks = new Set();
     this.runningTasks = new Set();
     this.doneTasks = new Map();
+    this.agentProfileCache = { value: null, expiresAt: 0 };
   }
 
   async start() {
@@ -156,9 +158,10 @@ export class Runner {
       const transcripts = await this.transcribeAttachments(staged.files);
       const adapter = this.registry.select({ ...m, content });
       await this.wtt.typing(topicId, 'start', { statusText: `${adapterDisplayName(adapter.name)} 正在执行`, statusKind: 'running', adapter: adapter.name, ttlMs: 30000 });
-      const agentSoul = renderAgentSoulContext(m.metadata, this.config.agentId);
+      const agentProfile = await this.getAgentProfile();
+      const agentSoul = renderAgentSoulContext(m.metadata, agentProfile?.role_template);
       const discussionRouting = renderDiscussionRoutingInstruction(m, this.config);
-      const currentDisplayName = effectiveAgentDisplayName(this.config);
+      const currentDisplayName = effectiveAgentDisplayName(this.config, agentProfile);
       const prompt = [
         'You are replying to a WTT Web conversation. Do not mention implementation internals unless asked.',
         `WTT topic_id: ${topicId}`,
@@ -189,7 +192,8 @@ export class Runner {
       });
       const reply = stripHiddenContextLeak(output || '(empty response)') || '(empty response)';
       await this.maybeAttachSpeech(topicId, reply, `chat-${topicId}`);
-      await this.wtt.publish(topicId, reply, 'CHAT_REPLY', roleContextMetadataForRelay(m.metadata));
+      await this.wtt.publish(topicId, reply, 'CHAT_REPLY');
+      await this.maybeRenderOpenDesignArtifact(m, reply, adapter);
       log('info', 'chat replied', { topicId, chars: reply.length });
     } catch (err) {
       await this.wtt.publish(topicId, `执行失败：${err.message}`, 'CHAT_REPLY');
@@ -208,8 +212,9 @@ export class Runner {
     const staged = await this.attachments.stageMessage(task);
     const transcripts = await this.transcribeAttachments(staged.files);
     const adapter = this.registry.select(task);
+    const agentProfile = await this.getAgentProfile();
     if (topicId) await this.wtt.typing(topicId, 'start', { statusText: `${adapterDisplayName(adapter.name)} 正在执行任务`, statusKind: 'running', adapter: adapter.name, ttlMs: 30000 });
-    const prompt = buildTaskPrompt(task, this.config, staged, transcripts);
+    const prompt = buildTaskPrompt(task, this.config, staged, transcripts, agentProfile);
     try {
       const output = await adapter.run(prompt, {
         sessionKey: `wtt:task:${taskId}`,
@@ -240,6 +245,14 @@ export class Runner {
     }
   }
 
+  async getAgentProfile() {
+    const now = Date.now();
+    if (this.agentProfileCache.value && now < this.agentProfileCache.expiresAt) return this.agentProfileCache.value;
+    const value = await this.api.getAgentProfile(this.config.agentId);
+    this.agentProfileCache = { value, expiresAt: now + 30_000 };
+    return value;
+  }
+
   async transcribeAttachments(files) {
     try {
       return await this.stt.transcribeAll(files);
@@ -261,6 +274,48 @@ export class Runner {
     }
   }
 
+  async maybeRenderOpenDesignArtifact(message, reply, adapter) {
+    const topicId = String(message.topic_id || '');
+    if (!topicId || !shouldRenderOpenDesignArtifact(message, reply)) return;
+    try {
+      await this.wtt.typing(topicId, 'start', {
+        statusText: 'OpenDesign 正在生成可视化 artifact',
+        statusKind: 'opendesign',
+        adapter: adapter.name,
+        ttlMs: 30000,
+      });
+      const outputDir = await prepareOpenDesignDir(this.config, topicId);
+      const prompt = buildOpenDesignPrompt({
+        outputDir,
+        userMessage: message.content || '',
+        reply,
+        topicId,
+        locale: inferLocale(`${message.content || ''}\n${reply || ''}`),
+      });
+      await adapter.run(prompt, {
+        sessionKey: `wtt:opendesign:${topicId}`,
+        topicId,
+        onProgress: (event) => this.maybePublishProgress(topicId, event, adapter.name),
+      });
+      const artifact = await this.artifacts.uploadDirectory(outputDir, {
+        source: message.topic_type || 'feed',
+        sourceId: topicId,
+        title: `OpenDesign · ${topicId.slice(0, 8)}`,
+        entry: 'index.html',
+        type: 'opendesign',
+        metadata: { message_id: message.id || message.message_id || '', generated_by: adapter.name },
+      });
+      const previewUrl = artifact.preview_url || artifact.url;
+      if (previewUrl) {
+        const title = artifact.title || 'OpenDesign artifact';
+        await this.wtt.publish(topicId, `[opendesign:${title}](${previewUrl})`, 'TASK_ARTIFACT');
+      }
+      log('info', 'opendesign artifact completed', { topicId, preview: previewUrl });
+    } catch (err) {
+      log('warn', 'opendesign artifact failed', { topicId, error: err.message });
+    }
+  }
+
   async materializeTaskArtifact(taskId, summary) {
     try {
       return await this.artifacts.uploadText(`task-${taskId}-summary.md`, summary);
@@ -311,6 +366,10 @@ function adapterDisplayName(name) {
   return name || 'Agent';
 }
 
+function inferLocale(text) {
+  return /[\u4e00-\u9fff]/.test(String(text || '')) ? 'zh' : 'en';
+}
+
 function messageTopicType(m) {
   return String(m.topic_type || metadataValue(m.metadata, 'topic_type') || metadataValue(m.metadata, 'topicType') || '').toLowerCase();
 }
@@ -473,51 +532,26 @@ function parseMetadata(metadata) {
   return obj && typeof obj === 'object' ? obj : null;
 }
 
-function effectiveAgentDisplayName(config) {
+function effectiveAgentDisplayName(config, profile = null) {
+  const profileName = String(profile?.display_name || '').trim();
+  if (profileName && profileName.toLowerCase() !== 'wtt-connect') return profileName;
   const name = String(config.setupDisplayName || '').trim();
   if (!name || name.toLowerCase() === 'wtt-connect') return '';
   return name;
 }
 
-function roleContextMetadataForRelay(metadata) {
+function renderAgentSoulContext(metadata, profileRole = null) {
   const meta = parseMetadata(metadata);
-  if (!meta || typeof meta !== 'object') return null;
-  const out = {};
-  for (const key of [
-    'agent_role_templates_by_agent',
-    'agentRoleTemplatesByAgent',
-  ]) {
-    const value = meta[key];
-    if (value && typeof value === 'object') out[key] = value;
-  }
-  return Object.keys(out).length ? out : null;
-}
-
-function renderAgentSoulContext(metadata, currentAgentId = '') {
-  const meta = parseMetadata(metadata);
-  if (!meta) return '';
 
   const lines = [];
-  const soul = meta.agent_soul;
-  const role = meta.agent_role_template;
-  const hasRoleMap = hasAgentRoleTemplateMap(meta);
-  const roleByAgent = getRoleTemplateForAgent(meta, currentAgentId);
-  const persona = meta.worker_persona;
-  const workerContext = meta.worker_context;
-
-  if (roleByAgent) {
-    if (roleByAgent.label) lines.push(`Adopt this agent role silently: ${roleByAgent.label}.`);
-    if (Array.isArray(roleByAgent.skills) && roleByAgent.skills.length) lines.push(`Relevant capabilities: ${roleByAgent.skills.join(', ')}.`);
-    const systemPrompt = roleByAgent.system_prompt || roleByAgent.systemPrompt || roleByAgent.instructions;
-    if (systemPrompt) lines.push(String(systemPrompt));
-  } else if (!hasRoleMap && soul && typeof soul === 'object') {
-    if (soul.role) lines.push(`Adopt this agent role silently: ${soul.role}.`);
-    if (Array.isArray(soul.skills) && soul.skills.length) lines.push(`Relevant capabilities: ${soul.skills.join(', ')}.`);
-    if (soul.instructions) lines.push(String(soul.instructions));
-  } else if (!hasRoleMap && role && typeof role === 'object') {
-    if (role.label) lines.push(`Adopt this agent role silently: ${role.label}.`);
-    if (Array.isArray(role.skills) && role.skills.length) lines.push(`Relevant capabilities: ${role.skills.join(', ')}.`);
-    const systemPrompt = role.system_prompt || role.systemPrompt || role.instructions;
+  const persona = meta?.worker_persona;
+  const workerContext = meta?.worker_context;
+
+  const profileRoleObject = profileRole && typeof profileRole === 'object' ? profileRole : null;
+  if (profileRoleObject && (profileRoleObject.label || profileRoleObject.system_prompt || profileRoleObject.systemPrompt)) {
+    if (profileRoleObject.label) lines.push(`Adopt this agent role silently: ${profileRoleObject.label}.`);
+    if (Array.isArray(profileRoleObject.skills) && profileRoleObject.skills.length) lines.push(`Relevant capabilities: ${profileRoleObject.skills.join(', ')}.`);
+    const systemPrompt = profileRoleObject.system_prompt || profileRoleObject.systemPrompt || profileRoleObject.instructions;
     if (systemPrompt) lines.push(String(systemPrompt));
   }
 
@@ -539,31 +573,6 @@ function renderAgentSoulContext(metadata, currentAgentId = '') {
   ].join('\n');
 }
 
-function hasAgentRoleTemplateMap(meta) {
-  const byAgent = meta.agent_role_templates_by_agent || meta.agentRoleTemplatesByAgent;
-  return Boolean(byAgent && typeof byAgent === 'object');
-}
-
-function getRoleTemplateForAgent(meta, currentAgentId) {
-  const byAgent = meta.agent_role_templates_by_agent || meta.agentRoleTemplatesByAgent;
-  if (!byAgent || typeof byAgent !== 'object' || !currentAgentId) return null;
-
-  const exact = byAgent[currentAgentId];
-  if (exact && typeof exact === 'object') return exact;
-
-  const normalizedCurrent = normalizeAgentRoleMapKey(currentAgentId);
-  for (const [agentId, role] of Object.entries(byAgent)) {
-    if (normalizeAgentRoleMapKey(agentId) === normalizedCurrent && role && typeof role === 'object') {
-      return role;
-    }
-  }
-  return null;
-}
-
-function normalizeAgentRoleMapKey(value) {
-  return String(value || '').trim().toLowerCase();
-}
-
 function stripHiddenContextLeak(text) {
   return String(text || '')
     .replace(/\[Agent Role Template\][\s\S]*?\[\/Agent Role Template\]\s*/gi, '')
@@ -639,10 +648,10 @@ function taskFromEvent(taskId, event) {
   return { id: taskId, title: m.title || `WTT task ${taskId}`, description: m.content || '', topic_id: m.topic_id };
 }
 
-function buildTaskPrompt(task, config, staged = { promptBlock: '' }, transcripts = []) {
+function buildTaskPrompt(task, config, staged = { promptBlock: '' }, transcripts = [], agentProfile = null) {
   const title = task.title || task.name || `Task ${task.id}`;
   const description = task.description || task.content || task.task_request || '';
-  const agentSoul = renderAgentSoulContext(task.metadata || task.msg_metadata, config.agentId);
+  const agentSoul = renderAgentSoulContext(task.metadata || task.msg_metadata, agentProfile?.role_template);
   return [
     'You are executing a WTT task through wtt-connect.',
     `Task ID: ${task.id}`,

package/src/wtt-api.js

@@ -49,6 +49,16 @@ export class WTTApi {
     }
   }
 
+  async getAgentProfile(agentId = this.config.agentId) {
+    if (!agentId) return null;
+    try {
+      return await this.request('GET', `/agents/${encodeURIComponent(agentId)}/profile`);
+    } catch (err) {
+      log('warn', 'get_agent_profile failed', { agentId, error: err.message });
+      return null;
+    }
+  }
+
   async patchTask(taskId, payload) {
     if (this.config.dryRun) {
       log('info', 'dry-run patch task', { taskId, fields: Object.keys(payload).join(',') });

package/systemd/wtt-connect-claude.service

@@ -1,14 +0,0 @@
-[Unit]
-Description=WTT Connect Claude Code Agent
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-WorkingDirectory=/mnt/wd10t/saiph/wtt/wtt/tools/wtt-connect
-ExecStart=/usr/bin/node --experimental-websocket /mnt/wd10t/saiph/wtt/wtt/tools/wtt-connect/bin/wtt-connect.js start --env-file /mnt/wd10t/saiph/wtt/wtt/tools/wtt-connect/.env.claude
-Restart=always
-RestartSec=5
-
-[Install]
-WantedBy=default.target

package/systemd/wtt-connect-codex.service

@@ -1,14 +0,0 @@
-[Unit]
-Description=WTT Connect Codex Agent
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-WorkingDirectory=/mnt/wd10t/saiph/wtt/wtt/tools/wtt-connect
-ExecStart=/usr/bin/node --experimental-websocket /mnt/wd10t/saiph/wtt/wtt/tools/wtt-connect/bin/wtt-connect.js start --env-file /mnt/wd10t/saiph/wtt/wtt/tools/wtt-connect/.env
-Restart=always
-RestartSec=5
-
-[Install]
-WantedBy=default.target