ac-framework 1.9.8 → 2.0.0

package/src/commands/init.js

@@ -156,7 +156,8 @@ async function setupPersistentMemory() {
 async function setupCollaborativeSystem() {
   const hasOpenCode = hasCommand('opencode');
   const hasTmux = hasCommand('tmux');
-  const alreadyReady = hasOpenCode && hasTmux;
+  const hasZellij = hasCommand('zellij');
+  const alreadyReady = hasOpenCode && (hasZellij || hasTmux);
 
   console.log();
   await animatedSeparator(60);
@@ -168,10 +169,10 @@ async function setupCollaborativeSystem() {
   console.log(
     chalk.hex('#636E72')(
       `  ${COLLAB_SYSTEM_NAME} launches a real-time collaborative agent war-room with\n` +
-      '  4 coordinated roles (planner, critic, coder, reviewer) in tmux panes.\n\n' +
+      '  4 coordinated roles (planner, critic, coder, reviewer) in multiplexer panes.\n\n' +
       '  Each round is turn-based with shared incremental context, so every\n' +
       '  contribution from one agent is fed to the next, not isolated fan-out.\n\n' +
-      `  Dependencies: ${chalk.hex('#DFE6E9')('OpenCode')} + ${chalk.hex('#DFE6E9')('tmux')}`
+      `  Dependencies: ${chalk.hex('#DFE6E9')('OpenCode')} + ${chalk.hex('#DFE6E9')('zellij')} (${chalk.hex('#DFE6E9')('tmux')} fallback)`
     )
   );
   console.log();
@@ -223,7 +224,8 @@ async function setupCollaborativeSystem() {
 
   if (alreadyReady) {
     console.log();
-    console.log(chalk.hex('#00B894')('  ◆ OpenCode and tmux are already available.'));
+    const mux = hasZellij ? 'zellij' : 'tmux';
+    console.log(chalk.hex('#00B894')(`  ◆ OpenCode and ${mux} are already available.`));
     await installCollabMcpConnections();
     console.log(chalk.hex('#636E72')('  Run `acfm agents start --task "..."` to launch collaboration.'));
     console.log();
@@ -234,11 +236,20 @@ async function setupCollaborativeSystem() {
   console.log(chalk.hex('#B2BEC3')(`  Installing ${COLLAB_SYSTEM_NAME} dependencies...`));
   console.log();
 
-  const result = ensureCollabDependencies();
+  const result = await ensureCollabDependencies({
+    installZellij: true,
+    installTmux: true,
+    preferManagedZellij: true,
+  });
 
   const oColor = result.opencode.success ? chalk.hex('#00B894') : chalk.hex('#D63031');
+  const zColor = result.zellij.success ? chalk.hex('#00B894') : chalk.hex('#D63031');
   const tColor = result.tmux.success ? chalk.hex('#00B894') : chalk.hex('#D63031');
   console.log(oColor(`  ◆ OpenCode: ${result.opencode.message}`));
+  console.log(zColor(`  ◆ zellij: ${result.zellij.message}`));
+  if (result.zellij.binaryPath) {
+    console.log(chalk.hex('#636E72')(`    ${result.zellij.binaryPath}`));
+  }
   console.log(tColor(`  ◆ tmux: ${result.tmux.message}`));
   console.log();
 

package/src/mcp/collab-server.js

@@ -17,7 +17,13 @@ import { COLLAB_ROLES } from '../agents/constants.js';
 import { buildEffectiveRoleModels, sanitizeRoleModels } from '../agents/model-selection.js';
 import { runWorkerIteration } from '../agents/orchestrator.js';
 import { getSessionDir } from '../agents/state-store.js';
-import { spawnTmuxSession, tmuxSessionExists } from '../agents/runtime.js';
+import {
+  spawnTmuxSession,
+  spawnZellijSession,
+  tmuxSessionExists,
+  zellijSessionExists,
+  resolveMultiplexer,
+} from '../agents/runtime.js';
 import {
   addUserMessage,
   createSession,
@@ -28,7 +34,8 @@ import {
   setCurrentSession,
   stopSession,
 } from '../agents/state-store.js';
-import { hasCommand, resolveCommandPath } from '../services/dependency-installer.js';
+import { hasCommand, resolveCommandPath, resolveManagedZellijPath } from '../services/dependency-installer.js';
+import { loadAgentsConfig } from '../agents/config-store.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const runnerPath = resolve(__dirname, '../../bin/acfm.js');
@@ -67,6 +74,21 @@ function launchAutopilot(sessionId) {
   child.unref();
 }
 
+function resolveConfiguredZellijPath(config) {
+  const strategy = config?.agents?.zellij?.strategy || 'auto';
+  if (strategy === 'system') {
+    return resolveCommandPath('zellij');
+  }
+  const managed = resolveManagedZellijPath(config);
+  if (managed) return managed;
+  return resolveCommandPath('zellij');
+}
+
+async function muxExists(multiplexer, sessionName, zellijPath = null) {
+  if (multiplexer === 'zellij') return zellijSessionExists(sessionName, zellijPath);
+  return tmuxSessionExists(sessionName);
+}
+
 class MCPCollabServer {
   constructor() {
     this.server = new McpServer({
@@ -92,7 +114,7 @@ class MCPCollabServer {
           reviewer: z.string().optional(),
         }).partial().optional().describe('Optional per-role models (provider/model)'),
         cwd: z.string().optional().describe('Working directory for agents'),
-        spawnWorkers: z.boolean().default(true).describe('Create tmux workers and panes'),
+        spawnWorkers: z.boolean().default(true).describe('Create multiplexer workers and panes'),
         runPolicy: z.object({
           timeoutPerRoleMs: z.number().int().positive().optional(),
           retryOnTimeout: z.number().int().min(0).optional(),
@@ -107,8 +129,12 @@ class MCPCollabServer {
             throw new Error('OpenCode binary not found in PATH. Run: acfm agents setup');
           }
 
-          if (spawnWorkers && !hasCommand('tmux')) {
-            throw new Error('tmux is not installed. Run: acfm agents setup');
+          const config = await loadAgentsConfig();
+          const configuredMux = config.agents.multiplexer || 'auto';
+          const zellijPath = resolveConfiguredZellijPath(config);
+          const multiplexer = resolveMultiplexer(configuredMux, hasCommand('tmux'), Boolean(zellijPath));
+          if (spawnWorkers && !multiplexer) {
+            throw new Error('No multiplexer found (zellij/tmux). Run: acfm agents setup');
           }
 
           const state = await createSession(task, {
@@ -119,18 +145,31 @@ class MCPCollabServer {
             workingDirectory,
             opencodeBin,
             runPolicy,
+            multiplexer: multiplexer || configuredMux,
           });
           let updated = state;
           if (spawnWorkers) {
-            const tmuxSessionName = `acfm-synapse-${state.sessionId.slice(0, 8)}`;
+            const sessionName = `acfm-synapse-${state.sessionId.slice(0, 8)}`;
             const sessionDir = getSessionDir(state.sessionId);
-            await spawnTmuxSession({ sessionName: tmuxSessionName, sessionDir, sessionId: state.sessionId });
-            updated = await saveSessionState({ ...state, tmuxSessionName });
+            if (multiplexer === 'zellij') {
+              await spawnZellijSession({ sessionName, sessionDir, sessionId: state.sessionId, binaryPath: zellijPath });
+            } else {
+              await spawnTmuxSession({ sessionName, sessionDir, sessionId: state.sessionId });
+            }
+            updated = await saveSessionState({
+              ...state,
+              multiplexer,
+              multiplexerSessionName: sessionName,
+              tmuxSessionName: multiplexer === 'tmux' ? sessionName : null,
+            });
           }
           await setCurrentSession(state.sessionId);
 
-          const tmuxSessionName = updated.tmuxSessionName || null;
-          const attachCommand = tmuxSessionName ? `tmux attach -t ${tmuxSessionName}` : null;
+          const mux = updated.multiplexer || null;
+          const muxSessionName = updated.multiplexerSessionName || updated.tmuxSessionName || null;
+          const attachCommand = muxSessionName
+            ? (mux === 'zellij' ? `zellij attach ${muxSessionName}` : `tmux attach -t ${muxSessionName}`)
+            : null;
           return {
             content: [{
               type: 'text',
@@ -142,7 +181,8 @@ class MCPCollabServer {
                 roleModels: updated.roleModels || {},
                 effectiveRoleModels: buildEffectiveRoleModels(updated, updated.model || null),
                 run: summarizeRun(updated),
-                tmuxSessionName,
+                multiplexer: mux,
+                multiplexerSessionName: muxSessionName,
                 attachCommand,
               }, null, 2),
             }],
@@ -169,7 +209,7 @@ class MCPCollabServer {
             throw new Error(`Session is ${state.status}. Resume/start before invoking.`);
           }
 
-          if (!state.tmuxSessionName) {
+          if (!state.multiplexerSessionName && !state.tmuxSessionName) {
             launchAutopilot(state.sessionId);
           }
 
@@ -193,8 +233,13 @@ class MCPCollabServer {
                 status: state.status,
                 run: summarizeRun(state),
                 latestEvent: latestRunEvent(state),
-                tmuxSessionName: state.tmuxSessionName || null,
-                attachCommand: state.tmuxSessionName ? `tmux attach -t ${state.tmuxSessionName}` : null,
+                multiplexer: state.multiplexer || null,
+                multiplexerSessionName: state.multiplexerSessionName || state.tmuxSessionName || null,
+                attachCommand: state.multiplexerSessionName
+                  ? (state.multiplexer === 'zellij'
+                    ? `zellij attach ${state.multiplexerSessionName}`
+                    : `tmux attach -t ${state.multiplexerSessionName}`)
+                  : (state.tmuxSessionName ? `tmux attach -t ${state.tmuxSessionName}` : null),
               }, null, 2),
             }],
           };
@@ -408,35 +453,50 @@ class MCPCollabServer {
 
     this.server.tool(
       'collab_resume_session',
-      'Resume session and recreate tmux workers if needed',
+      'Resume session and recreate workers if needed',
       {
         sessionId: z.string().optional().describe('Session ID (defaults to current session)'),
-        recreateWorkers: z.boolean().default(true).describe('Recreate tmux session when missing'),
+        recreateWorkers: z.boolean().default(true).describe('Recreate multiplexer session when missing'),
       },
       async ({ sessionId, recreateWorkers }) => {
         try {
           const id = sessionId || await loadCurrentSessionId();
           if (!id) throw new Error('No active session found');
           let state = await loadSessionState(id);
+          const config = await loadAgentsConfig();
+          const zellijPath = resolveConfiguredZellijPath(config);
 
-          const tmuxSessionName = state.tmuxSessionName || `acfm-synapse-${state.sessionId.slice(0, 8)}`;
-          const tmuxExists = hasCommand('tmux') ? await tmuxSessionExists(tmuxSessionName) : false;
+          const multiplexer = state.multiplexer || resolveMultiplexer('auto', hasCommand('tmux'), Boolean(zellijPath));
+          if (!multiplexer) {
+            throw new Error('No multiplexer found (zellij/tmux). Run: acfm agents setup');
+          }
+          const sessionName = state.multiplexerSessionName || state.tmuxSessionName || `acfm-synapse-${state.sessionId.slice(0, 8)}`;
+          const sessionExists = await muxExists(multiplexer, sessionName, zellijPath);
 
-          if (!tmuxExists && recreateWorkers) {
-            if (!hasCommand('tmux')) {
-              throw new Error('tmux is not installed. Run: acfm agents setup');
-            }
+          if (!sessionExists && recreateWorkers) {
             const sessionDir = getSessionDir(state.sessionId);
-            await spawnTmuxSession({ sessionName: tmuxSessionName, sessionDir, sessionId: state.sessionId });
+            if (multiplexer === 'zellij') {
+              if (!zellijPath) throw new Error('zellij is not installed. Run: acfm agents setup');
+              await spawnZellijSession({ sessionName, sessionDir, sessionId: state.sessionId, binaryPath: zellijPath });
+            } else {
+              if (!hasCommand('tmux')) throw new Error('tmux is not installed. Run: acfm agents setup');
+              await spawnTmuxSession({ sessionName, sessionDir, sessionId: state.sessionId });
+            }
           }
 
           state = await saveSessionState({
             ...state,
             status: 'running',
-            tmuxSessionName,
+            multiplexer,
+            multiplexerSessionName: sessionName,
+            tmuxSessionName: multiplexer === 'tmux' ? sessionName : state.tmuxSessionName || null,
           });
           await setCurrentSession(state.sessionId);
 
+          const attachCommand = multiplexer === 'zellij'
+            ? `zellij attach ${sessionName}`
+            : `tmux attach -t ${sessionName}`;
+
           return {
             content: [{
               type: 'text',
@@ -444,8 +504,10 @@ class MCPCollabServer {
                 success: true,
                 sessionId: state.sessionId,
                 status: state.status,
-                tmuxSessionName,
-                recreatedWorkers: !tmuxExists && recreateWorkers,
+                multiplexer,
+                multiplexerSessionName: sessionName,
+                recreatedWorkers: !sessionExists && recreateWorkers,
+                attachCommand,
               }, null, 2),
             }],
           };

package/src/services/dependency-installer.js

@@ -1,7 +1,9 @@
 import { spawnSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
+import { chmod, mkdir, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { platform } from 'node:os';
+import { arch, homedir, platform } from 'node:os';
+import { createHash } from 'node:crypto';
 
 function preferredOpenCodePath() {
   const home = process.env.HOME;
@@ -17,6 +19,68 @@ function run(command, args, options = {}) {
   });
 }
 
+function runInstallCommand(command) {
+  if (platform() === 'win32') {
+    return run('cmd.exe', ['/c', command], { stdio: 'inherit' });
+  }
+  return run('bash', ['-lc', command], { stdio: 'inherit' });
+}
+
+async function fetchJson(url) {
+  const response = await fetch(url, {
+    headers: {
+      Accept: 'application/vnd.github+json',
+      'User-Agent': 'ac-framework',
+    },
+  });
+  if (!response.ok) {
+    throw new Error(`Request failed (${response.status}) while fetching ${url}`);
+  }
+  return response.json();
+}
+
+function sha256HexFromBuffer(buffer) {
+  const hash = createHash('sha256');
+  hash.update(buffer);
+  return hash.digest('hex');
+}
+
+function managedToolsRoot() {
+  return join(homedir(), '.acfm', 'tools', 'zellij');
+}
+
+function platformAssetPrefix() {
+  const p = platform();
+  const a = arch();
+  if (p === 'linux' && a === 'x64') return 'zellij-x86_64-unknown-linux-musl';
+  if (p === 'linux' && a === 'arm64') return 'zellij-aarch64-unknown-linux-musl';
+  if (p === 'darwin' && a === 'x64') return 'zellij-x86_64-apple-darwin';
+  if (p === 'darwin' && a === 'arm64') return 'zellij-aarch64-apple-darwin';
+  if (p === 'win32' && a === 'x64') return 'zellij-x86_64-pc-windows-msvc';
+  return null;
+}
+
+function managedZellijBinaryPath(version) {
+  const fileName = platform() === 'win32' ? 'zellij.exe' : 'zellij';
+  return join(managedToolsRoot(), version, fileName);
+}
+
+function extractTarball(tarPath, outputDir) {
+  return run('tar', ['-xzf', tarPath, '-C', outputDir]);
+}
+
+function findReleaseAsset(release, suffix) {
+  return (release.assets || []).find((asset) => asset.name === suffix) || null;
+}
+
+export function resolveManagedZellijPath(config = null) {
+  const fromEnv = process.env.ACFM_ZELLIJ_BIN;
+  if (fromEnv && existsSync(fromEnv)) return fromEnv;
+  const configured = config?.agents?.zellij?.binaryPath;
+  if (configured && existsSync(configured)) return configured;
+  return null;
+}
+
 export function hasCommand(command) {
   return Boolean(resolveCommandPath(command));
 }
@@ -78,6 +142,29 @@ function resolveTmuxInstallCommand() {
   return null;
 }
 
+function resolveZellijInstallCommand() {
+  if (platform() === 'darwin') {
+    if (hasCommand('brew')) return 'brew install zellij';
+    return null;
+  }
+
+  if (platform() === 'linux') {
+    if (hasCommand('apt-get')) return 'sudo apt-get update && sudo apt-get install -y zellij';
+    if (hasCommand('dnf')) return 'sudo dnf install -y zellij';
+    if (hasCommand('yum')) return 'sudo yum install -y zellij';
+    if (hasCommand('pacman')) return 'sudo pacman -S --noconfirm zellij';
+    if (hasCommand('zypper')) return 'sudo zypper --non-interactive install zellij';
+  }
+
+  if (platform() === 'win32') {
+    if (hasCommand('winget')) return 'winget install --id zellij-org.zellij -e';
+    if (hasCommand('choco')) return 'choco install zellij -y';
+    if (hasCommand('scoop')) return 'scoop install zellij';
+  }
+
+  return null;
+}
+
 export function installTmux() {
   if (hasCommand('tmux')) {
     return { success: true, installed: false, message: 'tmux already installed' };
@@ -92,7 +179,7 @@ export function installTmux() {
     };
   }
 
-  const result = run('bash', ['-lc', installCommand], { stdio: 'inherit' });
+  const result = runInstallCommand(installCommand);
   if (result.status !== 0) {
     return { success: false, installed: false, message: 'tmux installation command failed' };
   }
@@ -106,12 +193,167 @@ export function installTmux() {
   };
 }
 
-export function ensureCollabDependencies() {
+export function installZellij() {
+  if (hasCommand('zellij')) {
+    return { success: true, installed: false, message: 'zellij already installed' };
+  }
+
+  const installCommand = resolveZellijInstallCommand();
+  if (!installCommand) {
+    return {
+      success: false,
+      installed: false,
+      message: 'No supported package manager detected for automatic zellij installation',
+    };
+  }
+
+  const result = runInstallCommand(installCommand);
+  if (result.status !== 0) {
+    return { success: false, installed: false, message: 'zellij installation command failed' };
+  }
+
+  return {
+    success: hasCommand('zellij'),
+    installed: true,
+    message: hasCommand('zellij')
+      ? 'zellij installed successfully'
+      : 'zellij installer finished but binary is not available in PATH yet',
+  };
+}
+
+export async function installManagedZellijLatest() {
+  const existingSystem = resolveCommandPath('zellij');
+  if (existingSystem) {
+    return {
+      success: true,
+      installed: false,
+      version: null,
+      binaryPath: existingSystem,
+      message: 'zellij already installed in system PATH',
+      source: 'system',
+    };
+  }
+
+  const prefix = platformAssetPrefix();
+  if (!prefix) {
+    return {
+      success: false,
+      installed: false,
+      version: null,
+      binaryPath: null,
+      message: `Unsupported OS/arch for managed zellij install: ${platform()}/${arch()}`,
+      source: 'managed',
+    };
+  }
+
+  try {
+    const release = await fetchJson('https://api.github.com/repos/zellij-org/zellij/releases/latest');
+    const version = String(release.tag_name || '').trim() || 'latest';
+
+    if (platform() === 'win32') {
+      const zipAsset = findReleaseAsset(release, `${prefix}.zip`);
+      if (!zipAsset) {
+        throw new Error(`No matching Windows asset found for ${prefix}`);
+      }
+      return {
+        success: false,
+        installed: false,
+        version,
+        binaryPath: null,
+        message: 'Managed Windows zellij install is not implemented yet; use winget/choco/scoop.',
+        source: 'managed',
+      };
+    }
+
+    const tarAsset = findReleaseAsset(release, `${prefix}.tar.gz`);
+    if (!tarAsset?.browser_download_url) {
+      throw new Error(`No matching zellij asset found for ${prefix}`);
+    }
+
+    const targetDir = join(managedToolsRoot(), version);
+    const binaryPath = managedZellijBinaryPath(version);
+    if (existsSync(binaryPath)) {
+      return {
+        success: true,
+        installed: false,
+        version,
+        binaryPath,
+        message: `Managed zellij already installed (${version})`,
+        source: 'managed',
+      };
+    }
+
+    await mkdir(targetDir, { recursive: true });
+    const tmpTarPath = join(targetDir, `${prefix}.tar.gz.download`);
+    const response = await fetch(tarAsset.browser_download_url, {
+      headers: { 'User-Agent': 'ac-framework' },
+    });
+    if (!response.ok) {
+      throw new Error(`Failed downloading ${tarAsset.name} (${response.status})`);
+    }
+    const raw = Buffer.from(await response.arrayBuffer());
+
+    const expectedDigest = String(tarAsset.digest || '').replace(/^sha256:/, '');
+    if (expectedDigest) {
+      const actualDigest = sha256HexFromBuffer(raw);
+      if (actualDigest !== expectedDigest) {
+        throw new Error(`Digest mismatch for ${tarAsset.name}`);
+      }
+    }
+
+    await writeFile(tmpTarPath, raw);
+    const extracted = extractTarball(tmpTarPath, targetDir);
+    await rm(tmpTarPath, { force: true });
+    if (extracted.status !== 0) {
+      throw new Error('Failed extracting zellij tarball');
+    }
+    if (!existsSync(binaryPath)) {
+      throw new Error(`zellij binary not found after extraction at ${binaryPath}`);
+    }
+    await chmod(binaryPath, 0o755);
+
+    const versionProbe = run(binaryPath, ['--version']);
+    if (versionProbe.status !== 0) {
+      throw new Error('Installed zellij binary failed version check');
+    }
+
+    return {
+      success: true,
+      installed: true,
+      version,
+      binaryPath,
+      message: `Managed zellij installed (${version})`,
+      source: 'managed',
+    };
+  } catch (error) {
+    return {
+      success: false,
+      installed: false,
+      version: null,
+      binaryPath: null,
+      message: `Managed zellij install failed: ${error.message}`,
+      source: 'managed',
+    };
+  }
+}
+
+export async function ensureCollabDependencies(options = {}) {
+  const installTmuxEnabled = options.installTmux ?? true;
+  const installZellijEnabled = options.installZellij ?? true;
+  const preferManagedZellij = options.preferManagedZellij ?? false;
   const opencode = installOpenCode();
-  const tmux = installTmux();
+  const tmux = installTmuxEnabled
+    ? installTmux()
+    : { success: hasCommand('tmux'), installed: false, message: hasCommand('tmux') ? 'tmux already installed' : 'tmux installation skipped' };
+  const zellij = installZellijEnabled
+    ? (preferManagedZellij ? await installManagedZellijLatest() : installZellij())
+    : { success: hasCommand('zellij'), installed: false, message: hasCommand('zellij') ? 'zellij already installed' : 'zellij installation skipped' };
+
+  const hasMultiplexer = tmux.success || zellij.success;
   return {
     opencode,
     tmux,
-    success: opencode.success && tmux.success,
+    zellij,
+    success: opencode.success && hasMultiplexer,
   };
 }