spectrawl 0.1.0

package/src/act/adapters/ih.js

@@ -0,0 +1,251 @@
+const { smartFill } = require('../form-filler')
+
+/**
+ * IndieHackers platform adapter.
+ * Browser-only — no API available. Uses Playwright page automation.
+ * 
+ * IH is an Ember.js app. Key patterns:
+ * - IDs are dynamic (ember48, ember49, etc.)
+ * - Must use class/placeholder selectors instead
+ * - New post page: /new-post (requires auth)
+ * - Groups: selected via dropdown before posting
+ * - Editor: contentEditable div (Ember component)
+ */
+class IHAdapter {
+  constructor() {
+    this.baseUrl = 'https://www.indiehackers.com'
+    // Timeouts for various operations
+    this.navTimeout = 30000
+    this.actionTimeout = 10000
+  }
+
+  async execute(action, params, ctx) {
+    switch (action) {
+      case 'post':
+        return this._post(params, ctx)
+      case 'comment':
+        return this._comment(params, ctx)
+      case 'upvote':
+        return this._upvote(params, ctx)
+      default:
+        throw new Error(`Unsupported IH action: ${action}`)
+    }
+  }
+
+  /**
+   * Create a new post on IndieHackers.
+   * @param {object} params - { title, body, group?, account, _cookies }
+   */
+  async _post(params, ctx) {
+    const { title, body, group, account, _cookies } = params
+
+    if (!_cookies) {
+      throw new Error(`No auth for IH/${account}. Run: spectrawl login ih --account ${account}`)
+    }
+    if (!title) throw new Error('IH post requires a title')
+    if (!body) throw new Error('IH post requires a body')
+
+    // Get a raw page from the browse engine
+    const { page, context } = await ctx.browse.getPage({
+      _cookies,
+      url: `${this.baseUrl}/new-post`
+    })
+
+    try {
+      // Check if we got redirected to sign-in (cookies expired)
+      if (page.url().includes('/sign-in')) {
+        throw new Error(`IH cookies expired for ${account}. Re-authenticate with: spectrawl login ih --account ${account}`)
+      }
+
+      // Wait for the post form to load
+      await page.waitForTimeout(2000)
+
+      // Select group if specified
+      if (group) {
+        await this._selectGroup(page, group)
+      }
+
+      // Fill title — IH uses an input with specific class
+      const titleSelector = 'input[placeholder*="title" i], input[placeholder*="Title" i], .post-form__title input, input.ember-text-field[type="text"]'
+      await page.waitForSelector(titleSelector, { timeout: this.actionTimeout })
+      await smartFill(page, titleSelector, title)
+      await page.waitForTimeout(300 + Math.random() * 500)
+
+      // Fill body — IH uses contentEditable div for the editor
+      const bodySelector = '[contenteditable="true"], .post-form__body [contenteditable], .ember-view[contenteditable], .ProseMirror, .ql-editor, textarea.ember-text-area'
+      await page.waitForSelector(bodySelector, { timeout: this.actionTimeout })
+      await smartFill(page, bodySelector, body)
+      await page.waitForTimeout(500 + Math.random() * 1000)
+
+      // Click submit/publish button
+      const submitSelector = 'button:has-text("Publish"), button:has-text("Post"), button:has-text("Submit"), button[type="submit"]'
+      await page.waitForSelector(submitSelector, { timeout: this.actionTimeout })
+      
+      // Human-like pause before clicking submit
+      await page.waitForTimeout(1000 + Math.random() * 2000)
+      await page.click(submitSelector)
+
+      // Wait for navigation (post created → redirects to post page)
+      await page.waitForTimeout(3000)
+
+      // Verify we're on a post page
+      const finalUrl = page.url()
+      const postCreated = finalUrl.includes('/post/') || finalUrl.includes('/product/')
+
+      if (!postCreated) {
+        // Check for error messages
+        const errorText = await page.evaluate(() => {
+          const err = document.querySelector('.error, .alert, .flash-message, [class*="error"]')
+          return err ? err.innerText : null
+        })
+        
+        if (errorText) {
+          throw new Error(`IH post failed: ${errorText}`)
+        }
+
+        // Might still be processing
+        await page.waitForTimeout(3000)
+        const retryUrl = page.url()
+        if (!retryUrl.includes('/post/') && !retryUrl.includes('/product/')) {
+          throw new Error(`IH post may have failed. Final URL: ${retryUrl}`)
+        }
+      }
+
+      return {
+        url: page.url(),
+        title: await page.title(),
+        platform: 'ih'
+      }
+    } finally {
+      await page.close()
+      await context.close()
+    }
+  }
+
+  /**
+   * Comment on an IH post.
+   * @param {object} params - { postUrl, text, account, _cookies }
+   */
+  async _comment(params, ctx) {
+    const { postUrl, text, account, _cookies } = params
+
+    if (!_cookies) {
+      throw new Error(`No auth for IH/${account}. Run: spectrawl login ih --account ${account}`)
+    }
+    if (!postUrl) throw new Error('IH comment requires postUrl')
+    if (!text) throw new Error('IH comment requires text')
+
+    const { page, context } = await ctx.browse.getPage({
+      _cookies,
+      url: postUrl
+    })
+
+    try {
+      if (page.url().includes('/sign-in')) {
+        throw new Error(`IH cookies expired for ${account}. Re-authenticate.`)
+      }
+
+      await page.waitForTimeout(2000)
+
+      // Find and click the comment input area
+      const commentSelector = '[contenteditable="true"], textarea[placeholder*="comment" i], textarea[placeholder*="reply" i], .comment-form [contenteditable], .ProseMirror, .ql-editor'
+      
+      // Scroll to comment area first
+      await page.evaluate(() => {
+        const commentArea = document.querySelector('[contenteditable="true"], textarea[placeholder*="comment" i]')
+        if (commentArea) commentArea.scrollIntoView({ behavior: 'smooth', block: 'center' })
+      })
+      await page.waitForTimeout(1000)
+
+      await page.waitForSelector(commentSelector, { timeout: this.actionTimeout })
+      await smartFill(page, commentSelector, text)
+      await page.waitForTimeout(500 + Math.random() * 1000)
+
+      // Submit comment
+      const submitSelector = 'button:has-text("Reply"), button:has-text("Comment"), button:has-text("Submit"), button:has-text("Post")'
+      await page.click(submitSelector)
+      await page.waitForTimeout(3000)
+
+      return {
+        url: postUrl,
+        commented: true,
+        platform: 'ih'
+      }
+    } finally {
+      await page.close()
+      await context.close()
+    }
+  }
+
+  /**
+   * Upvote an IH post.
+   */
+  async _upvote(params, ctx) {
+    const { postUrl, account, _cookies } = params
+
+    if (!_cookies) {
+      throw new Error(`No auth for IH/${account}. Run: spectrawl login ih --account ${account}`)
+    }
+
+    const { page, context } = await ctx.browse.getPage({
+      _cookies,
+      url: postUrl
+    })
+
+    try {
+      if (page.url().includes('/sign-in')) {
+        throw new Error(`IH cookies expired for ${account}. Re-authenticate.`)
+      }
+
+      await page.waitForTimeout(2000)
+
+      // Find upvote button
+      const upvoteSelector = 'button[class*="upvote"], .upvote-button, [data-test*="upvote"], button:has-text("upvote")'
+      await page.waitForSelector(upvoteSelector, { timeout: this.actionTimeout })
+      await page.click(upvoteSelector)
+      await page.waitForTimeout(1000)
+
+      return {
+        url: postUrl,
+        upvoted: true,
+        platform: 'ih'
+      }
+    } finally {
+      await page.close()
+      await context.close()
+    }
+  }
+
+  /**
+   * Select a group/community from the dropdown.
+   */
+  async _selectGroup(page, group) {
+    // IH group selector varies — try common patterns
+    const groupSelector = 'select[class*="group"], .group-selector, [data-test*="group"], button:has-text("Select a group")'
+    
+    try {
+      await page.waitForSelector(groupSelector, { timeout: 5000 })
+      
+      // If it's a select element
+      const isSelect = await page.evaluate((sel) => {
+        const el = document.querySelector(sel)
+        return el?.tagName === 'SELECT'
+      }, groupSelector)
+
+      if (isSelect) {
+        await page.selectOption(groupSelector, { label: group })
+      } else {
+        // Click to open dropdown, then find the option
+        await page.click(groupSelector)
+        await page.waitForTimeout(500)
+        await page.click(`text="${group}"`)
+      }
+      
+      await page.waitForTimeout(500)
+    } catch (e) {
+      console.log(`Could not select group "${group}": ${e.message}. Posting without group.`)
+    }
+  }
+}
+
+module.exports = { IHAdapter }

package/src/act/adapters/linkedin.js

@@ -0,0 +1,106 @@
+const https = require('https')
+
+/**
+ * LinkedIn platform adapter.
+ * Uses Cookie API — LinkedIn has aggressive bot detection.
+ * OAuth available but requires LinkedIn app approval (hard to get).
+ */
+class LinkedInAdapter {
+  async execute(action, params, ctx) {
+    switch (action) {
+      case 'post':
+        return this._post(params, ctx)
+      default:
+        throw new Error(`Unsupported LinkedIn action: ${action}`)
+    }
+  }
+
+  async _post(params, ctx) {
+    const { text, account, _cookies } = params
+
+    if (!_cookies) {
+      throw new Error(`No auth for LinkedIn/${account}. Run: spectrawl login linkedin --account ${account}`)
+    }
+
+    const csrfToken = _cookies.find(c => c.name === 'JSESSIONID')?.value?.replace(/"/g, '')
+    if (!csrfToken) throw new Error('Missing JSESSIONID in LinkedIn cookies')
+
+    const cookieStr = _cookies.map(c => `${c.name}=${c.value}`).join('; ')
+
+    // Get member URN first
+    const me = await fetchJson('https://www.linkedin.com/voyager/api/me', {
+      'Cookie': cookieStr,
+      'Csrf-Token': csrfToken
+    })
+
+    const memberUrn = me.miniProfile?.entityUrn || me.entityUrn
+    if (!memberUrn) throw new Error('Could not get LinkedIn member URN')
+
+    // Create post via Voyager API
+    const body = JSON.stringify({
+      visibleToConnectionsOnly: false,
+      externalAudienceProviders: [],
+      commentaryV2: { text, attributes: [] },
+      origin: 'FEED',
+      allowedCommentersScope: 'ALL',
+      media: []
+    })
+
+    const data = await postJson(
+      'https://www.linkedin.com/voyager/api/contentcreation/normalizedContent',
+      body,
+      {
+        'Cookie': cookieStr,
+        'Csrf-Token': csrfToken,
+        'Content-Type': 'application/json',
+        'X-Li-Lang': 'en_US',
+        'X-Restli-Protocol-Version': '2.0.0'
+      }
+    )
+
+    return { postId: data.urn || data.value?.urn, url: null }
+  }
+}
+
+function fetchJson(url, headers) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url)
+    https.get({
+      hostname: urlObj.hostname,
+      path: urlObj.pathname + urlObj.search,
+      headers: { ...headers, 'User-Agent': 'Mozilla/5.0' }
+    }, res => {
+      let data = ''
+      res.on('data', c => data += c)
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)) }
+        catch (e) { reject(new Error('Invalid LinkedIn response')) }
+      })
+    }).on('error', reject)
+  })
+}
+
+function postJson(url, body, headers) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url)
+    const opts = {
+      hostname: urlObj.hostname,
+      path: urlObj.pathname,
+      method: 'POST',
+      headers: { ...headers, 'Content-Length': Buffer.byteLength(body) }
+    }
+    const req = https.request(opts, res => {
+      let data = ''
+      res.on('data', c => data += c)
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)) }
+        catch (e) { reject(new Error('Invalid LinkedIn response')) }
+      })
+    })
+    req.on('error', reject)
+    req.write(body)
+    req.end()
+  })
+}
+
+module.exports = { LinkedInAdapter }

package/src/act/adapters/reddit.js

@@ -0,0 +1,160 @@
+const https = require('https')
+
+/**
+ * Reddit platform adapter.
+ * Method: Cookie API via OAuth endpoint.
+ * Key insight: Reddit blocks datacenter IPs on web frontend
+ * but NOT on oauth.reddit.com API.
+ */
+class RedditAdapter {
+  async execute(action, params, ctx) {
+    switch (action) {
+      case 'post':
+        return this._post(params, ctx)
+      case 'comment':
+        return this._comment(params, ctx)
+      case 'delete':
+        return this._delete(params, ctx)
+      default:
+        throw new Error(`Unsupported Reddit action: ${action}`)
+    }
+  }
+
+  async _post(params, ctx) {
+    const { account, subreddit, title, body: text, url: linkUrl, _cookies } = params
+    
+    const token = await this._getToken(_cookies)
+    
+    const formData = new URLSearchParams()
+    formData.append('sr', subreddit)
+    formData.append('title', title)
+    formData.append('api_type', 'json')
+    
+    if (linkUrl) {
+      formData.append('kind', 'link')
+      formData.append('url', linkUrl)
+    } else {
+      formData.append('kind', 'self')
+      formData.append('text', text || '')
+    }
+
+    const data = await postOAuth('https://oauth.reddit.com/api/submit', formData.toString(), token)
+    
+    if (data.json?.errors?.length > 0) {
+      throw new Error(`Reddit error: ${JSON.stringify(data.json.errors)}`)
+    }
+
+    const postUrl = data.json?.data?.url
+    const postId = data.json?.data?.name
+    return { postId, url: postUrl }
+  }
+
+  async _comment(params, ctx) {
+    const { postId, text, _cookies } = params
+    
+    const token = await this._getToken(_cookies)
+    
+    const formData = new URLSearchParams()
+    formData.append('thing_id', postId)
+    formData.append('text', text)
+    formData.append('api_type', 'json')
+
+    const data = await postOAuth('https://oauth.reddit.com/api/comment', formData.toString(), token)
+    
+    if (data.json?.errors?.length > 0) {
+      throw new Error(`Reddit error: ${JSON.stringify(data.json.errors)}`)
+    }
+
+    const commentId = data.json?.data?.things?.[0]?.data?.name
+    return { commentId }
+  }
+
+  async _delete(params, ctx) {
+    const { thingId, _cookies } = params
+    
+    const token = await this._getToken(_cookies)
+    
+    const formData = new URLSearchParams()
+    formData.append('id', thingId)
+
+    await postOAuth('https://oauth.reddit.com/api/del', formData.toString(), token)
+    return { deleted: thingId }
+  }
+
+  /**
+   * Extract Bearer token from Reddit cookies.
+   * Flow: cookies → hit reddit.com → get token_v2 JWT → use as Bearer
+   */
+  async _getToken(cookies) {
+    if (!cookies) throw new Error('No Reddit cookies available')
+    
+    // Look for token_v2 in cookies
+    const tokenCookie = cookies.find(c => c.name === 'token_v2')
+    if (tokenCookie) return tokenCookie.value
+
+    // Look for reddit_session
+    const sessionCookie = cookies.find(c => c.name === 'reddit_session')
+    if (sessionCookie) {
+      // Need to exchange session cookie for token
+      // Hit reddit.com with cookies to get fresh token_v2
+      const cookieStr = cookies.map(c => `${c.name}=${c.value}`).join('; ')
+      const html = await fetchWithCookies('https://www.reddit.com/', cookieStr)
+      
+      // Extract access token from page
+      const tokenMatch = html.match(/"accessToken":"([^"]+)"/)
+      if (tokenMatch) return tokenMatch[1]
+    }
+
+    throw new Error('Could not extract Reddit auth token from cookies')
+  }
+}
+
+function postOAuth(url, body, token) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url)
+    const opts = {
+      hostname: urlObj.hostname,
+      path: urlObj.pathname,
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'User-Agent': 'Spectrawl/0.1.0',
+        'Content-Length': Buffer.byteLength(body)
+      }
+    }
+
+    const req = https.request(opts, res => {
+      let data = ''
+      res.on('data', c => data += c)
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)) }
+        catch (e) { reject(new Error(`Invalid Reddit response: ${data.slice(0, 200)}`)) }
+      })
+    })
+    req.on('error', reject)
+    req.setTimeout(15000, () => { req.destroy(); reject(new Error('Reddit API timeout')) })
+    req.write(body)
+    req.end()
+  })
+}
+
+function fetchWithCookies(url, cookieStr) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url)
+    https.get({
+      hostname: urlObj.hostname,
+      path: urlObj.pathname,
+      headers: {
+        'Cookie': cookieStr,
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+      }
+    }, res => {
+      let data = ''
+      res.on('data', c => data += c)
+      res.on('end', () => resolve(data))
+    }).on('error', reject)
+  })
+}
+
+module.exports = { RedditAdapter }