wtt-connect 0.1.0

package/src/config.js

@@ -0,0 +1,118 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseBool, parseIntEnv } from './env.js';
+
+function wsUrl(base, agentId) {
+  let b = String(base || '').replace(/\/$/, '');
+  if (b.endsWith('/api/v1')) b = b.slice(0, -7);
+  return `${b.replace(/^https:/, 'wss:').replace(/^http:/, 'ws:')}/ws/${agentId}`;
+}
+
+export function apiUrl(base) {
+  return String(base || '').replace(/\/$/, '');
+}
+
+function readJsonConfig(file) {
+  if (!file) return {};
+  const resolved = path.resolve(file);
+  if (!fs.existsSync(resolved)) return {};
+  return JSON.parse(fs.readFileSync(resolved, 'utf8'));
+}
+
+export function loadConfig(argv = {}) {
+  const fileConfig = readJsonConfig(argv.config || process.env.WTT_CONNECT_CONFIG);
+  const base = process.env.WTT_BASE_URL || fileConfig.wttBaseUrl || 'https://www.waxbyte.com';
+  const agentId = process.env.WTT_AGENT_ID || fileConfig.agentId || '';
+  const token = process.env.WTT_TOKEN || process.env.WTT_AGENT_TOKEN || fileConfig.token || '';
+  const adapter = process.env.WTT_CONNECT_ADAPTER || fileConfig.adapter || 'codex';
+  const adapters = String(process.env.WTT_CONNECT_ADAPTERS || fileConfig.adapters || adapter).split(',').map((x) => x.trim()).filter(Boolean);
+  const workDir = process.env.WTT_CONNECT_WORKDIR || fileConfig.workDir || process.cwd();
+  const stateDir = process.env.WTT_CONNECT_STATE_DIR || fileConfig.stateDir || path.join(workDir, '.wtt-connect');
+  return {
+    configFile: argv.config || process.env.WTT_CONNECT_CONFIG || '',
+    envFile: argv.envFile || process.env.WTT_CONNECT_ENV_FILE || '',
+    wttBaseUrl: base,
+    wttWsUrl: process.env.WTT_WS_URL || fileConfig.wttWsUrl || wsUrl(base, agentId),
+    agentId,
+    token,
+    httpToken: process.env.WTT_HTTP_TOKEN || fileConfig.httpToken || '',
+    adapter,
+    adapters,
+    adapterPolicy: fileConfig.adapterPolicy || parseJsonEnv(process.env.WTT_CONNECT_ADAPTER_POLICY, {}),
+    workDir,
+    model: process.env.WTT_CONNECT_MODEL || fileConfig.model || '',
+    mode: process.env.WTT_CONNECT_MODE || fileConfig.mode || 'full-auto',
+    allowYolo: parseBool(process.env.WTT_CONNECT_ALLOW_YOLO, fileConfig.allowYolo ?? false),
+    reasoningEffort: process.env.WTT_CONNECT_REASONING_EFFORT || fileConfig.reasoningEffort || 'low',
+    codexBin: process.env.WTT_CODEX_BIN || fileConfig.codexBin || 'codex',
+    claudeBin: process.env.WTT_CLAUDE_BIN || fileConfig.claudeBin || 'claude',
+    cursorBin: process.env.WTT_CURSOR_BIN || fileConfig.cursorBin || 'agent',
+    geminiBin: process.env.WTT_GEMINI_BIN || fileConfig.geminiBin || 'gemini',
+    qoderBin: process.env.WTT_QODER_BIN || fileConfig.qoderBin || 'qodercli',
+    opencodeBin: process.env.WTT_OPENCODE_BIN || fileConfig.opencodeBin || 'opencode',
+    crushBin: process.env.WTT_CRUSH_BIN || fileConfig.crushBin || 'crush',
+    iflowBin: process.env.WTT_IFLOW_BIN || fileConfig.iflowBin || 'iflow',
+    kimiBin: process.env.WTT_KIMI_BIN || fileConfig.kimiBin || 'kimi',
+    piBin: process.env.WTT_PI_BIN || fileConfig.piBin || 'pi',
+    acpBin: process.env.WTT_ACP_BIN || process.env.WTT_CONNECT_ACP_COMMAND || fileConfig.acpBin || fileConfig.acpCommand || 'acp-agent',
+    acpCommand: process.env.WTT_CONNECT_ACP_COMMAND || process.env.WTT_ACP_BIN || fileConfig.acpCommand || fileConfig.acpBin || 'acp-agent',
+    acpArgs: parseListEnv(process.env.WTT_CONNECT_ACP_ARGS || fileConfig.acpArgs || ''),
+    acpDisplayName: process.env.WTT_CONNECT_ACP_DISPLAY_NAME || fileConfig.acpDisplayName || 'ACP Agent',
+    devinBin: process.env.WTT_DEVIN_BIN || fileConfig.devinBin || 'devin',
+    devinArgs: parseListEnv(process.env.WTT_DEVIN_ARGS || fileConfig.devinArgs || 'acp'),
+    openclawBin: process.env.WTT_OPENCLAW_BIN || fileConfig.openclawBin || 'openclaw',
+    enableChat: parseBool(process.env.WTT_CONNECT_ENABLE_CHAT, fileConfig.enableChat ?? true),
+    publishProgress: parseBool(process.env.WTT_CONNECT_PUBLISH_PROGRESS, fileConfig.publishProgress ?? false),
+    requireCommitPush: parseBool(process.env.WTT_REQUIRE_COMMIT_PUSH, fileConfig.requireCommitPush ?? true),
+    heartbeatSeconds: parseIntEnv(process.env.WTT_CONNECT_HEARTBEAT_SECONDS, fileConfig.heartbeatSeconds || 25),
+    taskTimeoutSeconds: parseIntEnv(process.env.WTT_CONNECT_TASK_TIMEOUT_SECONDS, fileConfig.taskTimeoutSeconds || 3600),
+    enableShell: parseBool(process.env.WTT_CONNECT_ENABLE_SHELL, fileConfig.enableShell ?? true),
+    shellMode: process.env.WTT_CONNECT_SHELL_MODE || fileConfig.shellMode || 'unsafe',
+    shellTimeoutSeconds: parseIntEnv(process.env.WTT_CONNECT_SHELL_TIMEOUT_SECONDS, fileConfig.shellTimeoutSeconds || 30),
+    shellMaxOutputChars: parseIntEnv(process.env.WTT_CONNECT_SHELL_MAX_OUTPUT_CHARS, fileConfig.shellMaxOutputChars || 20000),
+    dryRun: parseBool(process.env.WTT_CONNECT_DRY_RUN, fileConfig.dryRun ?? false),
+    stateDir,
+    storeFile: process.env.WTT_CONNECT_STORE_FILE || fileConfig.storeFile || path.join(stateDir, 'state.json'),
+    artifactDir: process.env.WTT_CONNECT_ARTIFACT_DIR || fileConfig.artifactDir || path.join(stateDir, 'artifacts'),
+    inboxDir: process.env.WTT_CONNECT_INBOX_DIR || fileConfig.inboxDir || path.join(stateDir, 'inbox'),
+    uploadArtifacts: parseBool(process.env.WTT_CONNECT_UPLOAD_ARTIFACTS, fileConfig.uploadArtifacts ?? false),
+    setupDisplayName: process.env.WTT_CONNECT_DISPLAY_NAME || fileConfig.setupDisplayName || 'wtt-connect',
+    agentAliases: parseListEnv(process.env.WTT_CONNECT_AGENT_ALIASES || fileConfig.agentAliases || ''),
+    stt: {
+      provider: process.env.WTT_CONNECT_STT_PROVIDER || fileConfig.stt?.provider || 'none',
+      command: process.env.WTT_CONNECT_STT_COMMAND || fileConfig.stt?.command || '',
+      openaiApiKey: process.env.WTT_CONNECT_STT_OPENAI_API_KEY || process.env.OPENAI_API_KEY || fileConfig.stt?.openaiApiKey || '',
+      openaiBaseUrl: process.env.WTT_CONNECT_STT_OPENAI_BASE_URL || process.env.OPENAI_BASE_URL || fileConfig.stt?.openaiBaseUrl || 'https://api.openai.com/v1',
+      openaiModel: process.env.WTT_CONNECT_STT_OPENAI_MODEL || fileConfig.stt?.openaiModel || 'whisper-1',
+      openaiTransport: process.env.WTT_CONNECT_STT_OPENAI_TRANSPORT || fileConfig.stt?.openaiTransport || 'auto',
+      language: process.env.WTT_CONNECT_STT_LANGUAGE || fileConfig.stt?.language || '',
+      prompt: process.env.WTT_CONNECT_STT_PROMPT || fileConfig.stt?.prompt || '',
+      responseFormat: process.env.WTT_CONNECT_STT_RESPONSE_FORMAT || fileConfig.stt?.responseFormat || 'json',
+      timeoutMs: parseIntEnv(process.env.WTT_CONNECT_STT_TIMEOUT_MS, fileConfig.stt?.timeoutMs || 120000),
+    },
+    tts: {
+      provider: process.env.WTT_CONNECT_TTS_PROVIDER || fileConfig.tts?.provider || 'none',
+      voice: process.env.WTT_CONNECT_TTS_VOICE || fileConfig.tts?.voice || '',
+      outDir: process.env.WTT_CONNECT_TTS_OUT_DIR || fileConfig.tts?.outDir || path.join(workDir, '.wtt-connect', 'tts'),
+    },
+  };
+}
+
+function parseJsonEnv(value, fallback) {
+  if (!value) return fallback;
+  try { return JSON.parse(value); } catch { return fallback; }
+}
+
+function parseListEnv(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value.map((x) => String(x).trim()).filter(Boolean);
+  const raw = String(value).trim();
+  if (!raw) return [];
+  if (raw.startsWith('[')) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) return parsed.map((x) => String(x).trim()).filter(Boolean);
+    } catch {}
+  }
+  return raw.split(',').map((x) => x.trim()).filter(Boolean);
+}

package/src/env.js

@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export function parseBool(value, fallback = false) {
+  if (value === undefined || value === null || value === '') return fallback;
+  return ['1', 'true', 'yes', 'y', 'on'].includes(String(value).trim().toLowerCase());
+}
+
+export function parseIntEnv(value, fallback) {
+  const n = Number.parseInt(String(value || ''), 10);
+  return Number.isFinite(n) ? n : fallback;
+}
+
+export function loadEnvFile(file) {
+  if (!fs.existsSync(file)) return;
+  for (const raw of fs.readFileSync(file, 'utf8').split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith('#') || !line.includes('=')) continue;
+    const idx = line.indexOf('=');
+    const key = line.slice(0, idx).trim();
+    const value = line.slice(idx + 1).trim().replace(/^['"]|['"]$/g, '');
+    if (key && process.env[key] === undefined) process.env[key] = value;
+  }
+}
+
+export function loadDefaultEnvFiles(options = {}) {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const root = path.resolve(here, '..');
+  const explicit = options.envFile || process.env.WTT_CONNECT_ENV_FILE || '';
+  const loaded = new Set();
+  if (explicit) {
+    const resolved = path.resolve(process.cwd(), explicit);
+    loadEnvFile(resolved);
+    loaded.add(resolved);
+    process.env.WTT_CONNECT_ENV_FILE = resolved;
+  }
+  for (const file of [path.join(root, '.env'), path.join(process.cwd(), '.env')]) {
+    const resolved = path.resolve(file);
+    if (!loaded.has(resolved)) loadEnvFile(resolved);
+  }
+}

package/src/events.js

@@ -0,0 +1,23 @@
+export function normalizeAgentEvent(adapterName, event) {
+  const item = event?.item || {};
+  const type = event?.type || '';
+  const now = new Date().toISOString();
+  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 };
+    if (kind === 'web_search') return { kind: 'web_search', status: 'started', text: item.query || 'web search', time: now, raw: event };
+    return { kind, status: 'started', text: kind, time: now, raw: event };
+  }
+  if (type === 'item.completed') {
+    const kind = item.type || 'item';
+    const text = item.command || item.query || item.title || kind;
+    return { kind, status: 'completed', text, time: now, raw: event };
+  }
+  if (type === 'error') return { kind: 'error', status: 'failed', text: String(event.error || event.message || 'error'), time: now, raw: event };
+  return null;
+}
+
+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)}`;
+}

package/src/logger.js

@@ -0,0 +1,18 @@
+export function nowIso() {
+  return new Date().toISOString();
+}
+
+export function redact(value) {
+  const s = String(value || '');
+  if (!s) return s;
+  if (s.length <= 10) return '***';
+  return `${s.slice(0, 4)}…${s.slice(-4)}`;
+}
+
+export function log(level, message, fields = {}) {
+  const suffix = Object.entries(fields)
+    .filter(([, v]) => v !== undefined && v !== null && v !== '')
+    .map(([k, v]) => `${k}=${String(v).replace(/\s+/g, ' ')}`)
+    .join(' ');
+  process.stdout.write(`${nowIso()} [${level.toUpperCase()}] ${message}${suffix ? ` ${suffix}` : ''}\n`);
+}

package/src/main.js

@@ -0,0 +1,143 @@
+import { spawnSync } from 'node:child_process';
+import { loadDefaultEnvFiles } from './env.js';
+import { loadConfig } from './config.js';
+import { Runner } from './runner.js';
+import { PermissionBroker } from './permissions.js';
+import { setup } from './setup.js';
+import { smokeChat, smokeTask } from './smoke.js';
+import { log, redact } from './logger.js';
+import { adapterBin, normalizeProfileName } from './adapters/generic-cli.js';
+import { normalizeAdapterName } from './adapters/index.js';
+import { down, listProfiles, logs, resolveProfileEnvFile, restart, status, up } from './service-manager.js';
+
+export async function main(args) {
+  const cmd = args[0] || 'help';
+  const argv = parseArgs(args.slice(1));
+  if (!argv.envFile && argv.profile) argv.envFile = resolveProfileEnvFile(argv.profile);
+  loadDefaultEnvFiles({ envFile: argv.envFile });
+  if (cmd === 'help' || cmd === '--help' || cmd === '-h') return printHelp();
+  if (cmd === 'up' || cmd === 'link') return up(argv);
+  if (cmd === 'list') return listProfiles(argv);
+  if (cmd === 'status') return status(argv);
+  if (cmd === 'restart') return restart(argv);
+  if (cmd === 'logs') return logs(argv);
+  if (cmd === 'down' || cmd === 'unlink') return down(argv);
+  if (cmd === 'doctor') return doctor(loadConfig(argv));
+  if (cmd === 'setup') return setup(loadConfig(argv), argv);
+  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 === 'start') {
+    const config = loadConfig(argv);
+    if (!config.agentId) throw new Error('WTT_AGENT_ID is required');
+    const runner = new Runner(config);
+    process.on('SIGINT', () => runner.close().finally(() => process.exit(0)));
+    process.on('SIGTERM', () => runner.close().finally(() => process.exit(0)));
+    await runner.start();
+    return;
+  }
+  throw new Error(`unknown command: ${cmd}`);
+}
+
+function parseArgs(args) {
+  const out = { _: [] };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--config') out.config = args[++i];
+    else if (a === '--env-file') out.envFile = args[++i];
+    else if (a === '--profile' || a === '--name') out.profile = args[++i];
+    else if (a === '--claim-code') out.claimCode = true;
+    else if (a === '--no-register') out.noRegister = true;
+    else if (a === '--agent-id') out.agentId = args[++i];
+    else if (a === '--token') out.token = args[++i];
+    else if (a === '--adapter') out.adapter = args[++i];
+    else if (a === '--base-url') out.baseUrl = args[++i];
+    else if (a === '--workdir' || a === '--work-dir') out.workDir = args[++i];
+    else if (a === '--state-dir') out.stateDir = args[++i];
+    else if (a === '--mode') out.mode = args[++i];
+    else if (a === '--allow-yolo' || a === '--allow-dangerous-permissions') out.allowYolo = true;
+    else if (a === '--yes' || a === '-y') out.yes = true;
+    else if (a === '--publish-progress') out.publishProgress = true;
+    else if (a === '--enable-linger') out.enableLinger = true;
+    else if (a === '--no-start') out.noStart = true;
+    else if (a === '--node-bin') out.nodeBin = args[++i];
+    else if (a === '--codex-bin') out.codexBin = args[++i];
+    else if (a === '--claude-bin') out.claudeBin = args[++i];
+    else if (a === '--lines') out.lines = Number(args[++i]);
+    else if (a === '--display-name') out.displayName = args[++i];
+    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 === '--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];
+    else if (a.startsWith('--')) throw new Error(`unknown argument: ${a}`);
+    else out._.push(a);
+  }
+  return out;
+}
+
+function printHelp() {
+  console.log(`wtt-connect
+
+Commands:
+  up <agenttype> <agent_id> <token>  Bind profile, install user service, and start it
+  link <agenttype> <agent_id> <token>
+                                  Alias for up
+  list                            List configured profiles
+  status [profile|all]            Show systemd service status for profiles
+  restart [profile|all]           Restart one or all configured services
+  logs <profile> [--lines 100]    Show service logs
+  down <profile>                  Stop/disable service; keep profile/state files
+  unlink <profile>                Alias for down
+  setup [--claim-code]           Register/write local .env and optionally print claim code
+  start [--profile name|--env-file file]
+                                  Start WTT-native connector daemon
+  doctor [--profile name|--env-file file]
+                                  Check local configuration and adapter binaries
+  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
+  help                           Show this help
+`);
+}
+
+
+function doctor(config) {
+  log('info', 'wtt-connect doctor', {
+    agentId: config.agentId || '(missing)',
+    token: config.token ? redact(config.token) : '(missing)',
+    adapter: config.adapter,
+    adapters: config.adapters.join(','),
+    envFile: config.envFile || '(default)',
+    workDir: config.workDir,
+    mode: config.mode,
+    allowYolo: config.allowYolo,
+    tts: config.tts.provider,
+    store: config.storeFile,
+    uploadArtifacts: config.uploadArtifacts,
+  });
+  const checks = [];
+  try { new PermissionBroker(config).validate(); checks.push(['permission policy', 'ok', true]); }
+  catch (err) { checks.push(['permission policy', err.message, false]); }
+  checks.push(['node', process.version, true]);
+  checks.push(['WTT_AGENT_ID', config.agentId ? 'ok' : 'missing', Boolean(config.agentId)]);
+  checks.push(['WTT_TOKEN', config.token ? 'ok' : 'missing', Boolean(config.token)]);
+  for (const adapter of config.adapters) {
+    const bin = resolveAdapterBin(config, adapter);
+    const found = spawnSync('which', [bin], { encoding: 'utf8' });
+    checks.push([`${adapter} binary`, found.status === 0 ? found.stdout.trim() : `not found: ${bin}`, found.status === 0]);
+  }
+  for (const [name, value, ok] of checks) console.log(`${ok ? '✓' : '✗'} ${name}: ${value}`);
+  if (checks.some(([, , ok]) => !ok)) process.exitCode = 1;
+}
+
+function resolveAdapterBin(config, adapter) {
+  const name = normalizeAdapterName(adapter);
+  if (name === 'codex') return config.codexBin;
+  if (name === 'claude-code') return config.claudeBin;
+  if (name === 'acp') return config.acpCommand || config.acpBin;
+  if (name === 'devin') return config.devinBin;
+  if (name === 'openclaw') return config.openclawBin;
+  return adapterBin(config, normalizeProfileName(name)) || name;
+}

package/src/mime.js

@@ -0,0 +1,12 @@
+const MAP = new Map([
+  ['.txt', 'text/plain'], ['.md', 'text/markdown'], ['.json', 'application/json'],
+  ['.html', 'text/html'], ['.pdf', 'application/pdf'], ['.zip', 'application/zip'],
+  ['.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'],
+]);
+
+export function lookupMime(filePath) {
+  const ext = filePath.slice(filePath.lastIndexOf('.')).toLowerCase();
+  return MAP.get(ext) || 'text/plain';
+}

package/src/permissions.js

@@ -0,0 +1,28 @@
+const MODE_TO_CODEX = {
+  suggest: [],
+  'auto-edit': ['--full-auto'],
+  'full-auto': ['--full-auto'],
+  yolo: ['--dangerously-bypass-approvals-and-sandbox'],
+};
+
+export class PermissionBroker {
+  constructor(config) {
+    this.config = config;
+  }
+
+  validate() {
+    if (this.config.mode === 'yolo' && !this.config.allowYolo) {
+      throw new Error('WTT_CONNECT_MODE=yolo requires WTT_CONNECT_ALLOW_YOLO=1');
+    }
+  }
+
+  codexArgs() {
+    this.validate();
+    return MODE_TO_CODEX[this.config.mode] || MODE_TO_CODEX['full-auto'];
+  }
+
+  describe() {
+    if (this.config.mode === 'yolo') return 'yolo/dangerously-bypass-approvals-and-sandbox';
+    return this.config.mode;
+  }
+}