wtt-connect 0.2.20 → 0.2.22

package/package.json

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

package/src/runner.js

@@ -2,6 +2,7 @@ import { WTTClient } from './wtt-client.js';
 import { execFile } from 'node:child_process';
 import fs from 'node:fs';
 import fsp from 'node:fs/promises';
+import os from 'node:os';
 import path from 'node:path';
 import { promisify } from 'node:util';
 import { WTTApi } from './wtt-api.js';
@@ -572,11 +573,11 @@ function parseUpgradeArgs(argsText = '') {
 }
 
 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 packageSpecs = [];
+  if (targets.includes('wtt-connect')) packageSpecs.push({ target: 'wtt-connect', spec: 'wtt-connect@latest' });
+  if (targets.includes('codex')) packageSpecs.push({ target: 'codex', spec: '@openai/codex@latest' });
+  if (targets.includes('claude-code')) packageSpecs.push({ target: 'claude-code', spec: '@anthropic-ai/claude-code@latest' });
+  if (!packageSpecs.length) return { message: upgradeHelp(), summary: {} };
 
   const prefix = await resolveNpmPrefix(config);
   const cache = process.env.NPM_CONFIG_CACHE
@@ -595,27 +596,29 @@ async function upgradeToolchain(config, targets) {
     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 installOutputs = [];
+  for (const pkg of packageSpecs) {
+    try {
+      const install = await installNpmGlobal(config, pkg.spec, { prefix, cache, registry, env });
+      installOutputs.push({ spec: pkg.spec, method: 'npm', stdout: install.stdout, stderr: install.stderr });
+    } catch (err) {
+      if (pkg.target !== 'wtt-connect') throw err;
+      const fallback = await installWttConnectFromRegistry(prefix, registry);
+      installOutputs.push({
+        spec: pkg.spec,
+        method: 'registry-tarball',
+        stdout: fallback.stdout,
+        stderr: `npm install failed; used registry tarball fallback.\n${err.stderr || err.message || err}`,
+      });
+    }
+  }
   const after = await toolVersions(config, prefix);
   const lines = [
     'Toolchain upgrade completed.',
     `- npm prefix: ${prefix}`,
     `- npm cache: ${cache}`,
-    `- packages: ${specs.join(', ')}`,
+    `- packages: ${packageSpecs.map((pkg) => pkg.spec).join(', ')}`,
+    `- install methods: ${installOutputs.map((out) => `${out.spec}:${out.method}`).join(', ')}`,
     '',
     'Versions:',
     `- wtt-connect: ${before.wtt_connect || 'unknown'} -> ${after.wtt_connect || 'unknown'}`,
@@ -625,14 +628,18 @@ async function upgradeToolchain(config, targets) {
   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));
+  const outputText = installOutputs
+    .map((out) => [`[${out.spec} via ${out.method}]`, out.stdout, out.stderr].filter(Boolean).join('\n'))
+    .join('\n\n')
+    .trim();
+  if (outputText) lines.push('', 'install output:', truncate(outputText, 4000));
   return {
     message: lines.join('\n'),
     summary: {
       prefix,
       cache,
-      packages: specs,
+      packages: packageSpecs.map((pkg) => pkg.spec),
+      install_methods: Object.fromEntries(installOutputs.map((out) => [out.spec, out.method])),
       before,
       after,
       installed_at: new Date().toISOString(),
@@ -640,6 +647,82 @@ async function upgradeToolchain(config, targets) {
   };
 }
 
+async function installNpmGlobal(config, spec, { prefix, cache, registry, env }) {
+  return execFileAsync('npm', [
+    'install',
+    '-g',
+    '--prefix',
+    prefix,
+    '--cache',
+    cache,
+    `--registry=${registry}`,
+    spec,
+  ], {
+    cwd: config.workDir,
+    env,
+    timeout: 10 * 60_000,
+    maxBuffer: 2 * 1024 * 1024,
+  });
+}
+
+async function installWttConnectFromRegistry(prefix, registry) {
+  const registryBase = String(registry || 'https://registry.npmjs.org').replace(/\/+$/, '');
+  const metadataUrl = `${registryBase}/wtt-connect`;
+  const metadata = await fetchJson(metadataUrl);
+  const version = metadata?.['dist-tags']?.latest;
+  const tarball = version ? metadata?.versions?.[version]?.dist?.tarball : '';
+  if (!version || !tarball) throw new Error(`wtt-connect metadata missing latest tarball from ${metadataUrl}`);
+
+  const tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'wtt-connect-upgrade-'));
+  const archive = path.join(tmpDir, `wtt-connect-${version}.tgz`);
+  const extractDir = path.join(tmpDir, 'extract');
+  const libDir = path.join(prefix, 'lib', 'node_modules');
+  const binDir = path.join(prefix, 'bin');
+  const targetDir = path.join(libDir, 'wtt-connect');
+  const nextDir = path.join(libDir, `.wtt-connect-${version}-${process.pid}-${Date.now()}`);
+  try {
+    await execFileAsync('curl', ['-fsSL', tarball, '-o', archive], { timeout: 5 * 60_000, maxBuffer: 512 * 1024 });
+    await fsp.mkdir(extractDir, { recursive: true });
+    await execFileAsync('tar', ['-xzf', archive, '-C', extractDir], { timeout: 2 * 60_000, maxBuffer: 512 * 1024 });
+    await fsp.mkdir(libDir, { recursive: true });
+    await fsp.mkdir(binDir, { recursive: true });
+    await fsp.rm(nextDir, { recursive: true, force: true });
+    await fsp.rename(path.join(extractDir, 'package'), nextDir);
+    await fsp.rm(targetDir, { recursive: true, force: true });
+    await fsp.rename(nextDir, targetDir);
+    const entry = path.join(targetDir, 'bin', 'wtt-connect.js');
+    await fsp.chmod(entry, 0o755).catch(() => {});
+    const link = path.join(binDir, 'wtt-connect');
+    await fsp.rm(link, { force: true });
+    await fsp.symlink('../lib/node_modules/wtt-connect/bin/wtt-connect.js', link);
+    await writeToolVersion(prefix, 'wtt_connect', version);
+    return { stdout: `installed wtt-connect@${version} from ${tarball}`, stderr: '' };
+  } finally {
+    await fsp.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
+async function fetchJson(url) {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`GET ${url} failed: ${res.status} ${res.statusText}`);
+  return res.json();
+}
+
+async function writeToolVersion(prefix, key, version) {
+  const toolchainDir = path.dirname(prefix);
+  const file = path.join(toolchainDir, 'tool-versions.json');
+  let current = {};
+  try {
+    current = JSON.parse(await fsp.readFile(file, 'utf8'));
+  } catch {
+    current = {};
+  }
+  current[key] = version;
+  current.updated_at = new Date().toISOString();
+  await fsp.mkdir(toolchainDir, { recursive: true });
+  await fsp.writeFile(file, `${JSON.stringify(current, null, 2)}\n`);
+}
+
 async function resolveNpmPrefix(config) {
   const envPrefix = process.env.NPM_CONFIG_PREFIX || process.env.npm_config_prefix || '';
   if (envPrefix) return path.resolve(envPrefix);

package/src/store.js

@@ -20,10 +20,22 @@ export class DurableStore {
   }
 
   save() {
-    fs.mkdirSync(path.dirname(this.file), { recursive: true });
-    const tmp = `${this.file}.tmp`;
-    fs.writeFileSync(tmp, JSON.stringify(this.data, null, 2));
-    fs.renameSync(tmp, this.file);
+    const dir = path.dirname(this.file);
+    fs.mkdirSync(dir, { recursive: true });
+    const tmp = path.join(dir, `.${path.basename(this.file)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
+    try {
+      fs.writeFileSync(tmp, JSON.stringify(this.data, null, 2));
+      fs.mkdirSync(dir, { recursive: true });
+      fs.renameSync(tmp, this.file);
+    } catch (error) {
+      try { fs.rmSync(tmp, { force: true }); } catch {}
+      if (error && error.code === 'ENOENT') {
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(this.file, JSON.stringify(this.data, null, 2));
+        return;
+      }
+      throw error;
+    }
   }
 
   getSession(sessionKey) {