@openparachute/agent 0.1.0

package/.claude/skills/x-integration/host.ts

@@ -0,0 +1,155 @@
+/**
+ * X Integration IPC Handler
+ *
+ * Handles all x_* IPC messages from container agents.
+ * This is the entry point for X integration in the host process.
+ */
+
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+import { logger } from '../../../src/logger.js';
+
+interface SkillResult {
+  success: boolean;
+  message: string;
+  data?: unknown;
+}
+
+// Run a skill script as subprocess
+async function runScript(script: string, args: object): Promise<SkillResult> {
+  const scriptPath = path.join(process.cwd(), '.claude', 'skills', 'x-integration', 'scripts', `${script}.ts`);
+
+  return new Promise((resolve) => {
+    const proc = spawn('pnpm', ['exec', 'tsx', scriptPath], {
+      cwd: process.cwd(),
+      env: { ...process.env, NANOCLAW_ROOT: process.cwd() },
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    let stdout = '';
+    proc.stdout.on('data', (data) => { stdout += data.toString(); });
+    proc.stdin.write(JSON.stringify(args));
+    proc.stdin.end();
+
+    const timer = setTimeout(() => {
+      proc.kill('SIGTERM');
+      resolve({ success: false, message: 'Script timed out (120s)' });
+    }, 120000);
+
+    proc.on('close', (code) => {
+      clearTimeout(timer);
+      if (code !== 0) {
+        resolve({ success: false, message: `Script exited with code: ${code}` });
+        return;
+      }
+      try {
+        const lines = stdout.trim().split('\n');
+        resolve(JSON.parse(lines[lines.length - 1]));
+      } catch {
+        resolve({ success: false, message: `Failed to parse output: ${stdout.slice(0, 200)}` });
+      }
+    });
+
+    proc.on('error', (err) => {
+      clearTimeout(timer);
+      resolve({ success: false, message: `Failed to spawn: ${err.message}` });
+    });
+  });
+}
+
+// Write result to IPC results directory
+function writeResult(dataDir: string, sourceGroup: string, requestId: string, result: SkillResult): void {
+  const resultsDir = path.join(dataDir, 'ipc', sourceGroup, 'x_results');
+  fs.mkdirSync(resultsDir, { recursive: true });
+  fs.writeFileSync(path.join(resultsDir, `${requestId}.json`), JSON.stringify(result));
+}
+
+/**
+ * Handle X integration IPC messages
+ *
+ * @returns true if message was handled, false if not an X message
+ */
+export async function handleXIpc(
+  data: Record<string, unknown>,
+  sourceGroup: string,
+  isMain: boolean,
+  dataDir: string
+): Promise<boolean> {
+  const type = data.type as string;
+
+  // Only handle x_* types
+  if (!type?.startsWith('x_')) {
+    return false;
+  }
+
+  // Only main group can use X integration
+  if (!isMain) {
+    logger.warn({ sourceGroup, type }, 'X integration blocked: not main group');
+    return true;
+  }
+
+  const requestId = data.requestId as string;
+  if (!requestId) {
+    logger.warn({ type }, 'X integration blocked: missing requestId');
+    return true;
+  }
+
+  logger.info({ type, requestId }, 'Processing X request');
+
+  let result: SkillResult;
+
+  switch (type) {
+    case 'x_post':
+      if (!data.content) {
+        result = { success: false, message: 'Missing content' };
+        break;
+      }
+      result = await runScript('post', { content: data.content });
+      break;
+
+    case 'x_like':
+      if (!data.tweetUrl) {
+        result = { success: false, message: 'Missing tweetUrl' };
+        break;
+      }
+      result = await runScript('like', { tweetUrl: data.tweetUrl });
+      break;
+
+    case 'x_reply':
+      if (!data.tweetUrl || !data.content) {
+        result = { success: false, message: 'Missing tweetUrl or content' };
+        break;
+      }
+      result = await runScript('reply', { tweetUrl: data.tweetUrl, content: data.content });
+      break;
+
+    case 'x_retweet':
+      if (!data.tweetUrl) {
+        result = { success: false, message: 'Missing tweetUrl' };
+        break;
+      }
+      result = await runScript('retweet', { tweetUrl: data.tweetUrl });
+      break;
+
+    case 'x_quote':
+      if (!data.tweetUrl || !data.comment) {
+        result = { success: false, message: 'Missing tweetUrl or comment' };
+        break;
+      }
+      result = await runScript('quote', { tweetUrl: data.tweetUrl, comment: data.comment });
+      break;
+
+    default:
+      return false;
+  }
+
+  writeResult(dataDir, sourceGroup, requestId, result);
+  if (result.success) {
+    logger.info({ type, requestId }, 'X request completed');
+  } else {
+    logger.error({ type, requestId, message: result.message }, 'X request failed');
+  }
+  return true;
+}

package/.claude/skills/x-integration/lib/browser.ts

@@ -0,0 +1,148 @@
+/**
+ * X Integration - Shared utilities
+ * Used by all X scripts
+ */
+
+import { chromium, BrowserContext, Page } from 'playwright';
+import fs from 'fs';
+import path from 'path';
+import { config } from './config.js';
+
+export { config };
+
+export interface ScriptResult {
+  success: boolean;
+  message: string;
+  data?: unknown;
+}
+
+/**
+ * Read input from stdin
+ */
+export async function readInput<T>(): Promise<T> {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', chunk => { data += chunk; });
+    process.stdin.on('end', () => {
+      try {
+        resolve(JSON.parse(data));
+      } catch (err) {
+        reject(new Error(`Invalid JSON input: ${err}`));
+      }
+    });
+    process.stdin.on('error', reject);
+  });
+}
+
+/**
+ * Write result to stdout
+ */
+export function writeResult(result: ScriptResult): void {
+  console.log(JSON.stringify(result));
+}
+
+/**
+ * Clean up browser lock files
+ */
+export function cleanupLockFiles(): void {
+  for (const lockFile of ['SingletonLock', 'SingletonSocket', 'SingletonCookie']) {
+    const lockPath = path.join(config.browserDataDir, lockFile);
+    if (fs.existsSync(lockPath)) {
+      try { fs.unlinkSync(lockPath); } catch {}
+    }
+  }
+}
+
+/**
+ * Validate tweet/reply content
+ */
+export function validateContent(content: string | undefined, type = 'Tweet'): ScriptResult | null {
+  if (!content || content.length === 0) {
+    return { success: false, message: `${type} content cannot be empty` };
+  }
+  if (content.length > config.limits.tweetMaxLength) {
+    return { success: false, message: `${type} exceeds ${config.limits.tweetMaxLength} character limit (current: ${content.length})` };
+  }
+  return null; // Valid
+}
+
+/**
+ * Get browser context with persistent profile
+ */
+export async function getBrowserContext(): Promise<BrowserContext> {
+  if (!fs.existsSync(config.authPath)) {
+    throw new Error('X authentication not configured. Run /x-integration to complete login.');
+  }
+
+  cleanupLockFiles();
+
+  const context = await chromium.launchPersistentContext(config.browserDataDir, {
+    executablePath: config.chromePath,
+    headless: false,
+    viewport: config.viewport,
+    args: config.chromeArgs,
+    ignoreDefaultArgs: config.chromeIgnoreDefaultArgs,
+  });
+
+  return context;
+}
+
+/**
+ * Extract tweet ID from URL or raw ID
+ */
+export function extractTweetId(input: string): string | null {
+  const urlMatch = input.match(/(?:x\.com|twitter\.com)\/\w+\/status\/(\d+)/);
+  if (urlMatch) return urlMatch[1];
+  if (/^\d+$/.test(input.trim())) return input.trim();
+  return null;
+}
+
+/**
+ * Navigate to a tweet page
+ */
+export async function navigateToTweet(
+  context: BrowserContext,
+  tweetUrl: string
+): Promise<{ page: Page; success: boolean; error?: string }> {
+  const page = context.pages()[0] || await context.newPage();
+
+  let url = tweetUrl;
+  const tweetId = extractTweetId(tweetUrl);
+  if (tweetId && !tweetUrl.startsWith('http')) {
+    url = `https://x.com/i/status/${tweetId}`;
+  }
+
+  try {
+    await page.goto(url, { timeout: config.timeouts.navigation, waitUntil: 'domcontentloaded' });
+    await page.waitForTimeout(config.timeouts.pageLoad);
+
+    const exists = await page.locator('article[data-testid="tweet"]').first().isVisible().catch(() => false);
+    if (!exists) {
+      return { page, success: false, error: 'Tweet not found. It may have been deleted or the URL is invalid.' };
+    }
+
+    return { page, success: true };
+  } catch (err) {
+    return { page, success: false, error: `Navigation failed: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+
+/**
+ * Run script with error handling
+ */
+export async function runScript<T>(
+  handler: (input: T) => Promise<ScriptResult>
+): Promise<void> {
+  try {
+    const input = await readInput<T>();
+    const result = await handler(input);
+    writeResult(result);
+  } catch (err) {
+    writeResult({
+      success: false,
+      message: `Script execution failed: ${err instanceof Error ? err.message : String(err)}`
+    });
+    process.exit(1);
+  }
+}

package/.claude/skills/x-integration/lib/config.ts

@@ -0,0 +1,62 @@
+/**
+ * X Integration - Configuration
+ *
+ * All environment-specific settings in one place.
+ * Override via environment variables or modify defaults here.
+ */
+
+import path from 'path';
+
+// Project root - can be overridden for different deployments
+const PROJECT_ROOT = process.env.NANOCLAW_ROOT || process.cwd();
+
+/**
+ * Configuration object with all settings
+ */
+export const config = {
+  // Chrome executable path
+  // Default: standard macOS Chrome location
+  // Override: CHROME_PATH environment variable
+  chromePath: process.env.CHROME_PATH || '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+
+  // Browser profile directory for persistent login sessions
+  browserDataDir: path.join(PROJECT_ROOT, 'data', 'x-browser-profile'),
+
+  // Auth state marker file
+  authPath: path.join(PROJECT_ROOT, 'data', 'x-auth.json'),
+
+  // Browser viewport settings
+  viewport: {
+    width: 1280,
+    height: 800,
+  },
+
+  // Timeouts (in milliseconds)
+  timeouts: {
+    navigation: 30000,
+    elementWait: 5000,
+    afterClick: 1000,
+    afterFill: 1000,
+    afterSubmit: 3000,
+    pageLoad: 3000,
+  },
+
+  // X character limits
+  limits: {
+    tweetMaxLength: 280,
+  },
+
+  // Chrome launch arguments
+  chromeArgs: [
+    '--disable-blink-features=AutomationControlled',
+    '--no-sandbox',
+    '--disable-setuid-sandbox',
+    '--no-first-run',
+    '--no-default-browser-check',
+    '--disable-sync',
+  ],
+
+  // Args to ignore when launching Chrome
+  chromeIgnoreDefaultArgs: ['--enable-automation'],
+};
+

package/.claude/skills/x-integration/scripts/like.ts

@@ -0,0 +1,56 @@
+#!/usr/bin/env pnpm exec tsx
+/**
+ * X Integration - Like Tweet
+ * Usage: echo '{"tweetUrl":"https://x.com/user/status/123"}' | pnpm exec tsx like.ts
+ */
+
+import { getBrowserContext, navigateToTweet, runScript, config, ScriptResult } from '../lib/browser.js';
+
+interface LikeInput {
+  tweetUrl: string;
+}
+
+async function likeTweet(input: LikeInput): Promise<ScriptResult> {
+  const { tweetUrl } = input;
+
+  if (!tweetUrl) {
+    return { success: false, message: 'Please provide a tweet URL' };
+  }
+
+  let context = null;
+  try {
+    context = await getBrowserContext();
+    const { page, success, error } = await navigateToTweet(context, tweetUrl);
+
+    if (!success) {
+      return { success: false, message: error || 'Navigation failed' };
+    }
+
+    const tweet = page.locator('article[data-testid="tweet"]').first();
+    const unlikeButton = tweet.locator('[data-testid="unlike"]');
+    const likeButton = tweet.locator('[data-testid="like"]');
+
+    // Check if already liked
+    const alreadyLiked = await unlikeButton.isVisible().catch(() => false);
+    if (alreadyLiked) {
+      return { success: true, message: 'Tweet already liked' };
+    }
+
+    await likeButton.waitFor({ timeout: config.timeouts.elementWait });
+    await likeButton.click();
+    await page.waitForTimeout(config.timeouts.afterClick);
+
+    // Verify
+    const nowLiked = await unlikeButton.isVisible().catch(() => false);
+    if (nowLiked) {
+      return { success: true, message: 'Like successful' };
+    }
+
+    return { success: false, message: 'Like action completed but could not verify success' };
+
+  } finally {
+    if (context) await context.close();
+  }
+}
+
+runScript<LikeInput>(likeTweet);

package/.claude/skills/x-integration/scripts/post.ts

@@ -0,0 +1,66 @@
+#!/usr/bin/env pnpm exec tsx
+/**
+ * X Integration - Post Tweet
+ * Usage: echo '{"content":"Hello world"}' | pnpm exec tsx post.ts
+ */
+
+import { getBrowserContext, runScript, validateContent, config, ScriptResult } from '../lib/browser.js';
+
+interface PostInput {
+  content: string;
+}
+
+async function postTweet(input: PostInput): Promise<ScriptResult> {
+  const { content } = input;
+
+  const validationError = validateContent(content, 'Tweet');
+  if (validationError) return validationError;
+
+  let context = null;
+  try {
+    context = await getBrowserContext();
+    const page = context.pages()[0] || await context.newPage();
+
+    await page.goto('https://x.com/home', { timeout: config.timeouts.navigation, waitUntil: 'domcontentloaded' });
+    await page.waitForTimeout(config.timeouts.pageLoad);
+
+    // Check if logged in
+    const isLoggedIn = await page.locator('[data-testid="SideNav_AccountSwitcher_Button"]').isVisible().catch(() => false);
+    if (!isLoggedIn) {
+      const onLoginPage = await page.locator('input[autocomplete="username"]').isVisible().catch(() => false);
+      if (onLoginPage) {
+        return { success: false, message: 'X login expired. Run /x-integration to re-authenticate.' };
+      }
+    }
+
+    // Find and fill tweet input
+    const tweetInput = page.locator('[data-testid="tweetTextarea_0"]');
+    await tweetInput.waitFor({ timeout: config.timeouts.elementWait * 2 });
+    await tweetInput.click();
+    await page.waitForTimeout(config.timeouts.afterClick / 2);
+    await tweetInput.fill(content);
+    await page.waitForTimeout(config.timeouts.afterFill);
+
+    // Click post button
+    const postButton = page.locator('[data-testid="tweetButtonInline"]');
+    await postButton.waitFor({ timeout: config.timeouts.elementWait });
+
+    const isDisabled = await postButton.getAttribute('aria-disabled');
+    if (isDisabled === 'true') {
+      return { success: false, message: 'Post button disabled. Content may be empty or exceed character limit.' };
+    }
+
+    await postButton.click();
+    await page.waitForTimeout(config.timeouts.afterSubmit);
+
+    return {
+      success: true,
+      message: `Tweet posted: ${content.slice(0, 50)}${content.length > 50 ? '...' : ''}`
+    };
+
+  } finally {
+    if (context) await context.close();
+  }
+}
+
+runScript<PostInput>(postTweet);

package/.claude/skills/x-integration/scripts/quote.ts

@@ -0,0 +1,80 @@
+#!/usr/bin/env pnpm exec tsx
+/**
+ * X Integration - Quote Tweet
+ * Usage: echo '{"tweetUrl":"https://x.com/user/status/123","comment":"My thoughts"}' | pnpm exec tsx quote.ts
+ */
+
+import { getBrowserContext, navigateToTweet, runScript, validateContent, config, ScriptResult } from '../lib/browser.js';
+
+interface QuoteInput {
+  tweetUrl: string;
+  comment: string;
+}
+
+async function quoteTweet(input: QuoteInput): Promise<ScriptResult> {
+  const { tweetUrl, comment } = input;
+
+  if (!tweetUrl) {
+    return { success: false, message: 'Please provide a tweet URL' };
+  }
+
+  const validationError = validateContent(comment, 'Comment');
+  if (validationError) return validationError;
+
+  let context = null;
+  try {
+    context = await getBrowserContext();
+    const { page, success, error } = await navigateToTweet(context, tweetUrl);
+
+    if (!success) {
+      return { success: false, message: error || 'Navigation failed' };
+    }
+
+    // Click retweet button to open menu
+    const tweet = page.locator('article[data-testid="tweet"]').first();
+    const retweetButton = tweet.locator('[data-testid="retweet"]');
+    await retweetButton.waitFor({ timeout: config.timeouts.elementWait });
+    await retweetButton.click();
+    await page.waitForTimeout(config.timeouts.afterClick);
+
+    // Click quote option
+    const quoteOption = page.getByRole('menuitem').filter({ hasText: /Quote/i });
+    await quoteOption.waitFor({ timeout: config.timeouts.elementWait });
+    await quoteOption.click();
+    await page.waitForTimeout(config.timeouts.afterClick * 1.5);
+
+    // Find dialog with aria-modal="true"
+    const dialog = page.locator('[role="dialog"][aria-modal="true"]');
+    await dialog.waitFor({ timeout: config.timeouts.elementWait });
+
+    // Fill comment
+    const quoteInput = dialog.locator('[data-testid="tweetTextarea_0"]');
+    await quoteInput.waitFor({ timeout: config.timeouts.elementWait });
+    await quoteInput.click();
+    await page.waitForTimeout(config.timeouts.afterClick / 2);
+    await quoteInput.fill(comment);
+    await page.waitForTimeout(config.timeouts.afterFill);
+
+    // Click submit button
+    const submitButton = dialog.locator('[data-testid="tweetButton"]');
+    await submitButton.waitFor({ timeout: config.timeouts.elementWait });
+
+    const isDisabled = await submitButton.getAttribute('aria-disabled');
+    if (isDisabled === 'true') {
+      return { success: false, message: 'Submit button disabled. Content may be empty or exceed character limit.' };
+    }
+
+    await submitButton.click();
+    await page.waitForTimeout(config.timeouts.afterSubmit);
+
+    return {
+      success: true,
+      message: `Quote tweet posted: ${comment.slice(0, 50)}${comment.length > 50 ? '...' : ''}`
+    };
+
+  } finally {
+    if (context) await context.close();
+  }
+}
+
+runScript<QuoteInput>(quoteTweet);

package/.claude/skills/x-integration/scripts/reply.ts

@@ -0,0 +1,74 @@
+#!/usr/bin/env pnpm exec tsx
+/**
+ * X Integration - Reply to Tweet
+ * Usage: echo '{"tweetUrl":"https://x.com/user/status/123","content":"Great post!"}' | pnpm exec tsx reply.ts
+ */
+
+import { getBrowserContext, navigateToTweet, runScript, validateContent, config, ScriptResult } from '../lib/browser.js';
+
+interface ReplyInput {
+  tweetUrl: string;
+  content: string;
+}
+
+async function replyToTweet(input: ReplyInput): Promise<ScriptResult> {
+  const { tweetUrl, content } = input;
+
+  if (!tweetUrl) {
+    return { success: false, message: 'Please provide a tweet URL' };
+  }
+
+  const validationError = validateContent(content, 'Reply');
+  if (validationError) return validationError;
+
+  let context = null;
+  try {
+    context = await getBrowserContext();
+    const { page, success, error } = await navigateToTweet(context, tweetUrl);
+
+    if (!success) {
+      return { success: false, message: error || 'Navigation failed' };
+    }
+
+    // Click reply button
+    const tweet = page.locator('article[data-testid="tweet"]').first();
+    const replyButton = tweet.locator('[data-testid="reply"]');
+    await replyButton.waitFor({ timeout: config.timeouts.elementWait });
+    await replyButton.click();
+    await page.waitForTimeout(config.timeouts.afterClick * 1.5);
+
+    // Find dialog with aria-modal="true" to avoid matching other dialogs
+    const dialog = page.locator('[role="dialog"][aria-modal="true"]');
+    await dialog.waitFor({ timeout: config.timeouts.elementWait });
+
+    // Fill reply content
+    const replyInput = dialog.locator('[data-testid="tweetTextarea_0"]');
+    await replyInput.waitFor({ timeout: config.timeouts.elementWait });
+    await replyInput.click();
+    await page.waitForTimeout(config.timeouts.afterClick / 2);
+    await replyInput.fill(content);
+    await page.waitForTimeout(config.timeouts.afterFill);
+
+    // Click submit button
+    const submitButton = dialog.locator('[data-testid="tweetButton"]');
+    await submitButton.waitFor({ timeout: config.timeouts.elementWait });
+
+    const isDisabled = await submitButton.getAttribute('aria-disabled');
+    if (isDisabled === 'true') {
+      return { success: false, message: 'Submit button disabled. Content may be empty or exceed character limit.' };
+    }
+
+    await submitButton.click();
+    await page.waitForTimeout(config.timeouts.afterSubmit);
+
+    return {
+      success: true,
+      message: `Reply posted: ${content.slice(0, 50)}${content.length > 50 ? '...' : ''}`
+    };
+
+  } finally {
+    if (context) await context.close();
+  }
+}
+
+runScript<ReplyInput>(replyToTweet);