@triflux/remote 10.0.0-alpha.2 → 10.0.1

package/hub/team/remote-session.mjs

@@ -0,0 +1,299 @@
+// hub/team/remote-session.mjs — Remote session primitives for swarm integration
+// Extracted from scripts/remote-spawn.mjs for reuse by swarm-hypervisor.
+// Pure functions + SSH operations. No psmux, no WT, no CLI arg parsing.
+
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, join, posix as posixPath, win32 as win32Path } from 'node:path';
+import { execSshWithRetry } from '@triflux/core/hub/lib/ssh-retry.mjs';
+
+const REMOTE_ENV_TTL_MS = 86_400_000; // 24h
+const REMOTE_STAGE_ROOT = 'tfx-remote';
+const SAFE_HOST_RE = /^[a-zA-Z0-9._-]+$/;
+
+// ── Shell quoting utilities ─────────────────────────────────────
+
+export function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+export function escapePwshSingleQuoted(value) {
+  return String(value).replace(/'/g, "''");
+}
+
+export function escapePwshDoubleQuoted(value) {
+  return String(value).replace(/`/g, '``').replace(/"/g, '`"');
+}
+
+function normalizeCommandPath(value) {
+  return String(value).replace(/\\/g, '/');
+}
+
+// ── Validation ──────────────────────────────────────────────────
+
+export function validateHost(host) {
+  if (!host || !SAFE_HOST_RE.test(host)) {
+    throw new Error(`invalid host name: ${host}`);
+  }
+  return host;
+}
+
+// ── Remote environment probe ────────────────────────────────────
+
+function parseProbeLines(text) {
+  return Object.fromEntries(
+    text
+      .split(/\r?\n/u)
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => {
+        const idx = line.indexOf('=');
+        return idx === -1 ? null : [line.slice(0, idx), line.slice(idx + 1)];
+      })
+      .filter(Boolean),
+  );
+}
+
+function normalizePwshProbeEnv(parsed) {
+  if (parsed.shell !== 'pwsh' || parsed.os !== 'win32') return null;
+  if (!parsed.home) return null;
+  return Object.freeze({
+    claudePath: (!parsed.claude || parsed.claude === 'notfound') ? null : parsed.claude,
+    home: parsed.home,
+    os: 'win32',
+    shell: 'pwsh',
+  });
+}
+
+function normalizePosixProbeEnv(parsed) {
+  const os = parsed.os === 'darwin' ? 'darwin' : parsed.os === 'linux' ? 'linux' : null;
+  if (!os || !parsed.home) return null;
+  return Object.freeze({
+    claudePath: (!parsed.claude || parsed.claude === 'notfound') ? null : parsed.claude,
+    home: parsed.home,
+    os,
+    shell: parsed.shell === 'zsh' ? 'zsh' : 'bash',
+  });
+}
+
+function probeRemoteEnvViaPwsh(host) {
+  const command = [
+    "Write-Output 'shell=pwsh'",
+    'Write-Output "home=$env:USERPROFILE"',
+    'if (Test-Path "$env:USERPROFILE\\.local\\bin\\claude.exe") { Write-Output "claude=$env:USERPROFILE\\.local\\bin\\claude.exe" } elseif (Get-Command claude -ErrorAction SilentlyContinue) { Write-Output "claude=$((Get-Command claude).Source)" } else { Write-Output \'claude=notfound\' }',
+    'Write-Output "os=$([System.Runtime.InteropServices.RuntimeInformation]::IsOSPlatform([System.Runtime.InteropServices.OSPlatform]::Windows) ? \'win32\' : \'other\')"',
+  ].join('; ');
+
+  try {
+    const output = execSshWithRetry([host, 'pwsh', '-NoProfile', '-Command', command], {
+      encoding: 'utf8', timeout: 15000, stdio: ['pipe', 'pipe', 'pipe'],
+      maxRetries: 2, baseDelayMs: 1000,
+    });
+    return normalizePwshProbeEnv(parseProbeLines(output));
+  } catch {
+    return null;
+  }
+}
+
+function probeRemoteEnvViaPosix(host) {
+  const script = [
+    'echo shell=$(basename $SHELL)',
+    'echo home=$HOME',
+    'command -v claude >/dev/null 2>&1 && echo claude=$(command -v claude) || echo claude=notfound',
+    'echo os=$(uname -s | tr A-Z a-z)',
+  ].join('\n');
+
+  try {
+    const output = execSshWithRetry([host, 'sh'], {
+      encoding: 'utf8', timeout: 15000, input: script,
+      maxRetries: 2, baseDelayMs: 1000,
+    });
+    return normalizePosixProbeEnv(parseProbeLines(output));
+  } catch {
+    return null;
+  }
+}
+
+// ── Cache ───────────────────────────────────────────────────────
+
+function getEnvCachePath(host, cacheDir) {
+  return join(cacheDir, `${host}.json`);
+}
+
+function readEnvCache(host, cacheDir) {
+  const cachePath = getEnvCachePath(host, cacheDir);
+  if (!existsSync(cachePath)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(cachePath, 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function isEnvCacheFresh(entry) {
+  return Boolean(
+    entry
+    && typeof entry.cachedAt === 'number'
+    && entry.env
+    && (Date.now() - entry.cachedAt) < REMOTE_ENV_TTL_MS,
+  );
+}
+
+function writeEnvCache(host, env, cacheDir) {
+  mkdirSync(cacheDir, { recursive: true });
+  writeFileSync(getEnvCachePath(host, cacheDir), JSON.stringify({ cachedAt: Date.now(), env }, null, 2), 'utf8');
+}
+
+/**
+ * Probe remote host environment (OS, shell, Claude path, home dir).
+ * Results are cached for 24h.
+ *
+ * @param {string} host — SSH host
+ * @param {object} [opts]
+ * @param {boolean} [opts.force=false] — bypass cache
+ * @param {string} [opts.cacheDir] — cache directory (default: .omc/state/remote-env)
+ * @returns {Readonly<RemoteEnv>}
+ */
+export function probeRemoteEnv(host, opts = {}) {
+  validateHost(host);
+  const force = opts.force === true;
+  const cacheDir = opts.cacheDir || join('.omc', 'state', 'remote-env');
+
+  if (!force) {
+    const cached = readEnvCache(host, cacheDir);
+    if (isEnvCacheFresh(cached)) return cached.env;
+  }
+
+  const pwshEnv = probeRemoteEnvViaPwsh(host);
+  if (pwshEnv) { writeEnvCache(host, pwshEnv, cacheDir); return pwshEnv; }
+
+  const posixEnv = probeRemoteEnvViaPosix(host);
+  if (posixEnv) { writeEnvCache(host, posixEnv, cacheDir); return posixEnv; }
+
+  throw new Error(`remote probe failed for ${host}`);
+}
+
+// ── Remote directory resolution ─────────────────────────────────
+
+function isWindowsAbsolutePath(value) {
+  return /^[a-zA-Z]:[\\/]/u.test(value) || value.startsWith('\\\\');
+}
+
+/**
+ * Resolve a directory path on a remote host.
+ * Handles ~ expansion and OS-specific path normalization.
+ *
+ * @param {string} dir — requested directory (or empty for home)
+ * @param {RemoteEnv} env
+ * @returns {string}
+ */
+export function resolveRemoteDir(dir, env) {
+  const requestedDir = dir || env.home;
+
+  if (env.os === 'win32') {
+    const winDir = requestedDir.replace(/\//g, '\\');
+    if (winDir === '~') return env.home;
+    if (/^~[\\/]/u.test(winDir)) return win32Path.join(env.home, winDir.slice(2));
+    if (isWindowsAbsolutePath(winDir)) return winDir;
+    return win32Path.join(env.home, winDir);
+  }
+
+  if (requestedDir === '~') return env.home;
+  if (requestedDir.startsWith('~/')) return posixPath.join(env.home, requestedDir.slice(2));
+  if (requestedDir.startsWith('/')) return requestedDir;
+  return posixPath.join(env.home, requestedDir);
+}
+
+// ── Remote file staging ─────────────────────────────────────────
+
+/**
+ * Resolve the remote staging directory path.
+ * @param {RemoteEnv} env
+ * @param {string} stageId
+ * @returns {string}
+ */
+export function resolveRemoteStageDir(env, stageId) {
+  return `${normalizeCommandPath(env.home)}/${REMOTE_STAGE_ROOT}/${stageId}`;
+}
+
+/**
+ * Ensure the remote staging directory exists via SSH.
+ * @param {string} host
+ * @param {RemoteEnv} env
+ * @param {string} remoteStageDir
+ */
+export function ensureRemoteStageDir(host, env, remoteStageDir) {
+  if (env.os === 'win32') {
+    const safePath = escapePwshSingleQuoted(remoteStageDir);
+    execFileSync('ssh', [host, 'pwsh', '-NoProfile', '-Command', `New-Item -ItemType Directory -Path '${safePath}' -Force | Out-Null`], { timeout: 10000, stdio: 'pipe' });
+    return;
+  }
+  execFileSync('ssh', [host, 'sh', '-lc', `mkdir -p ${shellQuote(remoteStageDir)}`], { timeout: 10000, stdio: 'pipe' });
+}
+
+/**
+ * Upload a file to remote host via scp.
+ * @param {string} host
+ * @param {string} localPath
+ * @param {string} remotePath
+ */
+export function uploadFileToRemote(host, localPath, remotePath) {
+  execFileSync('scp', [localPath, `${host}:${remotePath}`], { timeout: 15000, stdio: 'pipe' });
+}
+
+/**
+ * Stage local files on a remote host for prompt delivery.
+ *
+ * @param {string} host
+ * @param {RemoteEnv} env
+ * @param {Array<{ localPath: string }>} transferCandidates
+ * @param {string} stageId
+ * @returns {{ remoteStageDir: string|null, stagedFiles: Array<{ localPath: string, remotePath: string }> }}
+ */
+export function stageRemotePromptFiles(host, env, transferCandidates, stageId) {
+  if (!transferCandidates || transferCandidates.length === 0) {
+    return { remoteStageDir: null, stagedFiles: [] };
+  }
+
+  const remoteStageDir = resolveRemoteStageDir(env, stageId);
+  ensureRemoteStageDir(host, env, remoteStageDir);
+
+  const basenameCounts = new Map();
+  const stagedFiles = transferCandidates.map((candidate) => {
+    const fileName = basename(candidate.localPath);
+    const count = (basenameCounts.get(fileName) || 0) + 1;
+    basenameCounts.set(fileName, count);
+    const stagedName = count === 1 ? fileName : `${count}-${fileName}`;
+    const remotePath = `${remoteStageDir}/${stagedName}`;
+    uploadFileToRemote(host, candidate.localPath, remotePath);
+    return { ...candidate, remotePath };
+  });
+
+  return { remoteStageDir, stagedFiles };
+}
+
+/**
+ * Execute a git command on a remote host via SSH.
+ *
+ * @param {string} host
+ * @param {RemoteEnv} env
+ * @param {string[]} gitArgs — git subcommand + args
+ * @param {string} cwd — remote working directory
+ * @returns {string} stdout
+ */
+export function remoteGit(host, env, gitArgs, cwd) {
+  const gitCmd = ['git', ...gitArgs].map((a) => shellQuote(a)).join(' ');
+
+  if (env.os === 'win32') {
+    const cdPath = escapePwshSingleQuoted(cwd);
+    const command = `Set-Location '${cdPath}'; ${gitCmd}`;
+    return execFileSync('ssh', [host, 'pwsh', '-NoProfile', '-Command', command], {
+      encoding: 'utf8', timeout: 30_000, stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+  }
+
+  return execFileSync('ssh', [host, 'sh', '-lc', `cd ${shellQuote(cwd)} && ${gitCmd}`], {
+    encoding: 'utf8', timeout: 30_000, stdio: ['pipe', 'pipe', 'pipe'],
+  }).trim();
+}

package/hub/team/swarm-hypervisor.mjs

@@ -18,6 +18,9 @@ import { execSync } from 'node:child_process';
 import { createConductor, STATES } from './conductor.mjs';
 import { createSwarmLocks } from './swarm-locks.mjs';
 import { createEventLog } from './event-log.mjs';
+import { probeRemoteEnv, resolveRemoteDir } from './remote-session.mjs';
+import { fetchRemoteShard } from './worktree-lifecycle.mjs';
+import { getHostConfig } from '@triflux/core/hub/lib/ssh-command.mjs';
 
 // ── Swarm states ──────────────────────────────────────────────
 
@@ -103,19 +106,51 @@ export function createSwarmHypervisor(opts) {
   // ── Worker lifecycle ────────────────────────────────────────
 
   function buildSessionConfig(shard) {
-    return {
+    const config = {
       id: `swarm-${shard.name}-${Date.now()}`,
       agent: shard.agent,
       prompt: shard.prompt,
       workdir,
       mcpServers: shard.mcp,
     };
+
+    // Remote shard: add conductor remote fields
+    if (shard.host && shard._remoteEnv) {
+      const remoteDir = resolveRemoteDir(workdir, shard._remoteEnv);
+      return {
+        ...config,
+        remote: true,
+        host: shard.host,
+        sessionName: `swarm-${shard.name}-${Date.now()}`,
+        paneTarget: `swarm-${shard.name}-${Date.now()}:0.0`,
+        workdir: remoteDir,
+      };
+    }
+
+    return config;
   }
 
   function launchShard(shard, isRedundant = false) {
     const shardLogsDir = join(logsDir, isRedundant ? `${shard.name}-redundant` : shard.name);
     mkdirSync(shardLogsDir, { recursive: true });
 
+    // Remote shard: probe environment before conductor creation
+    if (shard.host && !shard._remoteEnv) {
+      try {
+        shard._remoteEnv = probeRemoteEnv(shard.host);
+        if (!shard._remoteEnv.claudePath) {
+          eventLog.append('remote_probe_no_claude', { shard: shard.name, host: shard.host });
+          failures.set(shard.name, { mode: FAILURE_MODES.F1_CRASH, reason: `claude not found on ${shard.host}` });
+          return null;
+        }
+        eventLog.append('remote_probe_ok', { shard: shard.name, host: shard.host, env: shard._remoteEnv });
+      } catch (err) {
+        eventLog.append('remote_probe_failed', { shard: shard.name, host: shard.host, error: err.message });
+        failures.set(shard.name, { mode: FAILURE_MODES.F1_CRASH, reason: `remote probe failed: ${err.message}` });
+        return null;
+      }
+    }
+
     const conductor = createConductor({
       logsDir: shardLogsDir,
       maxRestarts,
@@ -150,6 +185,8 @@ export function createSwarmHypervisor(opts) {
       sessionId: sessionConfig.id,
       isRedundant,
       files: shard.files,
+      remote: Boolean(shard.host),
+      host: shard.host || null,
     });
 
     const entry = { conductor, shardConfig: shard, sessionConfig, startedAt: Date.now() };
@@ -302,6 +339,28 @@ export function createSwarmHypervisor(opts) {
       const worker = workers.get(shardName);
       if (!worker) continue;
 
+      // Fetch remote shard branch to local (push-blocked hosts like Ultra4)
+      const shard = plan.shards.find((s) => s.name === shardName);
+      if (shard?.host && shard._remoteEnv) {
+        const hostConfig = getHostConfig(shard.host, config.rootDir);
+        const sshUser = hostConfig?.ssh_user || shard.host;
+        const remoteRepoPath = resolveRemoteDir(config.rootDir || process.cwd(), shard._remoteEnv);
+        const fetchResult = await fetchRemoteShard({
+          host: shard.host,
+          sshUser,
+          remoteRepoPath,
+          branchName: worker.branchName || `swarm/${config.runId}/${shardName}`,
+          rootDir: config.rootDir || process.cwd(),
+        });
+
+        if (!fetchResult.ok) {
+          eventLog.append('remote_fetch_failed', { shard: shardName, error: fetchResult.error });
+          integrationFailures.push(shardName);
+          continue;
+        }
+        eventLog.append('remote_fetch_ok', { shard: shardName, headCommit: fetchResult.headCommit });
+      }
+
       // Read shard output log for changed files
       const changedFiles = detectChangedFiles(shardName, worker);
 

package/hub/team/swarm-planner.mjs

@@ -24,6 +24,7 @@ const SHARD_DEFAULTS = Object.freeze({
   depends: [],
   critical: false,
   prompt: '',
+  host: '',
 });
 
 /**
@@ -105,6 +106,9 @@ export function parseShards(content) {
       case 'critical':
         current.critical = /^(true|yes|1)$/i.test(value);
         break;
+      case 'host':
+        current.host = value;
+        break;
       case 'prompt':
         if (value && !value.startsWith('|')) {
           current.prompt = value;

package/hub/team/worktree-lifecycle.mjs

@@ -1,10 +1,12 @@
 // hub/team/worktree-lifecycle.mjs — Git worktree lifecycle management
 // Replaces shell commands in tfx-codex-swarm Step 5 + merge-worktree Phase 6.
 // Convention: .codex-swarm/wt-{slug} paths, swarm/{runId}/{slug} branches.
+// Remote support: host option → SSH-based git operations via remote-session.mjs.
 
 import { execFile } from 'node:child_process';
 import { resolve, normalize } from 'node:path';
 import { mkdir, rm, access } from 'node:fs/promises';
+import { remoteGit, validateHost } from './remote-session.mjs';
 
 const SWARM_ROOT = '.codex-swarm';
 const SLEEP_MS = 2000; // WT race-guard (MEMORY.md: wt-attach-spacing)
@@ -39,39 +41,58 @@ function normPath(p) {
  * @param {string} opts.runId — swarm run ID
  * @param {string} [opts.rootDir=process.cwd()] — repo root
  * @param {string} [opts.baseBranch='main'] — base branch to branch from
- * @returns {Promise<{ worktreePath: string, branchName: string }>}
+ * @param {string} [opts.host] — SSH host for remote worktree creation
+ * @param {object} [opts.remoteEnv] — remote environment from probeRemoteEnv()
+ * @returns {Promise<{ worktreePath: string, branchName: string, remote: boolean }>}
  */
-export async function ensureWorktree({ slug, runId, rootDir = process.cwd(), baseBranch = 'main' }) {
-  const wtDir = resolve(rootDir, SWARM_ROOT, `wt-${slug}`);
+export async function ensureWorktree({ slug, runId, rootDir = process.cwd(), baseBranch = 'main', host, remoteEnv }) {
   const branchName = `swarm/${runId}/${slug}`;
 
+  // ── Remote path: SSH-based worktree creation ──
+  if (host && remoteEnv) {
+    const remoteRoot = rootDir.replace(/\\/g, '/');
+    const remoteWtDir = `${remoteRoot}/${SWARM_ROOT}/wt-${slug}`;
+
+    try { remoteGit(host, remoteEnv, ['worktree', 'prune'], remoteRoot); } catch { /* best-effort */ }
+
+    try {
+      remoteGit(host, remoteEnv, ['worktree', 'add', remoteWtDir, '-b', branchName, baseBranch], remoteRoot);
+    } catch {
+      try {
+        remoteGit(host, remoteEnv, ['worktree', 'add', remoteWtDir, branchName], remoteRoot);
+      } catch { /* already exists — acceptable */ }
+    }
+
+    return { worktreePath: remoteWtDir, branchName, remote: true };
+  }
+
+  // ── Local path (existing logic) ──
+  const wtDir = resolve(rootDir, SWARM_ROOT, `wt-${slug}`);
+
   await mkdir(resolve(rootDir, SWARM_ROOT), { recursive: true });
 
   // Check if worktree already exists
   try {
     await access(wtDir);
-    // Already exists — verify it's a valid worktree
     await git(['rev-parse', '--is-inside-work-tree'], wtDir);
-    return { worktreePath: normPath(wtDir), branchName };
+    return { worktreePath: normPath(wtDir), branchName, remote: false };
   } catch {
     // Doesn't exist or invalid — create fresh
   }
 
-  // Clean up stale references
   try {
     await git(['worktree', 'prune'], rootDir);
   } catch { /* best-effort */ }
 
   await sleep(SLEEP_MS);
 
-  // Try create with new branch, fallback to existing branch
   try {
     await git(['worktree', 'add', wtDir, '-b', branchName, baseBranch], rootDir);
   } catch {
     await git(['worktree', 'add', wtDir, branchName], rootDir);
   }
 
-  return { worktreePath: normPath(wtDir), branchName };
+  return { worktreePath: normPath(wtDir), branchName, remote: false };
 }
 
 /**
@@ -170,3 +191,39 @@ export async function pruneWorktree({ worktreePath, branchName, rootDir = proces
     try { await git(['branch', '-D', branchName], rootDir); } catch { /* may not exist */ }
   }
 }
+
+/**
+ * Fetch a remote shard's branch to the local repo via SSH.
+ * Workaround for hosts that cannot push to GitHub (e.g. Ultra4).
+ *
+ * Flow: add temp remote → fetch branch → remove remote.
+ *
+ * @param {object} opts
+ * @param {string} opts.host — SSH host (e.g. "ultra4")
+ * @param {string} opts.sshUser — SSH user (e.g. "SSAFY")
+ * @param {string} opts.remoteRepoPath — absolute path on remote (e.g. "/c/Users/SSAFY/Desktop/Projects/cli/triflux")
+ * @param {string} opts.branchName — branch to fetch (e.g. "swarm/run123/auth")
+ * @param {string} [opts.rootDir=process.cwd()] — local repo root
+ * @returns {Promise<{ ok: boolean, localRef?: string, error?: string }>}
+ */
+export async function fetchRemoteShard({ host, sshUser, remoteRepoPath, branchName, rootDir = process.cwd() }) {
+  validateHost(host);
+
+  const remoteName = `_swarm-${host}-${Date.now()}`;
+  const sshUrl = `ssh://${sshUser}@${host}${remoteRepoPath}`;
+
+  try {
+    await git(['remote', 'add', remoteName, sshUrl], rootDir);
+
+    await git(['fetch', remoteName, branchName, '--no-tags'], rootDir);
+
+    const localRef = `${remoteName}/${branchName}`;
+    const headCommit = await git(['rev-parse', `FETCH_HEAD`], rootDir);
+
+    return { ok: true, localRef, headCommit };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  } finally {
+    try { await git(['remote', 'remove', remoteName], rootDir); } catch { /* cleanup */ }
+  }
+}