@rozek/nanoclaw 0.0.1

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

@@ -0,0 +1,243 @@
+/**
+ * X Integration - MCP Tool Definitions (Agent/Container Side)
+ *
+ * These tools run inside the container and communicate with the host via IPC.
+ * The host-side implementation is in host.ts.
+ *
+ * Note: This file is compiled in the container, not on the host.
+ * The @ts-ignore is needed because the SDK is only available in the container.
+ */
+
+// @ts-ignore - SDK available in container environment only
+import { tool } from '@anthropic-ai/claude-agent-sdk';
+import { z } from 'zod';
+import fs from 'fs';
+import path from 'path';
+
+// IPC directories (inside container)
+const IPC_DIR = '/workspace/ipc';
+const TASKS_DIR = path.join(IPC_DIR, 'tasks');
+const RESULTS_DIR = path.join(IPC_DIR, 'x_results');
+
+function writeIpcFile(dir: string, data: object): string {
+  fs.mkdirSync(dir, { recursive: true });
+  const filename = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}.json`;
+  const filepath = path.join(dir, filename);
+  const tempPath = `${filepath}.tmp`;
+  fs.writeFileSync(tempPath, JSON.stringify(data, null, 2));
+  fs.renameSync(tempPath, filepath);
+  return filename;
+}
+
+async function waitForResult(requestId: string, maxWait = 60000): Promise<{ success: boolean; message: string }> {
+  const resultFile = path.join(RESULTS_DIR, `${requestId}.json`);
+  const pollInterval = 1000;
+  let elapsed = 0;
+
+  while (elapsed < maxWait) {
+    if (fs.existsSync(resultFile)) {
+      try {
+        const result = JSON.parse(fs.readFileSync(resultFile, 'utf-8'));
+        fs.unlinkSync(resultFile);
+        return result;
+      } catch (err) {
+        return { success: false, message: `Failed to read result: ${err}` };
+      }
+    }
+    await new Promise(resolve => setTimeout(resolve, pollInterval));
+    elapsed += pollInterval;
+  }
+
+  return { success: false, message: 'Request timed out' };
+}
+
+export interface SkillToolsContext {
+  groupFolder: string;
+  isMain: boolean;
+}
+
+/**
+ * Create X integration MCP tools
+ */
+export function createXTools(ctx: SkillToolsContext) {
+  const { groupFolder, isMain } = ctx;
+
+  return [
+    tool(
+      'x_post',
+      `Post a tweet to X (Twitter). Main group only.
+
+The host machine will execute the browser automation to post the tweet.
+Make sure the content is appropriate and within X's character limit (280 chars for text).`,
+      {
+        content: z.string().max(280).describe('The tweet content to post (max 280 characters)')
+      },
+      async (args: { content: string }) => {
+        if (!isMain) {
+          return {
+            content: [{ type: 'text', text: 'Only the main group can post tweets.' }],
+            isError: true
+          };
+        }
+
+        if (args.content.length > 280) {
+          return {
+            content: [{ type: 'text', text: `Tweet exceeds 280 character limit (current: ${args.content.length})` }],
+            isError: true
+          };
+        }
+
+        const requestId = `xpost-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        writeIpcFile(TASKS_DIR, {
+          type: 'x_post',
+          requestId,
+          content: args.content,
+          groupFolder,
+          timestamp: new Date().toISOString()
+        });
+
+        const result = await waitForResult(requestId);
+        return {
+          content: [{ type: 'text', text: result.message }],
+          isError: !result.success
+        };
+      }
+    ),
+
+    tool(
+      'x_like',
+      `Like a tweet on X (Twitter). Main group only.
+
+Provide the tweet URL or tweet ID to like.`,
+      {
+        tweet_url: z.string().describe('The tweet URL (e.g., https://x.com/user/status/123) or tweet ID')
+      },
+      async (args: { tweet_url: string }) => {
+        if (!isMain) {
+          return {
+            content: [{ type: 'text', text: 'Only the main group can interact with X.' }],
+            isError: true
+          };
+        }
+
+        const requestId = `xlike-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        writeIpcFile(TASKS_DIR, {
+          type: 'x_like',
+          requestId,
+          tweetUrl: args.tweet_url,
+          groupFolder,
+          timestamp: new Date().toISOString()
+        });
+
+        const result = await waitForResult(requestId);
+        return {
+          content: [{ type: 'text', text: result.message }],
+          isError: !result.success
+        };
+      }
+    ),
+
+    tool(
+      'x_reply',
+      `Reply to a tweet on X (Twitter). Main group only.
+
+Provide the tweet URL and your reply content.`,
+      {
+        tweet_url: z.string().describe('The tweet URL (e.g., https://x.com/user/status/123) or tweet ID'),
+        content: z.string().max(280).describe('The reply content (max 280 characters)')
+      },
+      async (args: { tweet_url: string; content: string }) => {
+        if (!isMain) {
+          return {
+            content: [{ type: 'text', text: 'Only the main group can interact with X.' }],
+            isError: true
+          };
+        }
+
+        const requestId = `xreply-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        writeIpcFile(TASKS_DIR, {
+          type: 'x_reply',
+          requestId,
+          tweetUrl: args.tweet_url,
+          content: args.content,
+          groupFolder,
+          timestamp: new Date().toISOString()
+        });
+
+        const result = await waitForResult(requestId);
+        return {
+          content: [{ type: 'text', text: result.message }],
+          isError: !result.success
+        };
+      }
+    ),
+
+    tool(
+      'x_retweet',
+      `Retweet a tweet on X (Twitter). Main group only.
+
+Provide the tweet URL to retweet.`,
+      {
+        tweet_url: z.string().describe('The tweet URL (e.g., https://x.com/user/status/123) or tweet ID')
+      },
+      async (args: { tweet_url: string }) => {
+        if (!isMain) {
+          return {
+            content: [{ type: 'text', text: 'Only the main group can interact with X.' }],
+            isError: true
+          };
+        }
+
+        const requestId = `xretweet-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        writeIpcFile(TASKS_DIR, {
+          type: 'x_retweet',
+          requestId,
+          tweetUrl: args.tweet_url,
+          groupFolder,
+          timestamp: new Date().toISOString()
+        });
+
+        const result = await waitForResult(requestId);
+        return {
+          content: [{ type: 'text', text: result.message }],
+          isError: !result.success
+        };
+      }
+    ),
+
+    tool(
+      'x_quote',
+      `Quote tweet on X (Twitter). Main group only.
+
+Retweet with your own comment added.`,
+      {
+        tweet_url: z.string().describe('The tweet URL (e.g., https://x.com/user/status/123) or tweet ID'),
+        comment: z.string().max(280).describe('Your comment for the quote tweet (max 280 characters)')
+      },
+      async (args: { tweet_url: string; comment: string }) => {
+        if (!isMain) {
+          return {
+            content: [{ type: 'text', text: 'Only the main group can interact with X.' }],
+            isError: true
+          };
+        }
+
+        const requestId = `xquote-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        writeIpcFile(TASKS_DIR, {
+          type: 'x_quote',
+          requestId,
+          tweetUrl: args.tweet_url,
+          comment: args.comment,
+          groupFolder,
+          timestamp: new Date().toISOString()
+        });
+
+        const result = await waitForResult(requestId);
+        return {
+          content: [{ type: 'text', text: result.message }],
+          isError: !result.success
+        };
+      }
+    )
+  ];
+}

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

@@ -0,0 +1,159 @@
+/**
+ * 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 pino from 'pino';
+
+const logger = pino({
+  level: process.env.LOG_LEVEL || 'info',
+  transport: { target: 'pino-pretty', options: { colorize: true } }
+});
+
+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('npx', ['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 npx tsx
+/**
+ * X Integration - Like Tweet
+ * Usage: echo '{"tweetUrl":"https://x.com/user/status/123"}' | npx 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);