@hasna/skills 0.0.2

package/skills/skill-e2bswarm/src/commands/spawn.ts

@@ -0,0 +1,134 @@
+import { resolve } from 'node:path';
+import ora from 'ora';
+import { E2BSwarm } from '../lib/e2b';
+import { loadTasks, distributeTasks, determineTaskSource, summarizeDistribution } from '../lib/tasks';
+import { loadConfig, loadState, saveState } from '../lib/config';
+import { logger } from '../lib/logger';
+import { paths } from '../lib/paths';
+import type { SpawnOptions, SwarmInstance } from '../types';
+
+export async function spawn(options: SpawnOptions) {
+  const spinner = ora('Loading configuration...').start();
+
+  try {
+    // Validate source options
+    if (!options.repo && !options.local) {
+      throw new Error(
+        'Must specify either --repo <url> or --local <path>\n' +
+        '  --repo <url>    Clone from git repository\n' +
+        '  --local <path>  Upload from local directory'
+      );
+    }
+
+    if (options.repo && options.local) {
+      throw new Error('Cannot specify both --repo and --local');
+    }
+
+    // Determine source type
+    const sourceType = options.local ? 'local' : 'repo';
+    const source = options.local ? resolve(options.local) : options.repo!;
+
+    // Load config with template
+    const config = await loadConfig(options.template);
+    spinner.succeed(`Configuration loaded (template: ${config.template})`);
+
+    // Determine task source and load tasks
+    spinner.start('Loading tasks...');
+    const taskSource = determineTaskSource(options);
+    const allTasks = await loadTasks(taskSource);
+    spinner.succeed(`Loaded ${allTasks.length} tasks from ${taskSource.type}`);
+
+    // Parse instance count
+    const instanceCount = parseInt(options.instances, 10);
+    if (isNaN(instanceCount) || instanceCount < 1) {
+      throw new Error('Instance count must be a positive number');
+    }
+
+    if (instanceCount > config.maxInstances) {
+      throw new Error(`Maximum ${config.maxInstances} instances allowed`);
+    }
+
+    // Distribute tasks
+    const distributeMode = options.distribute || 'all';
+    const distribution = distributeTasks(allTasks, instanceCount, distributeMode);
+
+    logger.header('Task Distribution');
+    console.log(summarizeDistribution(distribution));
+    console.log();
+
+    // Create swarm manager
+    const swarm = new E2BSwarm(config);
+
+    // Load existing state
+    const state = await loadState();
+
+    logger.header(`Spawning ${instanceCount} Instances`);
+    logger.info(`Source: ${source} (${sourceType})`);
+    logger.info(`Template: ${config.template}`);
+    logger.info(`Data directory: ${paths.skillData}`);
+    console.log();
+
+    // Parse include/exclude patterns
+    const include = options.include;
+    const exclude = options.exclude;
+
+    // Spawn instances in parallel
+    const spawnPromises = distribution.map(async (tasks, i) => {
+      if (tasks.length === 0) {
+        logger.warn(`Instance ${i + 1} has no tasks assigned, skipping`);
+        return null;
+      }
+
+      const instance = await swarm.spawn({
+        source,
+        sourceType,
+        tasks,
+        prompt: options.prompt || `Execute the assigned tasks from the swarm task list.`,
+        branch: options.branch,
+        newBranch: options.newBranch,
+        include,
+        exclude,
+        // GitHub integration options
+        autoCommit: options.autoCommit,
+        autoPush: options.autoPush,
+        createPr: options.createPr,
+        prTitle: options.prTitle,
+        prBase: options.prBase,
+      });
+
+      return instance;
+    });
+
+    const instances = (await Promise.all(spawnPromises)).filter(
+      (i): i is SwarmInstance => i !== null
+    );
+
+    // Save state
+    state.instances.push(...instances);
+    await saveState(state);
+
+    // Summary
+    logger.header('Summary');
+
+    const running = instances.filter(i => i.status === 'running').length;
+    const failed = instances.filter(i => i.status === 'failed').length;
+
+    logger.info(`Total instances: ${instances.length}`);
+    logger.info(`Running: ${running}`);
+    if (failed > 0) {
+      logger.error(`Failed: ${failed}`);
+    }
+
+    console.log();
+    logger.info(`Exports: ${paths.exports}`);
+    logger.info(`Logs: ${paths.logs}`);
+    console.log();
+    logger.info('Use `skill-e2bswarm status` to check progress');
+    logger.info('Use `skill-e2bswarm collect` to gather results');
+
+  } catch (error) {
+    spinner.fail('Failed');
+    logger.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}

package/skills/skill-e2bswarm/src/commands/status.ts

@@ -0,0 +1,90 @@
+import { E2BSwarm } from '../lib/e2b';
+import { loadConfig, loadState, saveState } from '../lib/config';
+import { logger } from '../lib/logger';
+import type { StatusOptions } from '../types';
+
+export async function status(options: StatusOptions) {
+  try {
+    const config = await loadConfig();
+    const state = await loadState();
+
+    if (state.instances.length === 0) {
+      logger.info('No instances found. Use `e2b-swarm spawn` to create instances.');
+      return;
+    }
+
+    const swarm = new E2BSwarm(config);
+
+    logger.header('Instance Status');
+
+    // Filter to specific instance if requested
+    const instances = options.instance
+      ? state.instances.filter(i => i.id.startsWith(options.instance!))
+      : state.instances;
+
+    if (instances.length === 0) {
+      logger.warn(`No instance found matching: ${options.instance}`);
+      return;
+    }
+
+    // Check and update status for running instances
+    for (const instance of instances) {
+      if (instance.status === 'running') {
+        const updated = await swarm.checkInstance(instance);
+        Object.assign(instance, updated);
+      }
+    }
+
+    // Save updated state
+    await saveState(state);
+
+    // Display status
+    for (const instance of instances) {
+      const shortId = instance.id.slice(0, 8);
+      const duration = instance.completedAt
+        ? formatDuration(new Date(instance.completedAt).getTime() - new Date(instance.startedAt).getTime())
+        : formatDuration(Date.now() - new Date(instance.startedAt).getTime());
+
+      logger.instance(instance.id, instance.status, `${instance.tasks.length} tasks`);
+      console.log(`           Repo: ${instance.source}`);
+      console.log(`           Duration: ${duration}`);
+      console.log(`           Sandbox: ${instance.sandboxId || 'N/A'}`);
+
+      if (instance.error) {
+        console.log(`           Error: ${instance.error}`);
+      }
+
+      console.log();
+    }
+
+    // Summary
+    const summary = {
+      total: instances.length,
+      starting: instances.filter(i => ['starting', 'cloning', 'setting-up'].includes(i.status)).length,
+      running: instances.filter(i => i.status === 'running').length,
+      completed: instances.filter(i => i.status === 'completed').length,
+      failed: instances.filter(i => i.status === 'failed').length,
+    };
+
+    logger.divider();
+    console.log(`Total: ${summary.total} | Running: ${summary.running} | Completed: ${summary.completed} | Failed: ${summary.failed}`);
+
+  } catch (error) {
+    logger.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+function formatDuration(ms: number): string {
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`;
+  }
+  return `${seconds}s`;
+}

package/skills/skill-e2bswarm/src/commands/sync.ts

@@ -0,0 +1,208 @@
+import { Sandbox } from 'e2b';
+import ora from 'ora';
+import { loadConfig, loadState, saveState } from '../lib/config';
+import { logger } from '../lib/logger';
+import {
+  setupGitHubAuth,
+  commitChanges,
+  pushChanges,
+  createBranch,
+  createPullRequest,
+  downloadChangedFiles,
+  getGitStatus,
+} from '../lib/github';
+import type { SyncOptions, SwarmInstance } from '../types';
+
+export async function sync(options: SyncOptions) {
+  const spinner = ora('Loading state...').start();
+
+  try {
+    const config = await loadConfig();
+    const state = await loadState();
+
+    if (state.instances.length === 0) {
+      spinner.fail('No instances found');
+      return;
+    }
+
+    // Filter instances
+    const instances = options.instance
+      ? state.instances.filter(i => i.id.startsWith(options.instance!))
+      : state.instances.filter(i =>
+          i.status === 'completed' ||
+          i.status === 'running' ||
+          i.status === 'committing' ||
+          i.status === 'pushing'
+        );
+
+    if (instances.length === 0) {
+      spinner.fail('No instances to sync');
+      logger.info('Use `skill-e2bswarm status` to check instance status');
+      return;
+    }
+
+    spinner.succeed(`Found ${instances.length} instances to sync`);
+
+    for (const instance of instances) {
+      await syncInstance(instance, config, options);
+    }
+
+    // Save updated state
+    await saveState(state);
+
+    logger.header('Sync Complete');
+
+    // Summary
+    const committed = instances.filter(i => i.committed).length;
+    const pushed = instances.filter(i => i.pushed).length;
+    const prs = instances.filter(i => i.prUrl).length;
+
+    if (committed > 0) logger.info(`Committed: ${committed} instances`);
+    if (pushed > 0) logger.info(`Pushed: ${pushed} instances`);
+    if (prs > 0) {
+      logger.info(`PRs created: ${prs}`);
+      for (const instance of instances) {
+        if (instance.prUrl) {
+          logger.success(`  ${instance.prUrl}`);
+        }
+      }
+    }
+
+  } catch (error) {
+    spinner.fail('Failed');
+    logger.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+async function syncInstance(
+  instance: SwarmInstance,
+  config: { apiKey: string; template: string; timeout: number; maxInstances: number },
+  options: SyncOptions
+): Promise<void> {
+  const shortId = instance.id.slice(0, 8);
+
+  if (!instance.sandboxId) {
+    logger.warn(`[${shortId}] No sandbox ID, skipping`);
+    return;
+  }
+
+  if (instance.sourceType !== 'repo') {
+    logger.warn(`[${shortId}] Not a repo source, skipping GitHub sync`);
+    return;
+  }
+
+  try {
+    const sandbox = await Sandbox.connect(instance.sandboxId, {
+      apiKey: config.apiKey,
+    });
+
+    // Setup GitHub auth
+    await setupGitHubAuth(sandbox);
+
+    // Get git status
+    const gitStatus = await getGitStatus(sandbox);
+    logger.instance(instance.id, 'syncing', `Branch: ${gitStatus.branch}`);
+
+    const hasChanges =
+      gitStatus.modified.length > 0 ||
+      gitStatus.added.length > 0 ||
+      gitStatus.deleted.length > 0;
+
+    if (!hasChanges) {
+      logger.instance(instance.id, 'syncing', 'No changes to sync');
+      return;
+    }
+
+    logger.instance(instance.id, 'syncing',
+      `Changes: ${gitStatus.modified.length} modified, ${gitStatus.added.length} added, ${gitStatus.deleted.length} deleted`
+    );
+
+    // Download changed files to local export dir
+    const downloadedFiles = await downloadChangedFiles(sandbox, instance);
+    if (downloadedFiles.length > 0) {
+      logger.instance(instance.id, 'syncing', `Downloaded ${downloadedFiles.length} files to ${instance.exportDir}/changes`);
+    }
+
+    // Create new branch if specified
+    if (instance.newBranch && gitStatus.branch !== instance.newBranch) {
+      const branchResult = await createBranch(sandbox, instance.newBranch);
+      if (!branchResult.success) {
+        logger.error(`[${shortId}] ${branchResult.error}`);
+        return;
+      }
+      logger.instance(instance.id, 'syncing', `Created branch: ${instance.newBranch}`);
+    }
+
+    // Commit if requested
+    if (options.commit !== false && (options.commit || instance.autoCommit)) {
+      instance.status = 'committing';
+      const commitMessage = options.message ||
+        `chore: automated changes from e2b-swarm\n\nInstance: ${instance.id}\nTasks completed: ${instance.tasks.filter(t => t.status === 'completed').length}/${instance.tasks.length}`;
+
+      const commitResult = await commitChanges(sandbox, commitMessage);
+      if (!commitResult.success) {
+        logger.error(`[${shortId}] ${commitResult.error}`);
+        return;
+      }
+      instance.committed = true;
+      logger.instance(instance.id, 'committing', 'Changes committed');
+    }
+
+    // Push if requested
+    if (options.push !== false && (options.push || instance.autoPush)) {
+      instance.status = 'pushing';
+      const pushResult = await pushChanges(sandbox, instance.newBranch);
+      if (!pushResult.success) {
+        logger.error(`[${shortId}] ${pushResult.error}`);
+        return;
+      }
+      instance.pushed = true;
+      logger.instance(instance.id, 'pushing', 'Changes pushed');
+    }
+
+    // Create PR if requested
+    if (options.createPr || instance.createPr) {
+      instance.status = 'creating-pr';
+      const prTitle = options.prTitle || instance.prTitle ||
+        `[E2B Swarm] Automated changes - ${shortId}`;
+
+      const prBody = `## Automated Changes
+
+This PR was created by E2B Swarm.
+
+**Instance ID:** ${instance.id}
+**Tasks completed:** ${instance.tasks.filter(t => t.status === 'completed').length}/${instance.tasks.length}
+
+### Tasks
+
+${instance.tasks.map(t => `- [${t.status === 'completed' ? 'x' : ' '}] ${t.subject}`).join('\n')}
+
+---
+🤖 Generated by skill-e2bswarm
+`;
+
+      const prResult = await createPullRequest(sandbox, {
+        title: prTitle,
+        body: prBody,
+        base: options.prBase || instance.prBase,
+        draft: false,
+      });
+
+      if (!prResult.success) {
+        logger.error(`[${shortId}] ${prResult.error}`);
+        return;
+      }
+
+      instance.prUrl = prResult.prUrl;
+      logger.instance(instance.id, 'creating-pr', `PR created: ${prResult.prUrl}`);
+    }
+
+    instance.status = 'completed';
+
+  } catch (error) {
+    logger.error(`[${shortId}] Failed: ${error instanceof Error ? error.message : error}`);
+    instance.status = 'failed';
+    instance.error = error instanceof Error ? error.message : String(error);
+  }
+}

package/skills/skill-e2bswarm/src/index.ts

@@ -0,0 +1,121 @@
+#!/usr/bin/env bun
+import { Command } from 'commander';
+import { spawn } from './commands/spawn';
+import { status } from './commands/status';
+import { kill } from './commands/kill';
+import { collect } from './commands/collect';
+import { sync } from './commands/sync';
+import { install } from './commands/install';
+import { paths } from './lib/paths';
+
+const program = new Command();
+
+program
+  .name('skill-e2bswarm')
+  .description('Spawn E2B sandbox instances for parallel Claude Code task execution')
+  .version('0.4.0');
+
+program
+  .command('spawn')
+  .description('Spawn E2B instances with tasks')
+  .option('-r, --repo <url>', 'Git repository URL to clone')
+  .option('-l, --local <path>', 'Local directory to upload (alternative to --repo)')
+  .option('-t, --tasks <id>', 'Task list ID from ~/.claude/tasks/')
+  .option('--tasks-dir <dir>', 'Load tasks from a local directory')
+  .option('--tasks-file <file>', 'Load tasks from a JSON file')
+  .option('--tasks-json <json>', 'Inline JSON array of tasks')
+  .option('-n, --instances <count>', 'Number of parallel instances', '1')
+  .option('-p, --prompt <text>', 'Additional prompt/instructions for Claude')
+  .option('-b, --branch <name>', 'Git branch to clone (only with --repo)')
+  .option('--new-branch <name>', 'Create and switch to new branch before making changes')
+  .option('--template <name>', 'E2B template to use', 'hasnaxyz-codebox')
+  .option('-d, --distribute <mode>', 'Task distribution: all, round-robin, by-dependency', 'all')
+  .option('--include <patterns...>', 'Include only these patterns (for --local)')
+  .option('--exclude <patterns...>', 'Exclude these patterns (for --local)')
+  // GitHub integration options
+  .option('--auto-commit', 'Automatically commit changes when tasks complete')
+  .option('--auto-push', 'Automatically push changes (requires --auto-commit)')
+  .option('--create-pr', 'Create a pull request after pushing')
+  .option('--pr-title <title>', 'Pull request title')
+  .option('--pr-base <branch>', 'Base branch for pull request (default: main)')
+  .action(spawn);
+
+program
+  .command('status')
+  .description('Check instance status')
+  .option('-i, --instance <id>', 'Specific instance ID (prefix match)')
+  .option('-w, --watch', 'Watch for status changes')
+  .action(status);
+
+program
+  .command('collect')
+  .description('Collect results from instances')
+  .option('-o, --output <dir>', 'Output directory (default: ~/.skills/skill-e2bswarm/exports/<timestamp>)')
+  .option('-i, --instance <id>', 'Specific instance ID (prefix match)')
+  .action(collect);
+
+program
+  .command('kill')
+  .description('Kill running instances')
+  .option('-i, --instance <id>', 'Specific instance ID (kills all if not specified)')
+  .action(kill);
+
+program
+  .command('sync')
+  .description('Sync changes back to GitHub (commit, push, create PR)')
+  .option('-i, --instance <id>', 'Specific instance ID (prefix match)')
+  .option('--commit', 'Commit changes')
+  .option('--no-commit', 'Skip committing')
+  .option('--push', 'Push changes to remote')
+  .option('--no-push', 'Skip pushing')
+  .option('--create-pr', 'Create a pull request')
+  .option('--pr-title <title>', 'Pull request title')
+  .option('--pr-base <branch>', 'Base branch for pull request')
+  .option('-m, --message <msg>', 'Commit message')
+  .action(sync);
+
+program
+  .command('clean')
+  .description('Clean up state file (remove old/completed instances)')
+  .action(async () => {
+    const { loadState, saveState } = await import('./lib/config');
+    const { logger } = await import('./lib/logger');
+
+    const state = await loadState();
+    const before = state.instances.length;
+
+    // Remove completed and failed instances older than 24 hours
+    const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+    state.instances = state.instances.filter(i => {
+      if (i.status === 'running' || i.status === 'starting') return true;
+      const completedAt = i.completedAt ? new Date(i.completedAt).getTime() : 0;
+      return completedAt > cutoff;
+    });
+
+    await saveState(state);
+    logger.success(`Cleaned up ${before - state.instances.length} old instances`);
+  });
+
+program
+  .command('info')
+  .description('Show skill data directory paths')
+  .action(() => {
+    console.log('Skill Data Directory Structure:');
+    console.log();
+    console.log(`  Root:     ${paths.skillData}`);
+    console.log(`  Exports:  ${paths.exports}`);
+    console.log(`  Logs:     ${paths.logs}`);
+    console.log(`  Cache:    ${paths.cache}`);
+    console.log(`  Config:   ${paths.config}`);
+    console.log(`  State:    ${paths.state}`);
+  });
+
+program
+  .command('install')
+  .description('Install this skill to Claude Code or Codex')
+  .option('--claude', 'Install to Claude Code (~/.claude/skills/)')
+  .option('--codex', 'Install to OpenAI Codex (~/.codex/skills/)')
+  .option('--local', 'Install to local repo (.claude/skills/ or .codex/skills/)')
+  .action(install);
+
+program.parse();

package/skills/skill-e2bswarm/src/lib/config.ts

@@ -0,0 +1,78 @@
+import type { SwarmConfig, SwarmState } from '../types';
+import { paths, ensureSkillDirs } from './paths';
+
+const SECRETS_FILE = `${process.env.HOME}/.secrets`;
+
+// Default E2B template (with Claude Code pre-installed)
+const DEFAULT_TEMPLATE = 'hasnaxyz-codebox';
+
+export async function loadConfig(template?: string): Promise<SwarmConfig> {
+  // Ensure skill directories exist
+  await ensureSkillDirs();
+
+  // Try to load E2B_API_KEY from environment or ~/.secrets
+  let apiKey = process.env.E2B_API_KEY;
+
+  if (!apiKey) {
+    try {
+      const secrets = await Bun.file(SECRETS_FILE).text();
+      const match = secrets.match(/E2B_API_KEY=["']?([^"'\n]+)["']?/);
+      if (match) {
+        apiKey = match[1];
+      }
+    } catch {
+      // ~/.secrets doesn't exist
+    }
+  }
+
+  if (!apiKey) {
+    throw new Error(
+      'E2B_API_KEY not found. Add it to ~/.secrets:\n' +
+      '  export E2B_API_KEY="your-api-key"\n\n' +
+      'Get your API key at: https://e2b.dev/dashboard'
+    );
+  }
+
+  return {
+    apiKey,
+    template: template || DEFAULT_TEMPLATE,
+    timeout: 30 * 60 * 1000, // 30 minutes
+    maxInstances: 10,
+  };
+}
+
+export async function loadState(): Promise<SwarmState> {
+  try {
+    const content = await Bun.file(paths.state).text();
+    return JSON.parse(content);
+  } catch {
+    return {
+      instances: [],
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+  }
+}
+
+export async function saveState(state: SwarmState): Promise<void> {
+  state.updatedAt = new Date().toISOString();
+  await Bun.write(paths.state, JSON.stringify(state, null, 2));
+}
+
+export function getStateFilePath(): string {
+  return paths.state;
+}
+
+/**
+ * List available E2B templates
+ * See: https://e2b.dev/docs/sandbox/templates
+ */
+export const E2B_TEMPLATES = {
+  // Custom templates
+  'hasnaxyz-codebox': 'Ubuntu sandbox with Claude Code, Bun, Node.js, and gh CLI pre-installed',
+
+  // Base templates
+  base: 'Default E2B Ubuntu sandbox (no Claude Code)',
+} as const;
+
+export type E2BTemplate = keyof typeof E2B_TEMPLATES | string;