wtt-connect 0.2.51 → 0.2.52

package/package.json

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

package/src/main.js

@@ -20,6 +20,7 @@ export async function main(args) {
   const argv = parseArgs(args.slice(1));
   if (!argv.envFile && argv.profile) argv.envFile = resolveProfileEnvFile(argv.profile);
   loadDefaultEnvFiles({ envFile: argv.envFile });
+  if (cmd === 'version' || cmd === '--version' || cmd === '-v') return printVersion();
   if (cmd === 'help' || cmd === '--help' || cmd === '-h') return printHelp();
   if (cmd === 'up' || cmd === 'link') return up(argv);
   if (cmd === 'list') return listProfiles(argv);
@@ -109,6 +110,15 @@ function parseArgs(args) {
   return out;
 }
 
+function printVersion() {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+    console.log(pkg.version || 'unknown');
+  } catch {
+    console.log('unknown');
+  }
+}
+
 function printHelp() {
   console.log(`wtt-connect
 

package/src/service-manager.js

@@ -87,12 +87,16 @@ export async function up(argv) {
 
 export function listProfiles() {
   const dir = profilesDir();
+  const sandboxEntries = discoverCloudSandboxEntries();
   if (!fs.existsSync(dir)) {
-    console.log('no profiles');
+    if (!sandboxEntries.length) console.log('no profiles');
+    for (const entry of sandboxEntries) {
+      console.log(`${entry.profile}\t${entry.adapter || 'cloud-sandbox'}\t${entry.agentId}\tcloud-sandbox`);
+    }
     return;
   }
   const files = fs.readdirSync(dir).filter((f) => f.endsWith('.env')).sort();
-  if (!files.length) {
+  if (!files.length && !sandboxEntries.length) {
     console.log('no profiles');
     return;
   }
@@ -101,23 +105,36 @@ export function listProfiles() {
     const env = readEnv(path.join(dir, file));
     console.log(`${profile}\t${env.WTT_CONNECT_ADAPTER || ''}\t${env.WTT_AGENT_ID || ''}`);
   }
+  for (const entry of sandboxEntries) {
+    console.log(`${entry.profile}\t${entry.adapter || 'cloud-sandbox'}\t${entry.agentId}\tcloud-sandbox`);
+  }
 }
 
 export function status(argv) {
-  const profiles = targetProfiles(argv);
-  if (!profiles.length) {
+  const profiles = targetProfiles(argv, { allowEmpty: true });
+  const sandboxEntries = targetCloudSandboxEntries(argv);
+  if (!profiles.length && !sandboxEntries.length) {
     console.log('no profiles');
     return;
   }
   for (const profile of profiles) {
     console.log(`${profile}: ${serviceStatus(profile)}`);
   }
+  for (const entry of sandboxEntries) {
+    console.log(`${entry.profile}: ${cloudSandboxStatus(entry)}`);
+  }
 }
 
 export function restart(argv) {
-  const profiles = targetProfiles(argv);
+  const profiles = targetProfiles(argv, { allowEmpty: true });
+  const sandboxEntries = targetCloudSandboxEntries(argv);
+  if (!profiles.length && !sandboxEntries.length) {
+    console.log('no profiles');
+    return;
+  }
   for (const profile of profiles) restartService(profile);
-  status({ _: profiles });
+  for (const entry of sandboxEntries) restartCloudSandboxEntry(entry);
+  status({ _: [...profiles, ...sandboxEntries.map((entry) => entry.profile)] });
 }
 
 export function logs(argv) {
@@ -182,11 +199,17 @@ export function down(argv) {
   console.log(`kept state dir: ${defaultStateDir(safe)}`);
 }
 
-function targetProfiles(argv) {
+function targetProfiles(argv, options = {}) {
   const requested = argv._ || [];
-  if (requested.length && requested[0] !== 'all') return requested.map(sanitizeProfile);
+  if (requested.length && requested[0] !== 'all') {
+    const available = new Set(discoverProfiles());
+    const profiles = requested.map(sanitizeProfile).filter((profile) => available.has(profile));
+    if (profiles.length || options.allowEmpty) return profiles;
+    return requested.map(sanitizeProfile);
+  }
   const profiles = discoverProfiles();
   if (!profiles.length && requested[0] === 'all') return [];
+  if (!profiles.length && options.allowEmpty) return [];
   if (!profiles.length) throw new Error('no wtt-connect profiles found');
   return profiles;
 }
@@ -197,6 +220,132 @@ function discoverProfiles() {
   return fs.readdirSync(dir).filter((f) => f.endsWith('.env')).map((f) => sanitizeProfile(f.slice(0, -4))).sort();
 }
 
+function targetCloudSandboxEntries(argv) {
+  const requested = (argv._ || []).map((value) => String(value || '').trim()).filter(Boolean);
+  const entries = discoverCloudSandboxEntries();
+  if (!requested.length || requested[0] === 'all') return entries;
+  const wanted = new Set(requested.map(sanitizeProfile));
+  return entries.filter((entry) => wanted.has(entry.profile) || wanted.has(entry.agentId));
+}
+
+function discoverCloudSandboxEntries() {
+  const root = path.join(os.homedir(), '.wtt-connect', 'agent');
+  if (!fs.existsSync(root)) return [];
+  const entries = [];
+  for (const name of fs.readdirSync(root).sort()) {
+    const agentRoot = path.join(root, name);
+    const envFile = path.join(agentRoot, 'run', 'wtt-connect.env');
+    if (!fs.existsSync(envFile)) continue;
+    const env = readEnv(envFile);
+    const agentId = sanitizeProfile(env.WTT_AGENT_ID || name);
+    if (!agentId) continue;
+    entries.push({
+      profile: agentId,
+      agentId,
+      adapter: env.WTT_CONNECT_ADAPTER || env.WTT_CONNECT_ADAPTERS || '',
+      envFile,
+      agentRoot,
+      pidFile: path.join(agentRoot, 'run', 'wtt-connect.pid'),
+      logFile: path.join(agentRoot, 'logs', 'wtt-connect.log'),
+      workDir: env.WTT_CONNECT_WORKDIR || path.join(agentRoot, 'workspace'),
+    });
+  }
+  return entries;
+}
+
+function cloudSandboxStatus(entry) {
+  const pid = readPid(entry.pidFile);
+  if (pid && processRunningWithAgent(pid, entry.agentId)) return `active pid=${pid}`;
+  const found = findPidByAgentEnv(entry.agentId);
+  if (found) return `active pid=${found}`;
+  return 'inactive';
+}
+
+function restartCloudSandboxEntry(entry) {
+  stopCloudSandboxEntry(entry);
+  ensureDir(path.dirname(entry.pidFile));
+  ensureDir(path.dirname(entry.logFile));
+  ensureDir(entry.workDir);
+  const bin = path.join(packageRoot(), 'bin', 'wtt-connect.js');
+  const script = [
+    `set -a`,
+    `. ${shellQuote(entry.envFile)}`,
+    `set +a`,
+    `export PATH=${shellQuote(runtimePath())}`,
+    `mkdir -p ${shellQuote(entry.workDir)} ${shellQuote(path.dirname(entry.pidFile))} ${shellQuote(path.dirname(entry.logFile))}`,
+    `cd ${shellQuote(entry.workDir)}`,
+    `nohup ${shellQuote(process.execPath)} ${shellQuote(bin)} start --env-file ${shellQuote(entry.envFile)} >> ${shellQuote(entry.logFile)} 2>&1 < /dev/null &`,
+    `echo $! > ${shellQuote(entry.pidFile)}`,
+  ].join('; ');
+  const result = spawnSync('bash', ['-lc', script], { encoding: 'utf8' });
+  if (result.status !== 0) {
+    throw new Error(`cloud sandbox restart failed for ${entry.agentId}: ${result.stderr || result.stdout}`);
+  }
+}
+
+function stopCloudSandboxEntry(entry) {
+  const pids = new Set();
+  const pid = readPid(entry.pidFile);
+  if (pid) pids.add(pid);
+  const envPid = findPidByAgentEnv(entry.agentId);
+  if (envPid) pids.add(envPid);
+  for (const target of pids) {
+    try { process.kill(target, 'SIGTERM'); } catch {}
+  }
+  const deadline = Date.now() + 2000;
+  while (Date.now() < deadline && Array.from(pids).some((target) => processAlive(target))) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
+  }
+  for (const target of pids) {
+    if (!processAlive(target)) continue;
+    try { process.kill(target, 'SIGKILL'); } catch {}
+  }
+  try { fs.rmSync(entry.pidFile); } catch {}
+}
+
+function readPid(file) {
+  try {
+    const pid = Number.parseInt(fs.readFileSync(file, 'utf8').trim(), 10);
+    return Number.isFinite(pid) && pid > 0 ? pid : 0;
+  } catch {
+    return 0;
+  }
+}
+
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function processRunningWithAgent(pid, agentId) {
+  if (!processAlive(pid)) return false;
+  try {
+    const env = fs.readFileSync(`/proc/${pid}/environ`, 'utf8').split('\0');
+    return env.includes(`WTT_AGENT_ID=${agentId}`);
+  } catch {
+    return false;
+  }
+}
+
+function findPidByAgentEnv(agentId) {
+  if (process.platform !== 'linux') return 0;
+  for (const name of fs.readdirSync('/proc')) {
+    if (!/^\d+$/.test(name)) continue;
+    const pid = Number.parseInt(name, 10);
+    if (pid === process.pid) continue;
+    if (processRunningWithAgent(pid, agentId)) return pid;
+  }
+  return 0;
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
 function writeProfileEnv(file, values) {
   const lines = [
     '# wtt-connect profile',