wtt-connect 0.2.18 → 0.2.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wtt-connect",
-  "version": "0.2.18",
+  "version": "0.2.20",
   "private": false,
   "description": "WTT-native connector daemon for Codex, Claude Code, Cursor, Gemini, ACP, and other coding agent surfaces.",
   "type": "module",
@@ -18,12 +18,9 @@
   "engines": {
     "node": ">=22"
   },
-  "dependencies": {
+  "optionalDependencies": {
     "node-pty": "^1.1.0"
   },
-  "bundledDependencies": [
-    "node-pty"
-  ],
   "files": [
     "bin",
     "src",

package/src/adapters/codex.js

@@ -1,7 +1,11 @@
 import { spawn } from 'node:child_process';
+import { execFile } from 'node:child_process';
 import readline from 'node:readline';
+import { promisify } from 'node:util';
 import { log } from '../logger.js';
 
+const execFileAsync = promisify(execFile);
+
 export class CodexAdapter {
   constructor(config, deps = {}) {
     this.config = config;
@@ -35,6 +39,45 @@ export class CodexAdapter {
     return result.text.trim();
   }
 
+  async handleSlashCommand(commandText, context = {}) {
+    const parsed = parseSlashCommand(commandText);
+    if (!parsed) return null;
+    const sessionKey = context.sessionKey || 'default';
+
+    switch (parsed.command) {
+      case '/help':
+        return [
+          'Codex slash commands supported by WTT:',
+          '- `/status`: show Codex runtime/session status.',
+          '- `/model`: show the model selected by WTT for this run. Use the WTT model picker to switch models.',
+          '- `/approvals`: show the current approval/sandbox mode.',
+          '- `/diff`: show current git diff summary and patch excerpt.',
+          '- `/review`: run Codex native code review for the current workspace.',
+          '- `/init`: ask Codex to inspect the workspace and create/update AGENTS.md guidance.',
+          '- `/clear`: clear the stored Codex resume thread for this WTT topic.',
+          '- `/compact`: non-interactive Codex cannot compact an existing TUI context; WTT clears the stored resume thread instead.',
+        ].join('\n');
+      case '/status':
+        return this.codexStatus(sessionKey, context);
+      case '/model':
+        return this.codexModel(context, parsed.args);
+      case '/approvals':
+        return this.codexApprovals();
+      case '/diff':
+        return this.gitDiff();
+      case '/clear':
+        return this.clearSession(sessionKey, 'clear');
+      case '/compact':
+        return this.clearSession(sessionKey, 'compact');
+      case '/review':
+        return this.runNativeReview(context, sessionKey);
+      case '/init':
+        return this.runInit(context, sessionKey);
+      default:
+        return `Unsupported Codex slash command: ${parsed.command}\n\nTry \`/help\` for supported WTT/Codex commands.`;
+    }
+  }
+
   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;
@@ -47,6 +90,12 @@ export class CodexAdapter {
   }
 
   buildArgs(threadId, context = {}) {
+    const options = this.buildOptions(context);
+    if (threadId) return ['exec', 'resume', ...options, threadId, '-'];
+    return ['exec', ...options, '--cd', this.config.workDir, '-'];
+  }
+
+  buildOptions(context = {}) {
     const options = ['--skip-git-repo-check', '--json'];
     options.push(...(this.permissions?.codexArgs() || []));
     const model = modelForCodex(this.config, context);
@@ -54,9 +103,102 @@ export class CodexAdapter {
     for (const img of context.images || []) options.push('--image', img);
     const reasoningEffort = reasoningEffortForRun(this.config, context);
     if (reasoningEffort && reasoningEffort !== 'off') options.push('-c', `model_reasoning_effort=${JSON.stringify(reasoningEffort)}`);
-    if (threadId) return ['exec', 'resume', ...options, threadId, '-'];
-    return ['exec', ...options, '--cd', this.config.workDir, '-'];
+    return options;
+  }
+
+  async codexStatus(sessionKey, context = {}) {
+    const stored = this.store?.getSession(sessionKey) || {};
+    const threadId = this.threadBySession.get(sessionKey) || stored.codexThreadId || '';
+    const version = await commandOutput(this.config.codexBin, ['--version'], this.config.workDir);
+    const model = modelForCodex(this.config, context) || '(config/default)';
+    return [
+      'Codex status',
+      `- binary: ${this.config.codexBin}`,
+      `- version: ${version || 'unknown'}`,
+      `- workdir: ${this.config.workDir}`,
+      `- mode: ${this.config.mode}`,
+      `- model: ${model}`,
+      `- resume thread: ${threadId || '(none)'}`,
+    ].join('\n');
+  }
+
+  codexModel(context = {}, args = '') {
+    const model = modelForCodex(this.config, context) || '(config/default)';
+    if (args.trim()) {
+      return [
+        `Current Codex model: ${model}`,
+        '',
+        'WTT runs Codex in non-interactive `codex exec` mode. Use the WTT Web model picker for per-message model switching; `/model <name>` is not applied to local Codex config.',
+      ].join('\n');
+    }
+    return `Current Codex model: ${model}\nUse the WTT Web model picker to switch the model for the next message.`;
   }
+
+  codexApprovals() {
+    const approvalArgs = (this.permissions?.codexArgs() || []).join(' ') || '(default Codex permissions)';
+    return [
+      'Codex approvals / sandbox',
+      `- WTT mode: ${this.config.mode}`,
+      `- Codex args: ${approvalArgs}`,
+    ].join('\n');
+  }
+
+  async gitDiff() {
+    const stat = await commandOutput('git', ['diff', '--stat'], this.config.workDir);
+    const patch = await commandOutput('git', ['diff', '--', '.'], this.config.workDir, 120000, 20000);
+    if (!stat && !patch) return 'No git diff in the current workspace.';
+    return [
+      'Current git diff',
+      stat ? `\n${stat}` : '',
+      patch ? `\nPatch excerpt:\n\`\`\`diff\n${truncate(patch, 12000)}\n\`\`\`` : '',
+    ].filter(Boolean).join('\n');
+  }
+
+  clearSession(sessionKey, reason) {
+    this.threadBySession.delete(sessionKey);
+    this.store?.clearSession(sessionKey, { adapter: this.name, codexThreadId: '', clearedBy: `/${reason}` });
+    return reason === 'compact'
+      ? 'Codex compact: non-interactive `codex exec` has no TUI context compaction. Cleared the stored WTT resume thread instead; the next turn starts a fresh Codex thread.'
+      : 'Codex session cleared for this WTT topic. The next turn starts a fresh Codex thread.';
+  }
+
+  async runNativeReview(context = {}, sessionKey = 'default') {
+    const args = ['exec', ...this.buildOptions(context), '--cd', this.config.workDir, 'review'];
+    const result = await this.runWithArgs(args, '', context, sessionKey);
+    return result.text.trim() || 'Codex review completed with no output.';
+  }
+
+  async runInit(context = {}, sessionKey = 'default') {
+    const prompt = [
+      'Inspect this workspace and create or update AGENTS.md with concise repository guidance for future coding agents.',
+      'Keep it specific to this repo. Include build/test commands and deployment notes only if discoverable from the workspace.',
+    ].join('\n');
+    const result = await this.runWithArgs(this.buildArgs('', context), prompt, context, sessionKey);
+    return result.text.trim() || 'Codex init completed with no output.';
+  }
+}
+
+function parseSlashCommand(text) {
+  const trimmed = String(text || '').trim();
+  if (!trimmed.startsWith('/')) return null;
+  const [command, ...rest] = trimmed.split(/\s+/);
+  return { command: command.toLowerCase(), args: rest.join(' ') };
+}
+
+async function commandOutput(bin, args, cwd, timeoutMs = 30000, maxChars = 8000) {
+  try {
+    const { stdout, stderr } = await execFileAsync(bin, args, { cwd, timeout: timeoutMs, maxBuffer: Math.max(maxChars * 4, 1024 * 1024) });
+    return truncate((stdout || stderr || '').trim(), maxChars);
+  } catch (err) {
+    const detail = `${err.stdout || ''}\n${err.stderr || ''}`.trim() || err.message;
+    return truncate(detail, maxChars);
+  }
+}
+
+function truncate(text, maxChars) {
+  const value = String(text || '');
+  if (value.length <= maxChars) return value;
+  return `${value.slice(0, maxChars)}\n...[truncated ${value.length - maxChars} chars]`;
 }
 
 function modelForCodex(config, context = {}) {

package/src/runner.js

@@ -180,6 +180,22 @@ export class Runner {
       const discussionRouting = renderDiscussionRoutingInstruction(m, this.config);
       const currentDisplayName = effectiveAgentDisplayName(this.config, agentProfile);
       const isSlashPassthrough = isAgentSlashCommand(m, content);
+      if (isSlashPassthrough) {
+        const localSlash = await this.handleLocalSlashCommand(content, adapter, {
+          sessionKey: `wtt:topic:${topicId}:${adapter.name}:${sessionModelKey(modelConfig)}`,
+          topicId,
+          modelConfig,
+          files: staged.files,
+          images: staged.images,
+          onProgress: (event) => this.maybePublishProgress(topicId, event, adapter.name),
+        });
+        if (localSlash !== null) {
+          const reply = stripHiddenContextLeak(localSlash || '(empty response)') || '(empty response)';
+          await this.wtt.publish(topicId, reply, 'CHAT_REPLY');
+          log('info', 'slash command replied', { topicId, adapter: adapter.name, chars: reply.length });
+          return;
+        }
+      }
       const prompt = isSlashPassthrough ? content : [
         'You are replying to a WTT Web conversation. Do not mention implementation internals unless asked.',
         `WTT topic_id: ${topicId}`,
@@ -306,6 +322,62 @@ export class Runner {
     }
   }
 
+  async handleLocalSlashCommand(content, adapter, context = {}) {
+    const parsed = parseSlashCommand(content);
+    if (!parsed) return null;
+    if (parsed.command === '/wtt') {
+      const nested = parseSlashCommand(`/${parsed.args}`);
+      if (!nested) return wttSlashHelp();
+      parsed.command = nested.command;
+      parsed.args = nested.args;
+    }
+    if (parsed.command === '/upgrade') {
+      return this.handleUpgradeCommand(parsed.args);
+    }
+    if (adapter.name === 'codex' && typeof adapter.handleSlashCommand === 'function') {
+      return adapter.handleSlashCommand(content, context);
+    }
+    if (parsed.command === '/status') {
+      return this.runtimeStatusText(adapter, context);
+    }
+    if (parsed.command === '/clear') {
+      this.store.clearSession(context.sessionKey || 'default', { adapter: adapter.name, clearedBy: '/clear' });
+      if (adapter.threadBySession?.delete) adapter.threadBySession.delete(context.sessionKey || 'default');
+      if (adapter.sessionByKey?.delete) adapter.sessionByKey.delete(context.sessionKey || 'default');
+      return `${adapterDisplayName(adapter.name)} session cleared for this WTT topic.`;
+    }
+    return null;
+  }
+
+  runtimeStatusText(adapter, context = {}) {
+    const runtime = this.runtimeInfo();
+    const modelConfig = context.modelConfig || {};
+    const model = modelConfig.model || runtime.current_model || runtime.model || this.config.model || '(config/default)';
+    return [
+      'WTT agent runtime status',
+      `- agent_id: ${this.config.agentId || '(unbound)'}`,
+      `- adapter: ${adapter.name}`,
+      `- model: ${model}`,
+      `- workdir: ${this.config.workDir}`,
+      `- mode: ${this.permissions.describe()}`,
+      `- node: ${process.version}`,
+      `- wtt-connect: ${runtime.wtt_connect || runtime.wttConnect || '(unknown)'}`,
+      `- claude: ${runtime.claude_code || runtime.claude || '(unknown)'}`,
+      `- codex: ${runtime.codex || '(unknown)'}`,
+    ].join('\n');
+  }
+
+  async handleUpgradeCommand(argsText = '') {
+    const parsed = parseUpgradeArgs(argsText);
+    if (parsed.help) return upgradeHelp();
+    const result = await upgradeToolchain(this.config, parsed.targets);
+    this.store.patchRuntime({
+      toolchain_updated_at: new Date().toISOString(),
+      toolchain_update: result.summary,
+    });
+    return result.message;
+  }
+
   recordRuntimeSelection(adapter, modelConfig = {}, status = 'idle') {
     const model = String(modelConfig.model || modelConfig.model_id || modelConfig.modelId || '').trim();
     const reasoning = String(modelConfig.reasoning_effort || modelConfig.reasoningEffort || '').trim().toLowerCase();
@@ -444,6 +516,192 @@ function adapterDisplayName(name) {
   return name || 'Agent';
 }
 
+function parseSlashCommand(text) {
+  const trimmed = String(text || '').trim();
+  if (!trimmed.startsWith('/')) return null;
+  const [command, ...rest] = trimmed.split(/\s+/);
+  return { command: command.toLowerCase(), args: rest.join(' ') };
+}
+
+function wttSlashHelp() {
+  return [
+    'WTT slash commands:',
+    '- `/upgrade codex`: install the latest Codex CLI into the persistent toolchain.',
+    '- `/upgrade claude-code`: install the latest Claude Code CLI into the persistent toolchain.',
+    '- `/upgrade wtt-connect`: install the latest wtt-connect package into the persistent toolchain. Restart is required to use the new connector process.',
+    '- `/upgrade all`: install all three tools.',
+    '- `/status`: show WTT agent runtime status.',
+    '- `/clear`: clear this WTT topic session state.',
+  ].join('\n');
+}
+
+function upgradeHelp() {
+  return [
+    'Usage:',
+    '- `/upgrade codex`',
+    '- `/upgrade claude-code`',
+    '- `/upgrade wtt-connect`',
+    '- `/upgrade all`',
+    '',
+    'Aliases: `claude`, `claude_code`, `connect`, `connector`, `tools`.',
+    'Installs use the current persistent npm prefix when available, for example `/workspace/toolchain/node-global` in Cloudflare Sandbox.',
+  ].join('\n');
+}
+
+function parseUpgradeArgs(argsText = '') {
+  const tokens = String(argsText || '').trim().toLowerCase().split(/\s+/).filter(Boolean);
+  if (!tokens.length || tokens.includes('--help') || tokens.includes('-h') || tokens.includes('help')) {
+    return { help: true, targets: [] };
+  }
+  const targets = new Set();
+  for (const token of tokens) {
+    if (['all', 'tools', 'toolchain'].includes(token)) {
+      targets.add('wtt-connect');
+      targets.add('codex');
+      targets.add('claude-code');
+    } else if (['wtt-connect', 'connect', 'connector'].includes(token)) {
+      targets.add('wtt-connect');
+    } else if (['codex', 'openai-codex', 'openai'].includes(token)) {
+      targets.add('codex');
+    } else if (['claude-code', 'claude_code', 'claude', 'anthropic'].includes(token)) {
+      targets.add('claude-code');
+    }
+  }
+  if (!targets.size) return { help: true, targets: [] };
+  return { help: false, targets: Array.from(targets) };
+}
+
+async function upgradeToolchain(config, targets) {
+  const specs = [];
+  if (targets.includes('wtt-connect')) specs.push('wtt-connect@latest');
+  if (targets.includes('codex')) specs.push('@openai/codex@latest');
+  if (targets.includes('claude-code')) specs.push('@anthropic-ai/claude-code@latest');
+  if (!specs.length) return { message: upgradeHelp(), summary: {} };
+
+  const prefix = await resolveNpmPrefix(config);
+  const cache = process.env.NPM_CONFIG_CACHE
+    || process.env.npm_config_cache
+    || (prefix.endsWith('/node-global') ? path.join(path.dirname(prefix), 'npm-cache') : path.join(prefix, '.npm-cache'));
+  const registry = process.env.NPM_CONFIG_REGISTRY || process.env.npm_config_registry || 'https://registry.npmjs.org';
+  await fsp.mkdir(prefix, { recursive: true });
+  await fsp.mkdir(cache, { recursive: true });
+
+  const before = await toolVersions(config);
+  const env = {
+    ...process.env,
+    NPM_CONFIG_PREFIX: prefix,
+    npm_config_prefix: prefix,
+    NPM_CONFIG_CACHE: cache,
+    npm_config_cache: cache,
+    npm_config_nodedir: process.env.npm_config_nodedir || '/usr/local',
+  };
+  const install = await execFileAsync('npm', [
+    'install',
+    '-g',
+    '--prefix',
+    prefix,
+    '--cache',
+    cache,
+    `--registry=${registry}`,
+    ...specs,
+  ], {
+    cwd: config.workDir,
+    env,
+    timeout: 10 * 60_000,
+    maxBuffer: 2 * 1024 * 1024,
+  });
+  const after = await toolVersions(config, prefix);
+  const lines = [
+    'Toolchain upgrade completed.',
+    `- npm prefix: ${prefix}`,
+    `- npm cache: ${cache}`,
+    `- packages: ${specs.join(', ')}`,
+    '',
+    'Versions:',
+    `- wtt-connect: ${before.wtt_connect || 'unknown'} -> ${after.wtt_connect || 'unknown'}`,
+    `- codex: ${before.codex || 'unknown'} -> ${after.codex || 'unknown'}`,
+    `- claude-code: ${before.claude_code || 'unknown'} -> ${after.claude_code || 'unknown'}`,
+  ];
+  if (targets.includes('wtt-connect')) {
+    lines.push('', 'Note: `wtt-connect` was upgraded on disk. Restart this agent process to run the new connector version; Claude Code and Codex upgrades are used on the next run because they are spawned per request.');
+  }
+  const stdout = String(install.stdout || '').trim();
+  if (stdout) lines.push('', 'npm output:', truncate(stdout, 4000));
+  return {
+    message: lines.join('\n'),
+    summary: {
+      prefix,
+      cache,
+      packages: specs,
+      before,
+      after,
+      installed_at: new Date().toISOString(),
+    },
+  };
+}
+
+async function resolveNpmPrefix(config) {
+  const envPrefix = process.env.NPM_CONFIG_PREFIX || process.env.npm_config_prefix || '';
+  if (envPrefix) return path.resolve(envPrefix);
+  const bin = await commandPath('wtt-connect').catch(() => '');
+  if (bin && path.basename(path.dirname(bin)) === 'bin') {
+    return path.dirname(path.dirname(bin));
+  }
+  const stateDir = config.stateDir || path.join(config.workDir || process.cwd(), '.wtt-connect');
+  return path.join(stateDir, 'toolchain', 'node-global');
+}
+
+async function commandPath(bin) {
+  const { stdout } = await execFileAsync('which', [bin], { timeout: 10000 });
+  return String(stdout || '').trim().split('\n')[0] || '';
+}
+
+async function toolVersions(config, prefix = '') {
+  const binDir = prefix ? path.join(prefix, 'bin') : '';
+  const wttConnectBin = binDir ? path.join(binDir, 'wtt-connect') : 'wtt-connect';
+  const codexBin = binDir ? path.join(binDir, 'codex') : config.codexBin;
+  const claudeBin = binDir ? path.join(binDir, 'claude') : config.claudeBin;
+  const [wttConnect, codex, claude] = await Promise.all([
+    npmPackageVersion('wtt-connect', prefix),
+    commandVersion(codexBin, ['--version'], config.workDir),
+    commandVersion(claudeBin, ['--version'], config.workDir),
+  ]);
+  return {
+    wtt_connect: wttConnect || await commandVersion(wttConnectBin, ['help'], config.workDir, /^wtt-connect\b/im),
+    codex,
+    claude_code: claude,
+  };
+}
+
+async function npmPackageVersion(packageName, prefix = '') {
+  try {
+    const args = ['list', '-g', packageName, '--depth=0', '--json'];
+    if (prefix) args.splice(2, 0, '--prefix', prefix);
+    const { stdout } = await execFileAsync('npm', args, { timeout: 30000, maxBuffer: 1024 * 1024 });
+    const parsed = JSON.parse(stdout || '{}');
+    return parsed.dependencies?.[packageName]?.version || '';
+  } catch {
+    return '';
+  }
+}
+
+async function commandVersion(bin, args, cwd, pattern = null) {
+  try {
+    const { stdout, stderr } = await execFileAsync(bin, args, { cwd, timeout: 30000, maxBuffer: 256 * 1024 });
+    const text = String(stdout || stderr || '').trim();
+    if (pattern && !pattern.test(text)) return '';
+    return text.split('\n')[0] || '';
+  } catch {
+    return '';
+  }
+}
+
+function truncate(text, maxChars) {
+  const value = String(text || '');
+  if (value.length <= maxChars) return value;
+  return `${value.slice(0, maxChars)}\n...[truncated ${value.length - maxChars} chars]`;
+}
+
 function renderGeneratedFileArtifactInstruction(config, topicId = '') {
   const workDir = config.workDir || process.cwd();
   const uploadCommand = `wtt-connect upload-file --topic-id ${topicId || '<topic_id>'} --title "optional display name" <file-or-files>`;

package/src/store.js

@@ -37,6 +37,12 @@ export class DurableStore {
     this.save();
   }
 
+  clearSession(sessionKey, patch = {}) {
+    this.load();
+    this.data.sessions[sessionKey] = { ...patch, updatedAt: new Date().toISOString() };
+    this.save();
+  }
+
   getRuntime() {
     this.load();
     return this.data.runtime || {};

package/src/terminal-session.js

@@ -2,10 +2,10 @@ import os from 'node:os';
 import path from 'node:path';
 import fs from 'node:fs';
 import { createRequire } from 'node:module';
-import * as pty from 'node-pty';
 import { log } from './logger.js';
 
 const require = createRequire(import.meta.url);
+let nodePty = null;
 
 export class TerminalSessionManager {
   constructor(config, sendJson) {
@@ -32,6 +32,7 @@ export class TerminalSessionManager {
 
     try {
       ensureNodePtyHelperExecutable();
+      const pty = await loadNodePty();
       const proc = pty.spawn(shell, [], {
         name: 'xterm-256color',
         cols,
@@ -119,6 +120,16 @@ export class TerminalSessionManager {
   }
 }
 
+async function loadNodePty() {
+  if (nodePty) return nodePty;
+  try {
+    nodePty = await import('node-pty');
+    return nodePty;
+  } catch (err) {
+    throw new Error(`node-pty is not installed or failed to load; terminal sessions are unavailable in this runtime: ${err.message}`);
+  }
+}
+
 function resolveDir(dir) {
   const resolved = path.resolve(String(dir || process.cwd()));
   if (!fs.existsSync(resolved)) fs.mkdirSync(resolved, { recursive: true });

package/node_modules/node-addon-api/LICENSE.md

@@ -1,9 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2017 [Node.js API collaborators](https://github.com/nodejs/node-addon-api#collaborators)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.