wtt-connect 0.2.5 → 0.2.7

package/README.md

@@ -28,6 +28,7 @@ Implemented production-oriented surfaces:
 - HTTP task status update path
 - Permission broker for Codex modes, including explicit opt-in for dangerous `yolo`
 - Optional WTT media artifact upload path (`/media/sign` → direct upload → `/media/commit`)
+- Agent-generated file artifacts for WTT feed chat (`.docx`, `.pptx`, `.xlsx`, `.pdf`, `.csv`, `.zip`) using explicit final-response markers that are converted into WTT file cards
 - Attachment staging for WTT message media/files; image attachments are passed to Codex with `--image` (including Claude Code image fallback when the Claude provider cannot view images directly)
 - STT extension point (`command` and OpenAI/Whisper providers) for audio attachments
 - Setup/claim-code command, smoke-task/smoke-chat commands, start script, and macOS launchd installer
@@ -106,6 +107,35 @@ A JSON config may also be supplied:
 node ./bin/wtt-connect.js start --config ./config.json
 ```
 
+### Generated files in feed chat
+
+Codex, Claude Code, and other adapters can generate user-facing files on the agent host and send them back to WTT feed chat as clickable file cards.
+
+Supported generated artifact types:
+
+```text
+.doc .docx .ppt .pptx .xls .xlsx .pdf .csv .md .txt .zip
+```
+
+When an agent creates a deliverable file, it should save the file under its workspace or artifact directory and include one final-response marker per file:
+
+```text
+[WTT_ARTIFACT_FILE path="report.docx" title="Project Report"]
+[WTT_ARTIFACT_FILE path="/absolute/workspace/slides.pptx" title="Review Slides"]
+```
+
+`wtt-connect` removes those marker lines from the visible reply, uploads each file through WTT media, and publishes file cards like:
+
+```text
+[file:Project Report](https://...)
+```
+
+Notes:
+
+- Generated file markers are explicit user-facing uploads; they are uploaded even when `WTT_CONNECT_UPLOAD_ARTIFACTS=0`.
+- Files outside the configured workspace, state directory, inbox directory, or artifact directory are ignored to avoid accidental leakage.
+- `WTT_CONNECT_UPLOAD_ARTIFACTS=1` still controls automatic summary/TTS uploads; it is not required for explicit generated file markers.
+
 ### One-command service binding
 
 The recommended install path for users is npm + `up`:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wtt-connect",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "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

@@ -17,8 +17,8 @@ export class ArtifactManager {
     return file;
   }
 
-  async uploadFile(filePath) {
-    if (!this.config.uploadArtifacts) return null;
+  async uploadFile(filePath, options = {}) {
+    if (!this.config.uploadArtifacts && !options.force) return null;
     const stat = await fs.stat(filePath);
     if (!stat.isFile()) return null;
     const mimeType = lookupMime(filePath);

package/src/mime.js

@@ -1,6 +1,10 @@
 const MAP = new Map([
   ['.txt', 'text/plain'], ['.md', 'text/markdown'], ['.json', 'application/json'],
-  ['.html', 'text/html'], ['.pdf', 'application/pdf'], ['.zip', 'application/zip'],
+  ['.html', 'text/html'], ['.htm', 'text/html'], ['.pdf', 'application/pdf'], ['.zip', 'application/zip'],
+  ['.csv', 'text/csv'], ['.xml', 'text/xml'], ['.yml', 'application/x-yaml'], ['.yaml', 'application/x-yaml'],
+  ['.doc', 'application/msword'], ['.docx', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'],
+  ['.ppt', 'application/vnd.ms-powerpoint'], ['.pptx', 'application/vnd.openxmlformats-officedocument.presentationml.presentation'],
+  ['.xls', 'application/vnd.ms-excel'], ['.xlsx', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'],
   ['.png', 'image/png'], ['.jpg', 'image/jpeg'], ['.jpeg', 'image/jpeg'],
   ['.gif', 'image/gif'], ['.webp', 'image/webp'], ['.mp3', 'audio/mpeg'],
   ['.wav', 'audio/wav'], ['.ogg', 'audio/ogg'], ['.webm', 'audio/webm'], ['.mp4', 'video/mp4'], ['.mov', 'video/quicktime'],

package/src/opendesign.js

@@ -55,6 +55,8 @@ export async function buildOpenDesignPrompt({ config, outputDir, userMessage, re
     '- Do not use external CDNs, remote images, external fonts, forms, cookies, localStorage, or network calls.',
     '- Use inline SVG or local CSS/JS only.',
     '- Treat this as a premium visual explainer, not a documentation page. The first viewport must look intentionally designed.',
+    '- Never rely on browser default fonts or default black SVG fills. Every SVG shape must intentionally set fill/stroke from named CSS variables.',
+    '- Do not produce black-on-white blob diagrams. Large black/dark fills, default #000 text-only SVGs, and unstyled Times/Arial pages are failed artifacts.',
     '- 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.',
     '',
@@ -132,7 +134,22 @@ export async function evaluateOpenDesignArtifact(dir) {
   if (/data-step|step-|timeline|progress|播放|replay|next/i.test(combined)) score += 1;
   else issues.push('missing step-by-step interaction/state');
 
-  return { ok: score >= 6, score, issues };
+  const lower = combined.toLowerCase();
+  const blackishTokens = (lower.match(/(?:#[0-2]{3,6}\b|rgb\(\s*(?:0|1?\d|2\d|3\d)\s*,\s*(?:0|1?\d|2\d|3\d)\s*,\s*(?:0|1?\d|2\d|3\d)\s*\)|fill=["'](?:black|#000|#111|#222)|background(?:-color)?:\s*(?:#000|#111|#121212|black))/g) || []).length;
+  const colorTokens = new Set((lower.match(/#[0-9a-f]{3,8}\b|oklch\([^)]+\)|hsl\([^)]+\)|rgb\([^)]+\)/g) || [])
+    .filter((token) => !/^#(?:000|111|222|333|fff|ffffff)\b/.test(token)));
+  if (blackishTokens <= 8 && colorTokens.size >= 8) score += 1;
+  else issues.push('visual palette is too black/default or lacks enough intentional color tokens; avoid black blob diagrams');
+
+  const fontFamilies = (combined.match(/font-family\s*:\s*([^;}]+)/gi) || []).join('\n').toLowerCase();
+  if (fontFamilies && !/inter|roboto|arial,\s*sans-serif|system-ui,\s*sans-serif/.test(fontFamilies)) score += 1;
+  else issues.push('typography is too default; use a distinctive local font stack, not Inter/Roboto/Arial/system-only');
+
+  const svgFills = (combined.match(/fill=["'][^"']+["']|fill:\s*[^;}]+/gi) || []).join('\n').toLowerCase();
+  if (svgFills && !/fill=["'](?:black|#000|#111|#222)["']/.test(svgFills)) score += 1;
+  else issues.push('SVG appears to rely on default/black fills; explicitly use colored fills and strokes for nodes, arrows, and highlights');
+
+  return { ok: score >= 8, score, issues };
 }
 
 async function loadSkillBlocks(config, skillNames) {
@@ -165,11 +182,12 @@ function visualQualityContract(zh) {
     '- Canvas: design for a 1440x900 whiteboard/preview area, responsive down to tablet. Use full-width composition, not a narrow article.',
     '- Visual hierarchy: strong title block, one dominant SVG/canvas diagram, one compact example panel, one formula/symbol table, one step timeline, and a final takeaway strip.',
     '- Default aesthetic when the user did not request a theme: light editorial research board, warm off-white paper, precise ink lines, subtle grid/noise, restrained color accents, refined spacing. It should feel closer to a polished team workspace/design note than a dark coding console.',
-    '- Aesthetic: choose a committed direction such as editorial lab notebook, precision engineering console, warm classroom blackboard, industrial systems map, or high-contrast research poster. Avoid generic SaaS cards.',
-    '- Typography: use distinctive CSS font stacks from local system fonts only, for example Georgia/Times editorial serif plus ui-monospace accents, or Avenir/Helvetica Neue with a mono data layer. Do not use plain Inter/Roboto/Arial defaults.',
-    '- Color: define CSS variables in :root. Use a restrained but intentional palette with textured background, grid/noise/paper effect, or layered panels. Avoid flat dark gray, neon cyan buttons, purple gradients, and default dark-mode dashboards unless the content explicitly requires them.',
+    '- Aesthetic: choose a committed direction such as editorial lab notebook, precision engineering console, warm classroom board, industrial systems map, or high-contrast research poster. Avoid generic SaaS cards.',
+    '- Typography: define a non-default font system in :root/body. Recommended local stacks: "Avenir Next", "Helvetica Neue", sans-serif for UI; Georgia, "Times New Roman", serif for editorial formulas; "SFMono-Regular", "Cascadia Code", monospace for data. Do not use plain Inter/Roboto/Arial/default browser font stacks.',
+    '- Color: define CSS variables in :root and use at least 8 named color tokens. Use a restrained but intentional palette with textured background, grid/noise/paper effect, or layered panels. Avoid flat dark gray, neon cyan buttons, purple gradients, and default dark-mode dashboards unless the content explicitly requires them.',
+    '- No black blob rule: SVG rectangles, circles, arrows, and paths must not default to black. Use colored fills like parchment, blue, amber, green, coral, slate ink, and colored strokes. Large dark regions must be rare accents, never the dominant diagram body.',
     '- Polish: use fine borders, soft shadows, intentional whitespace, aligned baselines, and varied panel sizes. Do not make every block the same rounded rectangle.',
-    '- SVG: include at least one large inline SVG with labeled nodes, arrows, and a visible animated path. Arrow animation must be obvious: stroke-dasharray/stroke-dashoffset or moving marker/dot.',
+    '- SVG: include at least one large inline SVG with labeled nodes, arrows, and a visible animated path. Every shape must have explicit fill/stroke. Arrow animation must be obvious: stroke-dasharray/stroke-dashoffset or moving marker/dot, and final arrow/path must remain visible after animation ends.',
     '- Motion: include 2-4 purposeful animations: entry reveal, arrow/path draw, active step highlight, formula/example transition. Respect prefers-reduced-motion.',
     '- Explanation: every diagram node must have adjacent text that explains why it matters. Do not rely on labels alone.',
     '- Example: include a minimal concrete example with inputs, intermediate transformation, and output/result.',

package/src/runner.js

@@ -1,5 +1,7 @@
 import { WTTClient } from './wtt-client.js';
 import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
 import { WTTApi } from './wtt-api.js';
 import { SessionManager } from './session-manager.js';
 import { TTSManager } from './tts.js';
@@ -17,6 +19,8 @@ import { TerminalSessionManager } from './terminal-session.js';
 import { buildOpenDesignPrompt, buildOpenDesignRepairPrompt, chooseOpenDesignSkills, evaluateOpenDesignArtifact, prepareOpenDesignDir, shouldRenderOpenDesignArtifact } from './opendesign.js';
 
 const TERMINAL_STATUSES = new Set(['review', 'done', 'approved', 'cancelled']);
+const GENERATED_FILE_EXTENSIONS = new Set(['.doc', '.docx', '.ppt', '.pptx', '.xls', '.xlsx', '.pdf', '.csv', '.md', '.txt', '.zip']);
+const AUTO_DETECTED_FILE_EXTENSIONS = '(?:docx?|pptx?|xlsx?|pdf|csv|zip)';
 
 export class Runner {
   constructor(config) {
@@ -183,6 +187,7 @@ export class Runner {
         '',
         staged.promptBlock,
         renderTranscriptBlock(transcripts),
+        renderGeneratedFileArtifactInstruction(this.config),
         'Reply naturally and concisely unless the user asks for detail.',
       ].filter(Boolean).join('\n');
       const output = await adapter.run(prompt, {
@@ -192,9 +197,11 @@ export class Runner {
         images: staged.images,
         onProgress: (event) => this.maybePublishProgress(topicId, event, adapter.name),
       });
-      const reply = stripHiddenContextLeak(output || '(empty response)') || '(empty response)';
+      const prepared = prepareGeneratedFileArtifacts(stripHiddenContextLeak(output || '(empty response)') || '(empty response)');
+      const reply = prepared.text || '(empty response)';
       await this.maybeAttachSpeech(topicId, reply, `chat-${topicId}`);
       await this.wtt.publish(topicId, reply, 'CHAT_REPLY');
+      await this.publishGeneratedFileArtifacts(topicId, prepared.refs, { source: 'chat', sourceId: topicId, adapter: adapter.name });
       await this.maybeRenderOpenDesignArtifact(m, reply, adapter);
       log('info', 'chat replied', { topicId, chars: reply.length });
     } catch (err) {
@@ -226,7 +233,8 @@ export class Runner {
         images: staged.images,
         onProgress: (ev) => topicId ? this.maybePublishProgress(topicId, ev, adapter.name) : Promise.resolve(),
       });
-      const summary = output || '(empty response)';
+      const prepared = prepareGeneratedFileArtifacts(output || '(empty response)');
+      const summary = prepared.text || '(empty response)';
       await this.maybeRelayArenaOpenCLResult(task, summary);
       const artifact = await this.materializeTaskArtifact(taskId, summary);
       const commitIds = extractCommitIds(summary);
@@ -235,6 +243,7 @@ export class Runner {
       await this.api.patchTask(taskId, patch);
       if (topicId) {
         await this.wtt.publish(topicId, summary, 'TASK_SUMMARY');
+        await this.publishGeneratedFileArtifacts(topicId, prepared.refs, { source: 'task', sourceId: taskId, adapter: adapter.name });
         if (artifact?.asset?.url) await this.wtt.publish(topicId, `Artifact: ${artifact.asset.url}`, 'TASK_ARTIFACT');
       }
       log('info', 'task completed', { taskId, chars: summary.length });
@@ -339,6 +348,49 @@ export class Runner {
     }
   }
 
+  async publishGeneratedFileArtifacts(topicId, refs, context = {}) {
+    if (!topicId || !Array.isArray(refs) || !refs.length) return [];
+    const uploaded = [];
+    const seen = new Set();
+    for (const ref of refs) {
+      const resolved = resolveGeneratedFilePath(ref.path, this.config);
+      if (!resolved || seen.has(resolved)) continue;
+      seen.add(resolved);
+      try {
+        const stat = await fsp.stat(resolved);
+        if (!stat.isFile()) continue;
+        await this.wtt.typing(topicId, 'start', {
+          statusText: `Agent 正在上传生成文件：${path.basename(resolved)}`,
+          statusKind: 'artifact_upload',
+          adapter: context.adapter,
+          ttlMs: 60000,
+        });
+        const asset = await this.artifacts.uploadFile(resolved, { force: true });
+        const url = asset?.url || asset?.public_url;
+        if (!url) continue;
+        const fileName = ref.title || path.basename(resolved);
+        await this.wtt.publish(
+          topicId,
+          `[file:${fileName}](${url})`,
+          'TASK_ARTIFACT',
+          {
+            type: 'generated_file',
+            source: context.source || 'agent',
+            source_id: context.sourceId || '',
+            file_name: fileName,
+            local_path: resolved,
+            mime_type: asset.mime_type || '',
+            size: asset.size || stat.size,
+          },
+        );
+        uploaded.push({ path: resolved, asset });
+      } catch (err) {
+        log('warn', 'generated file artifact upload failed', { topicId, file: ref.path, error: err.message });
+      }
+    }
+    return uploaded;
+  }
+
   async materializeTaskArtifact(taskId, summary) {
     try {
       return await this.artifacts.uploadText(`task-${taskId}-summary.md`, summary);
@@ -401,6 +453,100 @@ function webPreviewUrl(url) {
   return text;
 }
 
+function renderGeneratedFileArtifactInstruction(config) {
+  return [
+    'Generated file artifact rule, for internal execution only:',
+    `- If you create a user-facing file (.docx, .pptx, .xlsx, .pdf, .csv, .zip), save it under the workspace or artifact directory: ${config.artifactDir}.`,
+    '- Include one marker line per generated file in your final response, exactly like: [WTT_ARTIFACT_FILE path="relative/or/absolute/file.docx" title="optional display name"].',
+    '- Do not use this marker for source code files, temp files, private logs, credentials, or internal scratch files.',
+    '- wtt-connect will remove the marker from the visible chat and publish a WTT file card.',
+  ].join('\n');
+}
+
+function prepareGeneratedFileArtifacts(text) {
+  const input = String(text || '');
+  const refs = [];
+  let cleaned = input.replace(/^\s*\[WTT_ARTIFACT_FILE\s+([^\]]+)\]\s*$/gim, (_all, attrs) => {
+    const parsed = parseArtifactMarkerAttrs(attrs);
+    if (parsed.path) refs.push(parsed);
+    return '';
+  });
+  cleaned = cleaned.replace(/^\s*WTT_ARTIFACT_FILE\s*:\s*(.+?)\s*$/gim, (_all, body) => {
+    const parsed = parseArtifactLine(body);
+    if (parsed.path) refs.push(parsed);
+    return '';
+  });
+  for (const ref of extractLocalFilePathRefs(cleaned)) refs.push(ref);
+  return { text: cleaned.replace(/\n{3,}/g, '\n\n').trim(), refs: dedupeArtifactRefs(refs) };
+}
+
+function parseArtifactMarkerAttrs(attrs) {
+  const out = {};
+  for (const m of String(attrs || '').matchAll(/([a-zA-Z_][\w-]*)\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s]+))/g)) {
+    out[m[1]] = m[2] || m[3] || m[4] || '';
+  }
+  return { path: String(out.path || out.file || '').trim(), title: String(out.title || out.name || '').trim() };
+}
+
+function parseArtifactLine(body) {
+  const text = String(body || '').trim();
+  const parts = text.split(/\s+\|\s+/, 2);
+  return { path: stripPathPunctuation(parts[0] || ''), title: String(parts[1] || '').trim() };
+}
+
+function extractLocalFilePathRefs(text) {
+  const refs = [];
+  const body = String(text || '');
+  const ext = AUTO_DETECTED_FILE_EXTENSIONS;
+  const pathLike = new RegExp(`(?:^|[\\s"'\\\`(（])((?:~\\/|\\.{1,2}\\/|\\/)[^\\s"'\\\`<>]+?\\.${ext})(?=$|[\\s"'\\\`)）.,;，。；])`, 'gi');
+  for (const m of body.matchAll(pathLike)) refs.push({ path: stripPathPunctuation(m[1]), title: '' });
+  const basename = new RegExp(`\\b([A-Za-z0-9][A-Za-z0-9._-]{0,160}\\.${ext})\\b`, 'gi');
+  for (const m of body.matchAll(basename)) refs.push({ path: stripPathPunctuation(m[1]), title: '' });
+  return refs;
+}
+
+function stripPathPunctuation(value) {
+  return String(value || '').trim().replace(/^["'`]+|["'`.,;:，。；：)）\]]+$/g, '');
+}
+
+function dedupeArtifactRefs(refs) {
+  const out = [];
+  const seen = new Set();
+  for (const ref of refs) {
+    const filePath = stripPathPunctuation(ref?.path || '');
+    if (!filePath) continue;
+    const key = filePath.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({ path: filePath, title: String(ref?.title || '').trim() });
+  }
+  return out;
+}
+
+function resolveGeneratedFilePath(filePath, config) {
+  const raw = stripPathPunctuation(filePath);
+  if (!raw || /^https?:\/\//i.test(raw)) return null;
+  const ext = path.extname(raw).toLowerCase();
+  if (!GENERATED_FILE_EXTENSIONS.has(ext)) return null;
+
+  const expanded = raw.startsWith('~/') ? path.join(process.env.HOME || '', raw.slice(2)) : raw;
+  const base = path.resolve(config.workDir || process.cwd());
+  const resolved = path.resolve(path.isAbsolute(expanded) ? expanded : path.join(base, expanded));
+  const roots = [
+    config.workDir,
+    config.artifactDir,
+    config.storeFile ? path.dirname(config.storeFile) : '',
+    config.inboxDir,
+  ].filter(Boolean).map((root) => path.resolve(root));
+  if (!roots.some((root) => isPathInside(resolved, root))) return null;
+  return resolved;
+}
+
+function isPathInside(candidate, root) {
+  const rel = path.relative(root, candidate);
+  return rel === '' || (rel && !rel.startsWith('..') && !path.isAbsolute(rel));
+}
+
 function messageTopicType(m) {
   return String(m.topic_type || metadataValue(m.metadata, 'topic_type') || metadataValue(m.metadata, 'topicType') || '').toLowerCase();
 }
@@ -696,6 +842,7 @@ function buildTaskPrompt(task, config, staged = { promptBlock: '' }, transcripts
     renderTranscriptBlock(transcripts),
     '',
     config.requireCommitPush ? 'For code changes, commit and push before final response, and include commit id.' : '',
+    renderGeneratedFileArtifactInstruction(config),
     'Return a concise final summary with evidence, changed files, tests, artifacts, and blockers.',
   ].filter(Boolean).join('\n');
 }