wtt-connect 0.2.6 → 0.2.8

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`:
@@ -265,6 +295,8 @@ Uninstall one identity with:
 
 Discussion/collaborative topics are mention-gated: `wtt-connect` only replies when the message targets its `WTT_AGENT_ID`, one of `WTT_CONNECT_AGENT_ALIASES`, backend-resolved `runner_agent_id`, or a multi-mention `mention_target_agent_ids` entry. P2P and task topics still run normally.
 
+In discussion/collaborative topics, `wtt-connect` also injects a silent collaboration standard into each agent prompt. Agents should treat the topic as a shared workboard, preserve shared state, split non-trivial work into owned tasks, state concrete done criteria, report execution evidence, challenge weak assumptions, and only @mention the next specific agent when handoff is required.
+
 Adapter routing can be explicit through task fields such as `exec_mode=gemini`, or through message mentions such as `@codex`, `@claude`, `@cursor`, `@gemini`, `@qoder`, `@opencode`, `@iflow`, `@kimi`, `@pi`, `@acp`, or `@devin` when those adapters are enabled.
 
 OpenClaw is deliberately not part of the default `wtt-connect` adapter set because WTT already has the first-class `wtt-plugin` for OpenClaw.

package/package.json

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

@@ -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/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();
 }
@@ -427,6 +573,16 @@ function renderDiscussionRoutingInstruction(m, config) {
     '- If you want a different agent to continue, @mention only that other agent by its exact visible name or agent id from the conversation.',
     '- If your reply is a final answer, summary, or no further agent action is needed, do not @mention anyone.',
     '- Do not use @all or vague mentions; mention only the specific next agent that should act.',
+    '',
+    'Internal WTT group-collaboration operating standard. Use it silently to structure useful replies:',
+    '- Treat the topic as a shared workboard. Preserve shared state: goal, assumptions, decisions, owners, artifacts, blockers, and evidence.',
+    '- For non-trivial work, make planning explicit before execution: split the work into small tasks, assign one owner per task, and define a concrete done criterion for each task.',
+    '- When you are the owner of a task, report in this shape when useful: `Owner: <your name>`, `Task: <specific work>`, `Done criteria: <observable result>`, `Status: planned|running|blocked|done`, `Evidence: <files/tests/commands/artifacts>`, `Next: <next action or @agent>`.',
+    '- Prefer action over discussion: if you can safely execute or verify something in your environment, do it and report evidence instead of only suggesting it.',
+    '- Challenge weak assumptions, missing tests, unclear interfaces, and risky plans. Keep criticism concrete and tied to the task outcome.',
+    '- Do not repeat another agent unless adding new evidence, a correction, a decision, or a next action.',
+    '- For simple direct questions, answer normally and briefly; do not force the full task template.',
+    '- For final summaries, include completed work, remaining blockers, and recommended next owner only if more work is needed.',
   ].join('\n');
 }
 
@@ -696,6 +852,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');
 }