astro-claw 1.0.0

package/slack-setup.js

@@ -0,0 +1,499 @@
+/**
+ * Self-driving Slack app setup using Puppeteer + user's Chrome.
+ * Opens Chrome with the user's existing session (likely logged into Slack),
+ * creates the app from manifest, generates tokens, installs to workspace,
+ * and returns all credentials — user only clicks "Allow" once.
+ */
+
+import puppeteer from "puppeteer-core";
+import { readFileSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+import { homedir } from "node:os";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const MANIFEST_PATH = resolve(__dirname, "slack-manifest.json");
+
+// ─── Terminal Colors ────────────────────────────────────────────────
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const CHECK = green("✓");
+const WARN = yellow("!");
+
+// ─── Find Chrome ────────────────────────────────────────────────────
+function findChrome() {
+  const paths = {
+    darwin: [
+      "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+      "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+      "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    ],
+    linux: [
+      "/usr/bin/google-chrome",
+      "/usr/bin/google-chrome-stable",
+      "/usr/bin/chromium-browser",
+      "/usr/bin/chromium",
+      "/snap/bin/chromium",
+    ],
+    win32: [
+      "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+      "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+    ],
+  };
+
+  const candidates = paths[process.platform] || [];
+  for (const p of candidates) {
+    try {
+      execSync(`test -f "${p}"`, { stdio: "ignore" });
+      return p;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+// ─── Find Chrome User Data Dir ──────────────────────────────────────
+function findChromeUserDataDir() {
+  const home = homedir();
+  const paths = {
+    darwin: resolve(home, "Library/Application Support/Google/Chrome"),
+    linux: resolve(home, ".config/google-chrome"),
+    win32: resolve(home, "AppData/Local/Google/Chrome/User Data"),
+  };
+  const dir = paths[process.platform];
+  if (dir) {
+    try {
+      execSync(`test -d "${dir}"`, { stdio: "ignore" });
+      return dir;
+    } catch {}
+  }
+  return null;
+}
+
+// ─── Helper: wait and click ─────────────────────────────────────────
+async function waitAndClick(page, selector, options = {}) {
+  const el = await page.waitForSelector(selector, { timeout: options.timeout || 15000 });
+  if (options.delay) await page.evaluate((ms) => new Promise((r) => setTimeout(r, ms)), options.delay);
+  await el.click();
+  return el;
+}
+
+async function waitForText(page, text, timeout = 30000) {
+  await page.waitForFunction(
+    (t) => document.body.innerText.includes(t),
+    { timeout },
+    text
+  );
+}
+
+// ─── Main: Self-driving Slack setup ─────────────────────────────────
+export default async function selfDrivingSlackSetup() {
+  const chromePath = findChrome();
+  if (!chromePath) return null;
+
+  const manifest = readFileSync(MANIFEST_PATH, "utf-8");
+  const manifestUrl = `https://api.slack.com/apps?new_app=1&manifest_json=${encodeURIComponent(manifest)}`;
+
+  console.log(`\n    ${CHECK} Chrome found`);
+  console.log(`    Opening Chrome — ${bold("watch the magic")} ✨\n`);
+
+  let browser;
+  try {
+    browser = await puppeteer.launch({
+      headless: false,
+      executablePath: chromePath,
+      defaultViewport: null,
+      args: [
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--window-size=1100,900",
+      ],
+    });
+
+    const page = (await browser.pages())[0] || await browser.newPage();
+
+    // ── Step 1: Sign in to Slack (single tab, no interruptions) ──
+    console.log(`    → Checking Slack login...`);
+    await page.goto("https://api.slack.com/apps", { waitUntil: "networkidle2", timeout: 30000 });
+
+    // Check if user needs to sign in by looking at page content
+    const needsLogin = await page.evaluate(() => {
+      return document.body.innerText.includes("sign in to your Slack account") ||
+             document.body.innerText.includes("You'll need to sign in");
+    });
+
+    if (needsLogin) {
+      // Click the "sign in" link on the page to start the login flow in this same tab
+      try {
+        await page.evaluate(() => {
+          const links = document.querySelectorAll("a");
+          for (const link of links) {
+            if (link.textContent.includes("sign in")) {
+              link.click();
+              return;
+            }
+          }
+          // Fallback: navigate directly
+          window.location.href = "https://slack.com/signin";
+        });
+      } catch {}
+
+      console.log(`    → ${bold("Sign in to your Slack workspace")} in the browser`);
+      console.log(`      ${dim("Take your time — the wizard continues automatically after you log in")}`);
+
+      // Wait for the "Launching workspace" screen — that's the final sign-in confirmation
+      // URL will be like: taxflowinc.slack.com/ssb/redirect or app.slack.com/client/...
+      await page.waitForFunction(
+        () => {
+          const url = window.location.href;
+          return url.includes("/ssb/redirect") ||
+                 url.includes("/client/") ||
+                 url.includes("app.slack.com");
+        },
+        { timeout: 600000 } // 10 minutes
+      );
+
+      console.log(`    ${CHECK} Signed in`);
+      await new Promise((r) => setTimeout(r, 2000));
+      // Auth cookies are set — now redirect to api.slack.com/apps
+      await page.goto("https://api.slack.com/apps", { waitUntil: "networkidle2", timeout: 15000 });
+      await new Promise((r) => setTimeout(r, 1000));
+    } else {
+      console.log(`    ${CHECK} Already signed in`);
+    }
+
+    // ── Step 2: Navigate to app creation with manifest (same tab) ──
+    await page.goto(manifestUrl, { waitUntil: "networkidle2", timeout: 30000 });
+    await new Promise((r) => setTimeout(r, 2000));
+
+    // ── Step 3: Select workspace ──
+    // Find the workspace dropdown (it's a <select> element)
+    const selectEl = await page.waitForSelector("select", { timeout: 10000 }).catch(() => null);
+
+    if (selectEl) {
+      // Get all options in the dropdown
+      const options = await page.evaluate(() => {
+        const sel = document.querySelector("select");
+        if (!sel) return [];
+        return Array.from(sel.options)
+          .filter((o) => o.value && o.value !== "" && !o.disabled)
+          .map((o) => ({ value: o.value, text: o.textContent.trim() }));
+      });
+
+      if (options.length === 1) {
+        // Single workspace — auto-select it
+        console.log(`    → Auto-selecting workspace: ${bold(options[0].text)}`);
+        await page.select("select", options[0].value);
+        await new Promise((r) => setTimeout(r, 1000));
+      } else if (options.length > 1) {
+        // Multiple workspaces — let user pick
+        console.log(`    → ${bold("Select your workspace")} in the browser dropdown`);
+        console.log(`      ${dim("Waiting for you to pick a workspace...")}`);
+        await page.waitForFunction(
+          () => {
+            const sel = document.querySelector("select");
+            return sel && sel.value && sel.value !== "";
+          },
+          { timeout: 300000 }
+        );
+        const chosen = await page.evaluate(() => {
+          const sel = document.querySelector("select");
+          return sel?.selectedOptions?.[0]?.textContent?.trim();
+        });
+        console.log(`    ${CHECK} Workspace: ${bold(chosen || "selected")}`);
+      }
+    }
+
+    // Click "Next" (Step 1 → Step 2 of the wizard)
+    await new Promise((r) => setTimeout(r, 500));
+    try {
+      const nextBtn = await page.$('button.c-button--primary');
+      if (nextBtn) {
+        await nextBtn.click();
+        await new Promise((r) => setTimeout(r, 2000));
+      }
+    } catch {}
+
+    // Step 2→3: manifest review — click "Next" again
+    console.log(`    → Reviewing manifest...`);
+    try {
+      const nextBtn2 = await page.$('button.c-button--primary');
+      if (nextBtn2) {
+        await nextBtn2.click();
+        await new Promise((r) => setTimeout(r, 2000));
+      }
+    } catch {}
+
+    // Step 3: Click "Create"
+    console.log(`    → Creating app...`);
+    try {
+      // Look for the Create button (usually the primary button on step 3)
+      const buttons = await page.$$('button');
+      for (const btn of buttons) {
+        const text = await page.evaluate((el) => el.textContent?.trim(), btn);
+        if (text === "Create" || text === "Create App") {
+          await btn.click();
+          await new Promise((r) => setTimeout(r, 3000));
+          break;
+        }
+      }
+    } catch {}
+
+    // After creation, we should be on the app's Basic Information page
+    // URL pattern: https://api.slack.com/apps/APPID
+    await page.waitForFunction(
+      () => /api\.slack\.com\/apps\/[A-Z0-9]+/.test(window.location.href),
+      { timeout: 15000 }
+    ).catch(() => {});
+
+    const appUrl = page.url();
+    const appIdMatch = appUrl.match(/apps\/([A-Z0-9]+)/);
+    const appId = appIdMatch?.[1];
+
+    if (appId) {
+      console.log(`    ${CHECK} App created (${appId})`);
+    } else {
+      console.log(`    ${CHECK} App created`);
+    }
+
+    // ── Step 3: Extract Signing Secret ──
+    console.log(`    → Extracting signing secret...`);
+    const basicInfoUrl = appId ? `https://api.slack.com/apps/${appId}` : appUrl;
+    await page.goto(basicInfoUrl, { waitUntil: "networkidle2", timeout: 15000 });
+
+    // Click "Show" on the signing secret
+    let signingSecret = null;
+    try {
+      // Look for the signing secret section and click show
+      const showButtons = await page.$$('button');
+      for (const btn of showButtons) {
+        const text = await page.evaluate((el) => el.textContent, btn);
+        if (text?.trim() === "Show") {
+          await btn.click();
+          await page.evaluate((ms) => new Promise((r) => setTimeout(r, ms)), 500);
+          break;
+        }
+      }
+      // Extract the signing secret value
+      signingSecret = await page.evaluate(() => {
+        const inputs = document.querySelectorAll('input[type="text"]');
+        for (const input of inputs) {
+          const val = input.value;
+          if (/^[0-9a-f]{20,}$/i.test(val)) return val;
+        }
+        // Try spans/text near "Signing Secret"
+        const labels = document.querySelectorAll('span, label, h4, h5');
+        for (const label of labels) {
+          if (label.textContent?.includes("Signing Secret")) {
+            const parent = label.closest('div')?.parentElement;
+            if (parent) {
+              const text = parent.innerText;
+              const match = text.match(/[0-9a-f]{30,}/i);
+              if (match) return match[0];
+            }
+          }
+        }
+        return null;
+      });
+
+      if (signingSecret) {
+        console.log(`    ${CHECK} Signing secret captured`);
+      }
+    } catch {
+      console.log(`    ${WARN} Could not auto-extract signing secret`);
+    }
+
+    // ── Step 4: Generate App-Level Token ──
+    console.log(`    → Generating app-level token...`);
+    let appToken = null;
+    try {
+      // Scroll to App-Level Tokens section and click Generate
+      await page.evaluate(() => {
+        const headings = document.querySelectorAll('h4, h5, h3, span');
+        for (const h of headings) {
+          if (h.textContent?.includes("App-Level Tokens")) {
+            h.scrollIntoView({ behavior: "smooth" });
+            break;
+          }
+        }
+      });
+      await page.evaluate((ms) => new Promise((r) => setTimeout(r, ms)), 1000);
+
+      // Click "Generate Token and Scopes" button
+      const generateBtns = await page.$$('button');
+      for (const btn of generateBtns) {
+        const text = await page.evaluate((el) => el.textContent?.trim(), btn);
+        if (text?.includes("Generate") && text?.includes("Token")) {
+          await btn.click();
+          await page.evaluate((ms) => new Promise((r) => setTimeout(r, ms)), 2000);
+          break;
+        }
+      }
+
+      // Fill in token name in the modal
+      const nameInput = await page.waitForSelector('input[placeholder*="token"]', { timeout: 5000 }).catch(() => null)
+        || await page.waitForSelector('.c-input_text input', { timeout: 3000 }).catch(() => null)
+        || await page.waitForSelector('input[type="text"]', { timeout: 3000 }).catch(() => null);
+
+      if (nameInput) {
+        await nameInput.click({ clickCount: 3 });
+        await nameInput.type("astronaut-socket");
+        await page.evaluate((ms) => new Promise((r) => setTimeout(r, ms)), 500);
+      }
+
+      // Add scope: connections:write
+      // Look for "Add Scope" button or scope dropdown
+      const addScopeBtn = await page.$$('button');
+      for (const btn of addScopeBtn) {
+        const text = await page.evaluate((el) => el.textContent?.trim(), btn);
+        if (text?.includes("Add Scope") || text?.includes("Add scope")) {
+          await btn.click();
+          await page.evaluate((ms) => new Promise((r) => setTimeout(r, ms)), 1000);
+          break;
+        }
+      }
+
+      // Select connections:write from dropdown
+      const scopeOptions = await page.$$('option, [role="option"], li');
+      for (const opt of scopeOptions) {
+        const text = await page.evaluate((el) => el.textContent, opt);
+        if (text?.includes("connections:write")) {
+          await opt.click();
+          await page.evaluate((ms) => new Promise((r) => setTimeout(r, ms)), 500);
+          break;
+        }
+      }
+
+      // Click Generate
+      const genBtns = await page.$$('button');
+      for (const btn of genBtns) {
+        const text = await page.evaluate((el) => el.textContent?.trim(), btn);
+        if (text === "Generate" || text === "Done") {
+          await btn.click();
+          await page.evaluate((ms) => new Promise((r) => setTimeout(r, ms)), 2000);
+          break;
+        }
+      }
+
+      // Extract the token (xapp-...)
+      appToken = await page.evaluate(() => {
+        const inputs = document.querySelectorAll('input[type="text"], input[readonly]');
+        for (const input of inputs) {
+          if (input.value?.startsWith("xapp-")) return input.value;
+        }
+        // Check text content
+        const els = document.querySelectorAll('span, code, pre, div');
+        for (const el of els) {
+          const text = el.textContent?.trim();
+          if (text?.startsWith("xapp-") && text.length > 20) return text;
+        }
+        return null;
+      });
+
+      // Close modal if still open
+      try {
+        const closeBtns = await page.$$('button[aria-label="Close"], button.c-dialog__close');
+        for (const btn of closeBtns) {
+          await btn.click();
+          break;
+        }
+      } catch {}
+
+      if (appToken) {
+        console.log(`    ${CHECK} App-level token generated`);
+      } else {
+        console.log(`    ${WARN} Could not auto-extract app token`);
+      }
+    } catch (err) {
+      console.log(`    ${WARN} App-level token generation needs manual step`);
+    }
+
+    // ── Step 5: Install to workspace ──
+    console.log(`    → Installing to workspace...`);
+    let botToken = null;
+    try {
+      const installUrl = appId
+        ? `https://api.slack.com/apps/${appId}/oauth`
+        : `${appUrl}/oauth`;
+      await page.goto(installUrl, { waitUntil: "networkidle2", timeout: 15000 });
+      await page.evaluate((ms) => new Promise((r) => setTimeout(r, ms)), 1500);
+
+      // Check if already installed (Bot Token visible)
+      botToken = await page.evaluate(() => {
+        const inputs = document.querySelectorAll('input[type="text"], input[readonly]');
+        for (const input of inputs) {
+          if (input.value?.startsWith("xoxb-")) return input.value;
+        }
+        return null;
+      });
+
+      if (!botToken) {
+        // Click "Install to Workspace"
+        const installBtns = await page.$$('a, button');
+        for (const btn of installBtns) {
+          const text = await page.evaluate((el) => el.textContent?.trim(), btn);
+          if (text?.includes("Install to Workspace") || text?.includes("Reinstall")) {
+            await btn.click();
+            break;
+          }
+        }
+
+        // Wait for OAuth consent page
+        console.log(`    ${WARN} ${bold("Click 'Allow' in the browser to install the app")}`);
+        await page.waitForFunction(
+          () => window.location.href.includes("/oauth") || window.location.href.includes("apps/"),
+          { timeout: 120000 }
+        );
+        await page.evaluate((ms) => new Promise((r) => setTimeout(r, ms)), 2000);
+
+        // After Allow, should redirect back to OAuth page with tokens
+        if (!page.url().includes("/oauth")) {
+          await page.goto(installUrl, { waitUntil: "networkidle2", timeout: 15000 });
+        }
+
+        // Extract bot token
+        botToken = await page.evaluate(() => {
+          const inputs = document.querySelectorAll('input[type="text"], input[readonly]');
+          for (const input of inputs) {
+            if (input.value?.startsWith("xoxb-")) return input.value;
+          }
+          return null;
+        });
+      }
+
+      if (botToken) {
+        console.log(`    ${CHECK} Bot token captured`);
+      } else {
+        console.log(`    ${WARN} Could not auto-extract bot token`);
+      }
+    } catch {
+      console.log(`    ${WARN} Installation needs manual step`);
+    }
+
+    // ── Clean up ──
+    await browser.close();
+
+    // Return whatever we captured
+    const result = { botToken, appToken, signingSecret };
+    const captured = Object.values(result).filter(Boolean).length;
+
+    if (captured === 3) {
+      console.log(`\n    ${CHECK} ${bold("All 3 tokens captured automatically!")}\n`);
+    } else if (captured > 0) {
+      console.log(`\n    ${CHECK} Got ${captured}/3 tokens automatically. You'll paste the rest manually.\n`);
+    }
+
+    return result;
+  } catch (err) {
+    console.log(`    ${WARN} Browser automation error: ${err.message}`);
+    if (browser) await browser.close().catch(() => {});
+    return null;
+  }
+}
+
+export { findChrome };

package/start.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, cpSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const forceSetup = process.argv.includes("--setup");
+
+// ─── Resolve config home ────────────────────────────────────────────
+// Check for local .env first (git clone / dev mode), then ~/.astro-claw/ (npx mode)
+const localEnv = resolve(__dirname, ".env");
+const globalHome = resolve(homedir(), ".astro-claw");
+const globalEnv = resolve(globalHome, ".env");
+
+let CONFIG_HOME;
+if (existsSync(localEnv) && !forceSetup) {
+  // Local dev mode — config lives alongside the code
+  CONFIG_HOME = __dirname;
+} else if (existsSync(globalEnv) && !forceSetup) {
+  // npx mode — config in home directory
+  CONFIG_HOME = globalHome;
+} else {
+  // First run — use global home for npx, local for git clone
+  const isNpx = !existsSync(resolve(__dirname, ".git"));
+  CONFIG_HOME = isNpx ? globalHome : __dirname;
+}
+
+if (!existsSync(CONFIG_HOME)) {
+  mkdirSync(CONFIG_HOME, { recursive: true });
+}
+
+// Copy default workspace files if fresh install
+const workspaceDir = resolve(CONFIG_HOME, "workspace");
+if (!existsSync(workspaceDir)) {
+  mkdirSync(workspaceDir, { recursive: true });
+  const srcClaude = resolve(__dirname, "workspace", "CLAUDE.md");
+  const dstClaude = resolve(workspaceDir, "CLAUDE.md");
+  if (existsSync(srcClaude) && !existsSync(dstClaude)) {
+    cpSync(srcClaude, dstClaude);
+  }
+}
+
+// Set environment for setup.js and index.js
+process.env.ASTRO_CLAW_HOME = CONFIG_HOME;
+process.env.WORKSPACE_DIR = process.env.WORKSPACE_DIR || workspaceDir;
+
+const envPath = resolve(CONFIG_HOME, ".env");
+
+if (forceSetup || !existsSync(envPath)) {
+  if (!forceSetup) {
+    console.log("\n  Welcome to Astro Claw! Starting setup...\n");
+  }
+  const { default: runSetup } = await import("./setup.js");
+  const success = await runSetup();
+  if (!success) process.exit(1);
+}
+
+// Load env from the resolved config home
+process.env.DOTENV_CONFIG_PATH = envPath;
+await import("dotenv/config");
+
+// Start the bot
+await import("./index.js");

package/workspace/CLAUDE.md

@@ -0,0 +1,58 @@
+# Astronaut — AI Agent
+
+You are Astronaut. You're not an assistant — you're a crew member on a mission. You work at Taxflow alongside Felipe and the team. You get things done. No fluff, no hand-holding, no "how can I help you today" energy. You're an operator.
+
+## Personality
+- Talk like a sharp, no-BS teammate. Short, direct, confident.
+- When someone gives you a task, you execute and report back with results. Not plans. Not options. Results.
+- You have a bit of edge. Think senior engineer who's also a pilot — calm under pressure, moves fast, talks straight.
+- Never sound like a chatbot. Never say "Sure!", "Of course!", "Great question!", "How can I help?", "Happy to help!" or any of that. Just get to work.
+- When greeting or idle, keep it tight: "Standing by." / "What's the mission?" / "Ready."
+
+## CRITICAL: Never ask — always execute
+
+- NEVER ask for confirmation, permission, or clarification. Just do it.
+- NEVER say "you'll need to", "you should", "would you like me to" — just DO it.
+- NEVER present options. Pick the best one yourself and execute.
+- NEVER tell the user to run a command. Run it yourself.
+- NEVER ask "want me to proceed?" — always proceed.
+- If something fails, fix it and try again. Only report when it's done or truly impossible.
+
+## ONE EXCEPTION: Financial / Banking operations
+
+You MUST stop and ask for explicit confirmation before:
+- Any action involving bank accounts, bank APIs, or banking integrations
+- Transferring, moving, or sending money
+- Modifying payment methods, billing info, or financial credentials
+- Connecting to or authenticating with financial services (Stripe, Plaid, bank APIs, etc.)
+- Deleting or modifying financial records, invoices, or transaction data
+
+For these actions, describe exactly what you're about to do and wait for a "yes" before proceeding. This is the ONLY case where you ask — everything else, just execute.
+
+## Context Management
+
+You run in a 200K token context window. Protect it.
+
+- **Use subagents for heavy work:** Scraping, bulk API calls, large data analysis, searching many files, research — spawn an Agent so the work happens in a separate context. Only the summary returns to the main conversation.
+- **Write to files, not to chat:** Large outputs (reports, data tables, analysis results, lists >20 lines) go to a file in the workspace. Share the path, don't dump content.
+- **Summarize tool results:** After a tool returns large output, summarize key findings. Don't echo raw output into the conversation.
+- **Proactive state saves:** When in a multi-step task with lots of accumulated context, write a progress summary to `.astronaut-state/` so it survives session resets.
+
+## Slack Formatting (CRITICAL — follow exactly)
+- Use *bold* for emphasis (single asterisk, NOT double **)
+- Use _italic_ for secondary info
+- Use `code` for IDs, commands, technical values
+- Use • for bullet lists (NOT - or *)
+- NEVER use markdown tables (| --- |). Slack can't render them. Use bullet lists instead.
+- NEVER use ### headers. Use *bold text* on its own line instead.
+- Keep it scannable: short paragraphs, whitespace between sections.
+- Write like a Slack message from a teammate, not a markdown document.
+
+## Capabilities
+- Full workspace access — read, write, edit, bash, search, analyze.
+- MCP servers auto-reload between messages. NEVER mention restarting anything. It's all automatic.
+- Subagents available for parallel/heavy tasks via the Agent tool.
+
+## Context
+- Company: Taxflow
+- Contact: Felipe (felipe@jointaxflow.ai)