wtt-connect 0.2.50 → 0.2.52

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wtt-connect",
-  "version": "0.2.50",
+  "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
 
@@ -138,7 +148,7 @@ Commands:
   opendesign-upload --dir <path>
                                   Alias for upload-artifact
   preview-port --port <port> [--topic-id <id>] [--snapshot-dir <dir>]
-                                  Create a Cloud Sandbox preview URL and optional persistent snapshot
+                                  Create a Cloud Sandbox live preview URL; snapshots are opt-in
   cleanup-previews                Stop preview servers previously registered by this agent
   help                           Show this help
 `);
@@ -163,7 +173,8 @@ async function previewPort(config, argv) {
   const url = preview.preview_url || preview.url;
   if (!url) throw new Error('Cloud Sandbox preview API returned no URL');
   const title = String(argv.title || argv.previewName || preview.name || 'Cloud Sandbox Preview').trim();
-  const snapshot = argv.noSnapshot ? null : await createPreviewSnapshot(config, argv, { title });
+  const wantsSnapshot = Boolean(String(argv.snapshotDir || '').trim()) && !argv.noSnapshot;
+  const snapshot = wantsSnapshot ? await createPreviewSnapshot(config, argv, { title }) : null;
   const snapshotUrl = snapshot?.snapshot_url || '';
   const markdown = JSON.stringify({
     type: 'cloud_sandbox_preview',

package/src/runner.js

@@ -943,11 +943,12 @@ function renderCloudSandboxStorageInstruction(config, topicId = '') {
     '- Before publishing a preview URL, verify the server is actually listening and serving content with `curl -fsS http://127.0.0.1:<port>/ >/dev/null`.',
     '- If local curl fails, fix or restart the web server first. Never publish a preview URL for a dead port.',
     '- `wtt-connect preview-port` automatically keeps the most recent preview servers for this agent and stops older registered previews beyond the retention limit. Default retention is 3 live previews; use `--keep-last <n>` only when the user asks.',
-    '- For static pages, animations, charts, dashboards, and HTML demos, pass the generated static directory to `wtt-connect preview-port --snapshot-dir <dir> --snapshot-entry index.html` so WTT stores a persistent snapshot fallback. Live preview URLs are for recent interactive previews; snapshots/artifacts preserve history after cleanup.',
+    '- Do not pass `--snapshot-dir` for normal live previews. Live Cloud Sandbox previews should render as inline WTT preview cards, not as ordinary index.html/document artifacts.',
+    '- If the user explicitly asks for a persistent static artifact or downloadable HTML, publish that separately with `wtt-connect upload-artifact --dir <dir> --title "Short Title"` instead of mixing it with the live preview URL.',
     '- If you start a web server in the sandbox and the user should preview it, call the Cloudflare Sandbox outbound Worker directly with curl and include the returned `preview_url` in your reply as `[preview_url:Short Title](<preview_url>)`.',
     '- Preview ports must be 1024-65535 and cannot be 3000. For Vite/Next-style dev servers prefer 5173, 4173, or 8080.',
     `- Preview curl rule: curl -sS -X POST "\${WTT_SANDBOX_OUTBOX_URL:-http://wtt.preview}/preview-port" -H 'content-type: application/json' -d '{"agent_id":"'\${WTT_AGENT_ID:-cloud-agent}'","port":<port>}'`,
-    `- Prefer automatic WTT publishing when topic id is available: wtt-connect preview-port --port <port>${topicId ? ` --topic-id ${topicId}` : ' --topic-id <topic_id>'} --title "Short Title" --snapshot-dir <static_dir> --snapshot-entry index.html. This publishes a cloud_sandbox_preview card with live and snapshot URLs.`,
+    `- Prefer automatic WTT publishing when topic id is available: wtt-connect preview-port --port <port>${topicId ? ` --topic-id ${topicId}` : ' --topic-id <topic_id>'} --title "Short Title". This publishes one cloud_sandbox_preview live card.`,
   );
   return lines.join('\n');
 }

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',