wtt-connect 0.1.0 → 0.1.4

package/package.json

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

package/src/adapters/claude-code.js

@@ -11,18 +11,18 @@ export class ClaudeCodeAdapter {
   async run(prompt, context = {}) {
     if (context.images?.length && this.config.codexBin) {
       log('info', 'claude-code image fallback via codex', { sessionKey: context.sessionKey || 'default', images: context.images.length });
-      return runCodexVision(this.config.codexBin, prompt, context.images, this.config.workDir, this.config.taskTimeoutSeconds * 1000, this.config);
+      return runCodexVision(this.config.codexBin, prompt, context.images, this.config.workDir, this.config.taskTimeoutSeconds * 1000, this.config, context.onProgress);
     }
     // Claude Code 2.x requires --verbose when stream-json is used with --print/-p.
     const args = ['-p', prompt, '--output-format', 'stream-json', '--verbose'];
     if (this.config.mode === 'yolo') args.push('--dangerously-skip-permissions', '--permission-mode', 'bypassPermissions');
     if (this.config.model) args.push('--model', this.config.model);
     log('info', 'claude-code launch', { sessionKey: context.sessionKey || 'default' });
-    return runClaude(this.config.claudeBin, args, this.config.workDir, this.config.taskTimeoutSeconds * 1000);
+    return runClaude(this.config.claudeBin, args, this.config.workDir, this.config.taskTimeoutSeconds * 1000, context.onProgress);
   }
 }
 
-function runClaude(bin, args, cwd, timeoutMs) {
+function runClaude(bin, args, cwd, timeoutMs, onEvent) {
   return new Promise((resolve, reject) => {
     const child = spawn(bin, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env } });
     let stderr = '';
@@ -39,6 +39,7 @@ function runClaude(bin, args, cwd, timeoutMs) {
         rawLines.push(line);
         if (rawLines.length > 20) rawLines.shift();
         const ev = JSON.parse(line);
+        if (onEvent) Promise.resolve(onEvent(ev)).catch(() => {});
         const evError = extractEventError(ev);
         if (evError) streamError = evError;
         if (typeof ev.result === 'string' && ev.result.trim()) {
@@ -57,7 +58,7 @@ function runClaude(bin, args, cwd, timeoutMs) {
   });
 }
 
-async function runCodexVision(bin, prompt, images, cwd, timeoutMs, config = {}) {
+async function runCodexVision(bin, prompt, images, cwd, timeoutMs, config = {}, onEvent) {
   const args = ['exec', '--skip-git-repo-check', '--json', '--cd', cwd];
   if (config.mode === 'yolo') args.push('--dangerously-bypass-approvals-and-sandbox');
   for (const img of images || []) args.push('--image', img);
@@ -77,6 +78,7 @@ async function runCodexVision(bin, prompt, images, cwd, timeoutMs, config = {})
       if (!line.trim()) return;
       try {
         const event = JSON.parse(line);
+        if (onEvent) Promise.resolve(onEvent(event)).catch(() => {});
         const text = extractCodexText(event);
         if (text) messages.push(text);
       } catch {}

package/src/adapters/codex.js

@@ -17,19 +17,32 @@ export class CodexAdapter {
     const threadId = this.threadBySession.get(sessionKey) || stored.codexThreadId;
     const args = this.buildArgs(threadId, context);
     log('info', 'codex launch', { sessionKey, resume: Boolean(threadId), mode: this.config.mode });
-    const result = await runJsonCli(this.config.codexBin, args, prompt, this.config.workDir, (event) => {
+    let result;
+    try {
+      result = await this.runWithArgs(args, prompt, context, sessionKey);
+    } catch (err) {
+      if (!threadId || !shouldRetryFreshThread(err)) throw err;
+      log('warn', 'codex resume failed; retrying with fresh thread', { sessionKey, threadId, error: err.message });
+      this.threadBySession.delete(sessionKey);
+      this.store?.patchSession(sessionKey, { codexThreadId: '', adapter: this.name });
+      result = await this.runWithArgs(this.buildArgs('', context), prompt, context, sessionKey);
+    }
+    if (result.threadId) {
+      this.threadBySession.set(sessionKey, result.threadId);
+      this.store?.patchSession(sessionKey, { codexThreadId: result.threadId, adapter: this.name });
+    }
+    return result.text.trim();
+  }
+
+  async runWithArgs(args, prompt, context, sessionKey) {
+    return runJsonCli(this.config.codexBin, args, prompt, this.config.workDir, (event) => {
       const eventThreadId = event.thread_id || event.session_id || event.conversation_id;
       if ((event.type === 'thread.started' || event.type === 'session.started') && eventThreadId) {
         this.threadBySession.set(sessionKey, eventThreadId);
         this.store?.patchSession(sessionKey, { codexThreadId: eventThreadId, adapter: this.name });
       }
-      if (this.config.publishProgress && context.onProgress) context.onProgress(event).catch(() => {});
+      if (context.onProgress) context.onProgress(event).catch(() => {});
     }, this.config.taskTimeoutSeconds * 1000);
-    if (result.threadId) {
-      this.threadBySession.set(sessionKey, result.threadId);
-      this.store?.patchSession(sessionKey, { codexThreadId: result.threadId, adapter: this.name });
-    }
-    return result.text.trim();
   }
 
   buildArgs(threadId, context = {}) {
@@ -43,6 +56,18 @@ export class CodexAdapter {
   }
 }
 
+function shouldRetryFreshThread(err) {
+  const message = String(err?.message || err || '').toLowerCase();
+  return [
+    'exec resume',
+    'transport channel closed',
+    'http/request failed',
+    'failed to refresh available models',
+    'timed out',
+    'timeout waiting for child process',
+  ].some((needle) => message.includes(needle));
+}
+
 async function runJsonCli(bin, args, stdinText, cwd, onEvent, timeoutMs) {
   return new Promise((resolve, reject) => {
     const child = spawn(bin, args, { cwd, stdio: ['pipe', 'pipe', 'pipe'], env: { ...process.env } });

package/src/adapters/generic-cli.js

@@ -141,7 +141,7 @@ export class GenericCliAdapter {
     const result = await runCli(bin, built.args, built.stdin, this.config.workDir, (event) => {
       const eventSessionId = extractSessionId(event);
       if (eventSessionId) this.store?.patchSession(sessionKey, { [storedKey]: eventSessionId, adapter: this.name });
-      if (this.config.publishProgress && context.onProgress) context.onProgress(event).catch(() => {});
+      if (context.onProgress) context.onProgress(event).catch(() => {});
     }, this.config.taskTimeoutSeconds * 1000);
     if (result.sessionId) this.store?.patchSession(sessionKey, { [storedKey]: result.sessionId, adapter: this.name });
     return result.text.trim();

package/src/events.js

@@ -2,6 +2,24 @@ export function normalizeAgentEvent(adapterName, event) {
   const item = event?.item || {};
   const type = event?.type || '';
   const now = new Date().toISOString();
+
+  if (adapterName === 'claude-code') {
+    if (type === 'system') return { kind: 'session', status: 'started', text: event.subtype || 'session started', time: now, raw: event };
+    if (type === 'result') return { kind: 'turn', status: 'completed', text: event.result ? 'response completed' : 'turn completed', time: now, raw: event };
+    if (type === 'assistant') {
+      const parts = Array.isArray(event.message?.content) ? event.message.content : [];
+      const tool = parts.find((part) => part?.type === 'tool_use');
+      if (tool) {
+        const name = tool.name || 'tool';
+        const summary = summarizeToolInput(tool.input);
+        return { kind: 'tool', status: 'started', text: summary ? `${name} ${summary}` : name, time: now, raw: event };
+      }
+      if (parts.some((part) => part?.type === 'text' && String(part.text || '').trim())) {
+        return { kind: 'response', status: 'started', text: 'writing response', time: now, raw: event };
+      }
+    }
+  }
+
   if (type === 'item.started') {
     const kind = item.type || 'item';
     if (kind === 'command_execution') return { kind: 'command', status: 'started', text: item.command || 'command', time: now, raw: event };
@@ -21,3 +39,33 @@ export function renderStatusLine(evt) {
   if (!evt) return '';
   return `[TASK_STATUS] time=${evt.time} status=${evt.status} action=${evt.kind}:${String(evt.text || '').slice(0, 180)}`;
 }
+
+export function renderActivityText(evt, adapterName = 'agent') {
+  if (!evt) return '';
+  const adapter = adapterName === 'claude-code' ? 'Claude Code' : adapterName === 'codex' ? 'Codex' : adapterName;
+  const text = String(evt.text || '').trim();
+  if (evt.status === 'failed') return `${adapter} 执行失败：${text || evt.kind || 'error'}`;
+  if (evt.status === 'completed') return `${adapter} 已完成 ${labelKind(evt.kind)}`;
+  if (evt.kind === 'command') return `${adapter} 正在执行命令：${text || 'command'}`;
+  if (evt.kind === 'tool') return `${adapter} 正在调用工具：${text || 'tool'}`;
+  if (evt.kind === 'web_search') return `${adapter} 正在搜索：${text || 'web search'}`;
+  if (evt.kind === 'response') return `${adapter} 正在组织回复`;
+  if (evt.kind === 'session') return `${adapter} 会话已启动`;
+  return `${adapter} 正在执行：${text || labelKind(evt.kind)}`;
+}
+
+function labelKind(kind) {
+  const value = String(kind || '').replace(/_/g, ' ').trim();
+  return value || 'step';
+}
+
+function summarizeToolInput(input) {
+  if (!input || typeof input !== 'object') return '';
+  const command = input.command || input.cmd;
+  if (command) return String(command).slice(0, 120);
+  const path = input.path || input.file_path || input.file;
+  if (path) return String(path).slice(0, 120);
+  const query = input.query || input.pattern;
+  if (query) return String(query).slice(0, 120);
+  return '';
+}

package/src/runner.js

@@ -8,7 +8,7 @@ import { AttachmentManager } from './attachments.js';
 import { DurableStore } from './store.js';
 import { PermissionBroker } from './permissions.js';
 import { STTManager } from './stt.js';
-import { normalizeAgentEvent, renderStatusLine } from './events.js';
+import { normalizeAgentEvent, renderActivityText, renderStatusLine } from './events.js';
 import { log } from './logger.js';
 import { buildRuntimeInfo } from './runtime-info.js';
 import { runShellCommand } from './shell-runner.js';
@@ -151,16 +151,24 @@ export class Runner {
     if (!topicId) return;
     const staged = await this.attachments.stageMessage(m);
     if (!content && !staged.files.length) return;
-    await this.wtt.typing(topicId, 'start');
+    await this.wtt.typing(topicId, 'start', { statusText: 'Agent 已接收消息，正在准备执行', statusKind: 'queued', ttlMs: 30000 });
     try {
       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);
+      const discussionRouting = renderDiscussionRoutingInstruction(m, this.config);
       const prompt = [
         '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'}`,
+        `current_agent_id: ${this.config.agentId || 'unknown'}`,
+        this.config.setupDisplayName ? `current_agent_display_name: ${this.config.setupDisplayName}` : null,
         `sender_id: ${m.sender_id || 'human'}`,
+        m.sender_display_name || m.senderDisplayName ? `sender_display_name: ${m.sender_display_name || m.senderDisplayName}` : null,
         '',
+        discussionRouting,
+        discussionRouting ? '' : null,
         agentSoul,
         agentSoul ? '' : null,
         'User message:',
@@ -198,6 +206,7 @@ export class Runner {
     const staged = await this.attachments.stageMessage(task);
     const transcripts = await this.transcribeAttachments(staged.files);
     const adapter = this.registry.select(task);
+    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);
     try {
       const output = await adapter.run(prompt, {
@@ -224,6 +233,8 @@ export class Runner {
       await this.api.patchTask(taskId, { status: 'blocked', output: String(err.message || err) });
       if (topicId) await this.wtt.publish(topicId, `任务失败：${err.message}`, 'TASK_BLOCKED');
       log('error', 'task failed', { taskId, error: err.message });
+    } finally {
+      if (topicId) await this.wtt.typing(topicId, 'stop');
     }
   }
 
@@ -258,8 +269,18 @@ export class Runner {
   }
 
   async maybePublishProgress(topicId, event, adapterName = 'agent') {
-    if (!this.config.publishProgress || !topicId) return;
+    if (!topicId) return;
     const normalized = normalizeAgentEvent(adapterName, event);
+    const activityText = renderActivityText(normalized, adapterName);
+    if (activityText) {
+      await this.wtt.typing(topicId, 'start', {
+        statusText: activityText,
+        statusKind: normalized?.kind || 'running',
+        adapter: adapterName,
+        ttlMs: 30000,
+      });
+    }
+    if (!this.config.publishProgress) return;
     const line = renderStatusLine(normalized);
     if (line) await this.wtt.publish(topicId, line, 'TASK_STATUS');
   }
@@ -282,6 +303,41 @@ export class Runner {
   }
 }
 
+function adapterDisplayName(name) {
+  if (name === 'claude-code') return 'Claude Code';
+  if (name === 'codex') return 'Codex';
+  return name || 'Agent';
+}
+
+function messageTopicType(m) {
+  return String(m.topic_type || metadataValue(m.metadata, 'topic_type') || metadataValue(m.metadata, 'topicType') || '').toLowerCase();
+}
+
+function renderDiscussionRoutingInstruction(m, config) {
+  const topicType = messageTopicType(m);
+  if (topicType !== 'discussion' && topicType !== 'collaborative') return '';
+
+  const senderId = String(m.sender_id || '').trim();
+  const senderName = String(m.sender_display_name || m.senderDisplayName || '').trim();
+  const currentAgentId = String(config.agentId || '').trim();
+  const currentAgentName = String(config.setupDisplayName || '').trim();
+  const senderIsSelf = Boolean(senderId && currentAgentId && senderId === currentAgentId);
+  const directTarget = senderIsSelf ? '' : (senderName || senderId);
+  const directMention = directTarget ? `@${directTarget.replace(/^@+/, '')}` : '@<other-agent-name>';
+
+  return [
+    'Internal WTT group-discussion routing rule. Follow it silently and do not explain it:',
+    '- In discussion/collaborative topics, another agent will only run if your visible reply explicitly @mentions that agent.',
+    `- Your current agent identity is ${currentAgentName ? `${currentAgentName} (${currentAgentId || 'unknown id'})` : (currentAgentId || 'unknown')}. Never @mention yourself, your own display name, or your own agent id.`,
+    senderIsSelf
+      ? '- The triggering sender appears to be yourself. Do not @mention the sender; answer normally or @mention a different agent only if that specific other agent should act next.'
+      : `- If you want the sender agent to continue, challenge, verify, or answer, include ${directMention} in the visible reply.`,
+    '- 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.',
+  ].join('\n');
+}
+
 function isChatMessage(m, config) {
   const content = String(m.content || '').trim();
   if (!content || content.startsWith('[TASK_')) return false;

package/src/service-manager.js

@@ -385,6 +385,10 @@ function shouldPreserveEnvKey(key) {
     key === 'HTTPS_PROXY' ||
     key === 'ALL_PROXY' ||
     key === 'NO_PROXY' ||
+    key === 'http_proxy' ||
+    key === 'https_proxy' ||
+    key === 'all_proxy' ||
+    key === 'no_proxy' ||
     key === 'DISABLE_TELEMETRY' ||
     key === 'DISABLE_COST_WARNINGS' ||
     key === 'API_TIMEOUT_MS' ||

package/src/wtt-client.js

@@ -122,8 +122,17 @@ export class WTTClient {
     return this.action('publish', { topic_id: topicId, content, content_type: 'text', semantic_type: semanticType });
   }
 
-  async typing(topicId, state) {
-    try { await this.action('typing', { topic_id: topicId, state, ttl_ms: 6000 }, 5000); } catch {}
+  async typing(topicId, state, options = {}) {
+    try {
+      await this.action('typing', {
+        topic_id: topicId,
+        state,
+        ttl_ms: options.ttlMs || options.ttl_ms || 6000,
+        ...(options.statusText ? { status_text: options.statusText } : {}),
+        ...(options.statusKind ? { status_kind: options.statusKind } : {}),
+        ...(options.adapter ? { adapter: options.adapter } : {}),
+      }, 5000);
+    } catch {}
   }
 }
 

package/systemd/wtt-connect-claude.service

@@ -0,0 +1,14 @@
+[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

@@ -0,0 +1,14 @@
+[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