@1dolinski/fastforms 0.1.0

package/README.md

@@ -0,0 +1,113 @@
+# fastforms
+
+Fill any form fast. Manage personas locally, fill forms from your terminal.
+
+## Quick start
+
+```bash
+# 1. Create your personas
+npx fastforms init
+
+# 2. Enable remote debugging in Chrome
+#    Open chrome://inspect/#remote-debugging and toggle it on
+
+# 3. Fill any form (never submits)
+npx fastforms fill https://example.com/apply
+```
+
+## How it works
+
+1. **`fastforms init`** walks you through creating user + business personas interactively
+2. Personas are saved as simple JSON in `.fastforms/user.json` and `.fastforms/business.json`
+3. **`fastforms fill <url>`** connects to Chrome, opens the form, fills it by label matching
+4. **Review and submit manually** in Chrome
+
+## Requirements
+
+- Chrome >= 144
+- Node.js >= 18
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `fastforms init` | Create personas interactively |
+| `fastforms fill <url>` | Fill any form |
+| `fastforms edit` | Update existing personas |
+| `fastforms personas` | Open web persona manager in Chrome |
+
+### Fill options
+
+| Option | Description |
+|---|---|
+| `--web` | Use web app personas instead of local files |
+| `--dir <path>` | Custom persona directory path |
+| `--port <port>` | Chrome debug port (auto-detected) |
+| `--user <hint>` | User persona hint (web mode) |
+| `--business <hint>` | Business persona hint (web mode) |
+
+## `.fastforms/` directory
+
+```
+.fastforms/
+  user.json           # Your user persona
+  business.json       # Your business persona
+  dumps/              # Optional: raw text context files
+```
+
+`user.json` — just fill in what you have:
+
+```json
+{
+  "name": "chris",
+  "fullName": "Chris Dolinski",
+  "email": "chris@example.com",
+  "role": "Founder",
+  "location": "Toronto, ON",
+  "linkedIn": "linkedin.com/in/1dolinski",
+  "github": "github.com/1dolinski",
+  "bio": "Serial entrepreneur",
+  "facts": {
+    "x handle": "@1dolinski",
+    "telegram": "@chris"
+  }
+}
+```
+
+`business.json`:
+
+```json
+{
+  "name": "APINow.fun",
+  "oneLiner": "x402 everything",
+  "website": "apinow.fun",
+  "problem": "Payments are broken",
+  "solution": "Fix them with x402"
+}
+```
+
+## Web app (optional)
+
+You can also manage personas in the web UI at [293-fastforms.vercel.app/persona](https://293-fastforms.vercel.app/persona) and use `--web` flag to pull from there. The web app has an "Export for CLI" button to download your personas as local JSON files.
+
+## Contributing
+
+PRs welcome. To develop locally:
+
+```bash
+git clone https://github.com/1dolinski/fastforms.git
+cd fastforms
+npm install
+node bin/fastforms.js init
+node bin/fastforms.js fill https://example.com/apply
+```
+
+### Adding a new form mapping
+
+1. Add a `buildXxxData(user, biz)` function in `lib/fill.js`
+2. Add a URL check in `fillForm()`
+3. Test with `node bin/fastforms.js fill <url>`
+
+## License
+
+MIT

package/SKILL.md

@@ -0,0 +1,79 @@
+# fastforms
+
+Fill any form fast using your personas.
+
+## Triggers
+
+Use this skill when the user says any of:
+- "fill a form", "fill out this form", "fill out this application"
+- "apply to X", "submit my info to X"
+- "autofill form", "autofill with my persona"
+- "fill this form with my persona"
+- "use fastforms", "fastforms fill"
+- "set up my personas", "init fastforms"
+
+## What it does
+
+`fastforms` is a CLI tool that:
+
+1. Manages personas locally in a `.fastforms/` directory (simple JSON files)
+2. Connects to Chrome via the DevTools Protocol
+3. Fills any form using label-matching — never submits
+
+## Quick start
+
+```bash
+# 1. Create your personas interactively
+npx fastforms init
+
+# 2. Enable remote debugging in Chrome
+#    Open chrome://inspect/#remote-debugging
+
+# 3. Fill any form
+npx fastforms fill https://example.com/apply
+```
+
+## Commands
+
+### `npx fastforms init`
+
+Conversational persona builder. Walks through user + business persona fields, saves to `.fastforms/user.json` and `.fastforms/business.json`.
+
+### `npx fastforms fill <url>`
+
+Fills any form. Reads personas from local `.fastforms/` directory by default.
+
+Options:
+- `--web` — use web app personas (https://293-fastforms.vercel.app) instead of local files
+- `--dir <path>` — custom path to persona directory
+- `--port <port>` — Chrome debug port (auto-detected by default)
+
+### `npx fastforms edit`
+
+Re-run the persona builder with current values pre-filled.
+
+### `npx fastforms personas`
+
+Opens the web persona manager in Chrome.
+
+## Persona sources
+
+1. **Local `.fastforms/` directory** (default) — simple JSON files, no web app needed
+2. **Web app** (`--web` flag) — https://293-fastforms.vercel.app/persona manages personas in localStorage, CLI reads via CDP
+
+## How it works
+
+1. Reads personas from `.fastforms/user.json` and `.fastforms/business.json`
+2. Auto-discovers Chrome's debug port from `DevToolsActivePort`
+3. Opens (or reuses) the target form URL tab
+4. Fills using label-matching heuristics. Has site-specific mappings for known forms.
+5. Shows what was filled, what was skipped. **Never submits.**
+
+## Agent instructions
+
+When the user asks you to fill a form:
+
+1. Check if `.fastforms/` exists. If not, run `npx fastforms init`
+2. Run `npx fastforms fill <the-url>`
+3. If Chrome debugging isn't enabled, tell the user to open `chrome://inspect/#remote-debugging`
+4. After filling, tell the user to review in Chrome and submit manually

package/bin/fastforms.js

@@ -0,0 +1,396 @@
+#!/usr/bin/env node
+
+import { createInterface } from "readline";
+import { join } from "path";
+import { homedir } from "os";
+import { existsSync } from "fs";
+
+import { ensureChromeReady } from "../lib/chrome.js";
+import {
+  connectToChrome,
+  pullPersonas,
+  selectPersonas,
+  showPersonaDetails,
+  offerSetDefaults,
+  offerOpenPersonaManager,
+} from "../lib/personas.js";
+import { fillForm } from "../lib/fill.js";
+import {
+  findFastformsDir,
+  ensureDir,
+  loadLocalPersonas,
+  saveUserPersona,
+  saveBusinessPersona,
+  userTemplate,
+  businessTemplate,
+} from "../lib/local.js";
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+function flag(name) {
+  const idx = args.indexOf(name);
+  return idx !== -1 ? args[idx + 1] : "";
+}
+
+function hasFlag(name) {
+  return args.includes(name);
+}
+
+const explicitPort = flag("--port") ? Number(flag("--port")) : null;
+
+let _rl = null;
+function getRL() {
+  if (!_rl) _rl = createInterface({ input: process.stdin, output: process.stdout });
+  return _rl;
+}
+function closeRL() {
+  if (_rl) { _rl.close(); _rl = null; }
+}
+
+function ask(prompt, fallback = "") {
+  return new Promise((r) => getRL().question(prompt, (a) => r(a.trim() || fallback)));
+}
+
+function help() {
+  console.log(`
+  fastforms — Fill any form fast.
+
+  Usage:
+    fastforms init                  Set up your personas interactively
+    fastforms fill <url>            Fill a form with your personas
+    fastforms edit                  Edit your existing personas
+    fastforms personas              Open web persona manager in Chrome
+    fastforms                       Show this help
+
+  Options:
+    --web               Use web app personas instead of local .fastforms/
+    --dir <path>        Path to .fastforms/ directory (default: auto-detect)
+    --user <hint>       User persona name/hint (web mode)
+    --business <hint>   Business persona name/hint (web mode)
+    --port <port>       Chrome debug port (auto-detected by default)
+
+  Quick start:
+    1. npx fastforms init
+    2. Enable remote debugging: chrome://inspect/#remote-debugging
+    3. npx fastforms fill https://example.com/apply
+`);
+}
+
+// ---------------------------------------------------------------------------
+// init — conversational persona builder
+// ---------------------------------------------------------------------------
+
+async function init() {
+  const dirArg = flag("--dir");
+  const dir = dirArg || join(process.cwd(), ".fastforms");
+
+  console.log("\n  fastforms — Let's set up your personas.\n");
+
+  if (existsSync(join(dir, "user.json"))) {
+    const ans = await ask("  .fastforms/ already exists. Overwrite? [y/N]: ");
+    if (ans.toLowerCase() !== "y") {
+      console.log("  Use 'fastforms edit' to update existing personas.\n");
+      return;
+    }
+  }
+
+  // --- User persona ---
+  console.log("  --- User persona ---\n");
+  const user = userTemplate();
+
+  user.name = await ask("  Name (identifier): ");
+  user.fullName = await ask("  Full name: ");
+  user.email = await ask("  Email: ");
+  user.role = await ask("  Role / title: ");
+  user.location = await ask("  Location: ");
+  user.linkedIn = await ask("  LinkedIn (optional): ");
+  user.github = await ask("  GitHub (optional): ");
+  user.bio = await ask("  Short bio (optional): ");
+
+  // Custom facts
+  console.log("\n  Add custom facts (e.g. 'x handle = @1dolinski'). Press Enter to skip.\n");
+  while (true) {
+    const raw = await ask("  fact: ");
+    if (!raw) break;
+    const eq = raw.indexOf("=");
+    if (eq === -1) {
+      console.log("    Use format: key = value");
+      continue;
+    }
+    const key = raw.slice(0, eq).trim();
+    const value = raw.slice(eq + 1).trim();
+    if (key) user.facts[key] = value;
+  }
+
+  // --- Business persona ---
+  console.log("\n  --- Business persona ---\n");
+  const biz = businessTemplate();
+
+  biz.name = await ask("  Company / project name: ");
+  biz.oneLiner = await ask("  One-liner: ");
+  biz.website = await ask("  Website (optional): ");
+  biz.category = await ask("  Category (optional): ");
+  biz.location = await ask("  Location (optional): ");
+  biz.problem = await ask("  Problem you're solving (optional): ");
+  biz.solution = await ask("  Your solution (optional): ");
+  biz.targetUsers = await ask("  Target users (optional): ");
+  biz.traction = await ask("  Traction (optional): ");
+  biz.businessModel = await ask("  Business model (optional): ");
+  biz.differentiators = await ask("  Differentiators (optional): ");
+
+  console.log("\n  Add business facts. Press Enter to skip.\n");
+  while (true) {
+    const raw = await ask("  fact: ");
+    if (!raw) break;
+    const eq = raw.indexOf("=");
+    if (eq === -1) {
+      console.log("    Use format: key = value");
+      continue;
+    }
+    const key = raw.slice(0, eq).trim();
+    const value = raw.slice(eq + 1).trim();
+    if (key) biz.facts[key] = value;
+  }
+
+  // Save
+  ensureDir(dir);
+  saveUserPersona(dir, user);
+  saveBusinessPersona(dir, biz);
+
+  console.log(`\n  Saved to ${dir}/`);
+  console.log("    user.json");
+  console.log("    business.json");
+  console.log("\n  Next: npx fastforms fill <url>\n");
+  closeRL();
+}
+
+// ---------------------------------------------------------------------------
+// edit — re-run init with pre-filled values
+// ---------------------------------------------------------------------------
+
+async function edit() {
+  const dirArg = flag("--dir");
+  const dir = dirArg || findFastformsDir();
+
+  if (!dir) {
+    console.error("  No .fastforms/ directory found. Run 'fastforms init' first.\n");
+    process.exit(1);
+  }
+
+  const dump = loadLocalPersonas(dir);
+  const existing = dump.personas[0];
+  const existingBiz = dump.businessPersonas[0];
+
+  console.log("\n  fastforms — Edit your personas. Press Enter to keep current value.\n");
+
+  // --- User ---
+  console.log("  --- User persona ---\n");
+  const ep = existing?.profile || {};
+  const user = userTemplate();
+
+  user.name = await ask(`  Name [${existing?.name || ""}]: `, existing?.name || "");
+  user.fullName = await ask(`  Full name [${ep.fullName || ""}]: `, ep.fullName || "");
+  user.email = await ask(`  Email [${ep.email || ""}]: `, ep.email || "");
+  user.role = await ask(`  Role [${ep.currentRole || ""}]: `, ep.currentRole || "");
+  user.location = await ask(`  Location [${ep.location || ""}]: `, ep.location || "");
+  user.linkedIn = await ask(`  LinkedIn [${ep.linkedIn || ""}]: `, ep.linkedIn || "");
+  user.github = await ask(`  GitHub [${ep.github || ""}]: `, ep.github || "");
+  user.bio = await ask(`  Bio [${ep.bio ? ep.bio.slice(0, 40) + "..." : ""}]: `, ep.bio || "");
+
+  // Carry over existing facts
+  const existingFacts = {};
+  for (const f of (existing?.customFacts || [])) {
+    if (f.enabled !== false) existingFacts[f.key] = f.value;
+  }
+  user.facts = { ...existingFacts };
+
+  if (Object.keys(user.facts).length) {
+    console.log("\n  Current facts:");
+    for (const [k, v] of Object.entries(user.facts)) {
+      console.log(`    ${k} = ${v}`);
+    }
+  }
+  console.log("\n  Add/update facts (Enter to finish):\n");
+  while (true) {
+    const raw = await ask("  fact: ");
+    if (!raw) break;
+    const eq = raw.indexOf("=");
+    if (eq === -1) { console.log("    Use format: key = value"); continue; }
+    user.facts[raw.slice(0, eq).trim()] = raw.slice(eq + 1).trim();
+  }
+
+  // --- Business ---
+  console.log("\n  --- Business persona ---\n");
+  const bp = existingBiz?.profile || {};
+  const biz = businessTemplate();
+
+  biz.name = await ask(`  Company [${existingBiz?.name || ""}]: `, existingBiz?.name || "");
+  biz.oneLiner = await ask(`  One-liner [${bp.oneLiner || ""}]: `, bp.oneLiner || "");
+  biz.website = await ask(`  Website [${bp.website || ""}]: `, bp.website || "");
+  biz.category = await ask(`  Category [${bp.category || ""}]: `, bp.category || "");
+  biz.location = await ask(`  Location [${bp.location || ""}]: `, bp.location || "");
+  biz.problem = await ask(`  Problem [${bp.problem ? bp.problem.slice(0, 40) + "..." : ""}]: `, bp.problem || "");
+  biz.solution = await ask(`  Solution [${bp.solution ? bp.solution.slice(0, 40) + "..." : ""}]: `, bp.solution || "");
+  biz.targetUsers = await ask(`  Target users [${bp.targetUsers ? bp.targetUsers.slice(0, 40) + "..." : ""}]: `, bp.targetUsers || "");
+  biz.traction = await ask(`  Traction [${bp.traction ? bp.traction.slice(0, 40) + "..." : ""}]: `, bp.traction || "");
+  biz.businessModel = await ask(`  Business model [${bp.businessModel ? bp.businessModel.slice(0, 40) + "..." : ""}]: `, bp.businessModel || "");
+  biz.differentiators = await ask(`  Differentiators [${bp.differentiators ? bp.differentiators.slice(0, 40) + "..." : ""}]: `, bp.differentiators || "");
+
+  const existingBizFacts = {};
+  for (const f of (existingBiz?.customFacts || [])) {
+    if (f.enabled !== false) existingBizFacts[f.key] = f.value;
+  }
+  biz.facts = { ...existingBizFacts };
+
+  if (Object.keys(biz.facts).length) {
+    console.log("\n  Current facts:");
+    for (const [k, v] of Object.entries(biz.facts)) {
+      console.log(`    ${k} = ${v}`);
+    }
+  }
+  console.log("\n  Add/update facts (Enter to finish):\n");
+  while (true) {
+    const raw = await ask("  fact: ");
+    if (!raw) break;
+    const eq = raw.indexOf("=");
+    if (eq === -1) { console.log("    Use format: key = value"); continue; }
+    biz.facts[raw.slice(0, eq).trim()] = raw.slice(eq + 1).trim();
+  }
+
+  saveUserPersona(dir, user);
+  saveBusinessPersona(dir, biz);
+  console.log(`\n  Updated ${dir}/\n`);
+  closeRL();
+}
+
+// ---------------------------------------------------------------------------
+// fill — the main event
+// ---------------------------------------------------------------------------
+
+async function fill() {
+  const formUrl = args.find((a) => a.startsWith("http"));
+  if (!formUrl) {
+    console.error("  Usage: fastforms fill <url>\n");
+    process.exit(1);
+  }
+
+  console.log(`\n  fastforms fill — NO SUBMIT\n`);
+  console.log(`  Target: ${formUrl}\n`);
+
+  const port = await ensureChromeReady(explicitPort);
+  console.log(`  Connected to Chrome on port ${port}.`);
+
+  let dump;
+  let browser;
+
+  if (hasFlag("--web")) {
+    // Web app mode
+    console.log("  Pulling personas from web app...");
+    browser = await connectToChrome(port);
+    dump = await pullPersonas(browser);
+  } else {
+    // Local mode (default)
+    const dirArg = flag("--dir");
+    const dir = dirArg || findFastformsDir();
+
+    if (!dir) {
+      console.error("  No .fastforms/ directory found.");
+      console.error("  Run 'fastforms init' to create one, or use --web for web app mode.\n");
+      process.exit(1);
+    }
+
+    console.log(`  Loading personas from ${dir}/`);
+    dump = loadLocalPersonas(dir);
+    browser = await connectToChrome(port);
+  }
+
+  const personas = dump.personas || [];
+  const bizPersonas = dump.businessPersonas || [];
+  console.log(`  Found ${personas.length} user persona(s), ${bizPersonas.length} business persona(s).`);
+
+  if (!personas.length && !bizPersonas.length) {
+    console.error("\n  No personas found.");
+    if (hasFlag("--web")) {
+      await offerOpenPersonaManager(browser);
+    } else {
+      console.error("  Run 'fastforms init' to create personas.\n");
+    }
+    browser.disconnect();
+    process.exit(1);
+  }
+
+  const userHint = flag("--user");
+  const bizHint = flag("--business");
+  const { user, biz } = await selectPersonas(dump, userHint, bizHint);
+
+  if (!user && !biz) {
+    console.error("\n  No matching personas.");
+    browser.disconnect();
+    process.exit(1);
+  }
+
+  showPersonaDetails(user, biz);
+
+  const pages = await browser.pages();
+  const host = new URL(formUrl).host;
+  let page = pages.find((p) => p.url().includes(host));
+
+  if (page) {
+    console.log(`\n  Using existing tab for ${host}`);
+    await page.bringToFront();
+  } else {
+    page = await browser.newPage();
+    await page.goto(formUrl, { waitUntil: "networkidle2", timeout: 45_000 });
+    console.log(`\n  Opened ${formUrl}`);
+  }
+
+  await fillForm(page, formUrl, user, biz);
+
+  if (hasFlag("--web")) {
+    await offerSetDefaults(user, biz);
+  }
+
+  browser.disconnect();
+}
+
+// ---------------------------------------------------------------------------
+// personas — open web manager
+// ---------------------------------------------------------------------------
+
+async function openPersonas() {
+  const port = await ensureChromeReady(explicitPort);
+  const browser = await connectToChrome(port);
+  const pages = await browser.pages();
+  const existing = pages.find((p) => p.url().includes("293-fastforms.vercel.app/persona"));
+  if (existing) {
+    await existing.bringToFront();
+    console.log("  Focused existing persona manager tab.");
+  } else {
+    const tab = await browser.newPage();
+    await tab.goto("https://293-fastforms.vercel.app/persona", { waitUntil: "networkidle2", timeout: 30_000 });
+    console.log("  Opened https://293-fastforms.vercel.app/persona");
+  }
+  browser.disconnect();
+}
+
+// ---------------------------------------------------------------------------
+// Route
+// ---------------------------------------------------------------------------
+
+switch (command) {
+  case "init":
+    init().catch((e) => { console.error(e.message); process.exit(1); });
+    break;
+  case "edit":
+    edit().catch((e) => { console.error(e.message); process.exit(1); });
+    break;
+  case "fill":
+    fill().catch((e) => { console.error(e.message); process.exit(1); });
+    break;
+  case "personas":
+    openPersonas().catch((e) => { console.error(e.message); process.exit(1); });
+    break;
+  default:
+    help();
+}

package/lib/chrome.js

@@ -0,0 +1,66 @@
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { getDataDir } from "./platforms.js";
+
+/**
+ * Reads the DevToolsActivePort file from Chrome's user data directory.
+ * Chrome writes this file when remote debugging is enabled (via
+ * chrome://inspect/#remote-debugging or --remote-debugging-port).
+ * Returns { port, wsPath } or null.
+ */
+export function readDevToolsActivePort() {
+  const filePath = join(getDataDir(), "DevToolsActivePort");
+  if (!existsSync(filePath)) return null;
+
+  try {
+    const lines = readFileSync(filePath, "utf-8").trim().split("\n");
+    if (lines.length < 2) return null;
+    const port = Number(lines[0]);
+    if (!port || isNaN(port)) return null;
+    return { port, wsPath: lines[1] };
+  } catch {
+    return null;
+  }
+}
+
+export async function isCdpReady(port) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/json/version`);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+export async function ensureChromeReady(explicitPort) {
+  // If user passed --port, try that directly
+  if (explicitPort) {
+    if (await isCdpReady(explicitPort)) return explicitPort;
+
+    console.error(`\n  Cannot connect to Chrome on port ${explicitPort}.\n`);
+    console.error("  Enable remote debugging in Chrome:");
+    console.error("  1. Open chrome://inspect/#remote-debugging");
+    console.error("  2. Toggle 'Allow remote debugging' on");
+    console.error("  3. Re-run this command\n");
+    process.exit(1);
+  }
+
+  // Auto-discover from DevToolsActivePort
+  const active = readDevToolsActivePort();
+  if (active && await isCdpReady(active.port)) return active.port;
+
+  // Fallback: try common port
+  if (await isCdpReady(9222)) return 9222;
+
+  console.error("\n  Chrome remote debugging is not enabled.\n");
+  console.error("  To enable it:");
+  console.error("  1. Open chrome://inspect/#remote-debugging in Chrome");
+  console.error("  2. Toggle 'Allow remote debugging' on");
+  console.error("  3. Re-run this command\n");
+
+  if (active) {
+    console.error(`  (Found stale DevToolsActivePort for port ${active.port} — restart Chrome if needed)\n`);
+  }
+
+  process.exit(1);
+}

package/lib/fill.js

@@ -0,0 +1,188 @@
+import { getCustomFact } from "./personas.js";
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+export async function fillByLabel(page, label, value, opts = {}) {
+  if (!value) return false;
+  return page.evaluate((lbl, val, ta) => {
+    const norm = (s) => s?.toLowerCase().replace(/[*\s]+/g, " ").trim() || "";
+    for (const el of document.querySelectorAll("label, h3, h4, p, span, div")) {
+      if (!norm(el.textContent).includes(norm(lbl))) continue;
+      const parent = el.closest("div[class], section, fieldset") || el.parentElement;
+      if (!parent) continue;
+      const input = parent.querySelector(
+        ta ? "textarea" : 'input:not([type="hidden"]):not([type="checkbox"]):not([type="radio"]), textarea'
+      );
+      if (!input) continue;
+      input.focus();
+      const setter = Object.getOwnPropertyDescriptor(
+        input.tagName === "TEXTAREA" ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype, "value"
+      )?.set;
+      if (setter) setter.call(input, val); else input.value = val;
+      input.dispatchEvent(new Event("input", { bubbles: true }));
+      input.dispatchEvent(new Event("change", { bubbles: true }));
+      return true;
+    }
+    return false;
+  }, label, value, opts.textarea ?? false);
+}
+
+export async function clickRadio(page, sectionHint, value) {
+  return page.evaluate((hint, val) => {
+    for (const el of document.querySelectorAll("label, [role='radio'], button")) {
+      if (el.textContent?.trim().toLowerCase() !== val.toLowerCase()) continue;
+      const sec = el.closest("section, fieldset, div");
+      const heading = sec?.querySelector("h2, h3, h4, label, p");
+      if (!heading || heading.textContent?.toLowerCase().includes(hint.toLowerCase())) {
+        el.click();
+        return true;
+      }
+    }
+    return false;
+  }, sectionHint, value);
+}
+
+export async function clickCheckbox(page, textHint) {
+  return page.evaluate((hint) => {
+    for (const el of document.querySelectorAll("label, [role='checkbox'], span, div")) {
+      if (el.textContent?.trim().toLowerCase().includes(hint.toLowerCase())) {
+        const cb = el.querySelector('input[type="checkbox"]') || el;
+        cb.click();
+        return true;
+      }
+    }
+    return false;
+  }, textHint);
+}
+
+export function buildNitroData(user, biz) {
+  const u = user?.profile || {};
+  const b = biz?.profile || {};
+  const fact = (p, k) => getCustomFact(p, k);
+
+  return {
+    fields: [
+      { label: "Company / Project name", value: b.productName || b.companyName || b.name || "" },
+      { label: "Email", value: u.email || "" },
+      { label: "One-line description", value: b.oneLiner || "" },
+      { label: "What are you building", value: b.solution || [b.problem, b.solution].filter(Boolean).join("\n\n"), textarea: true },
+      { label: "Full Name", value: u.fullName || "" },
+      { label: "Role in the company", value: u.currentRole || "" },
+      { label: "X Handle", value: fact(user, "x handle") || fact(user, "twitter") || "" },
+      { label: "LinkedIn username", value: u.linkedIn || "" },
+      { label: "Telegram", value: fact(user, "telegram") || "" },
+      { label: "GitHub username", value: u.github || "" },
+      { label: "Why are you the right founder", value: [u.bio, u.keySkills ? `Key skills: ${u.keySkills}` : "", u.favoriteProjects ? `Notable projects: ${u.favoriteProjects}` : ""].filter(Boolean).join("\n\n"), textarea: true },
+      { label: "video content or long form writing", value: u.portfolio || "", textarea: true },
+      { label: "How did the founders meet", value: fact(user, "founders met") || fact(biz, "founders") || `I'm a solo founder building ${b.productName || b.companyName || "this project"} full-time.`, textarea: true },
+      { label: "Current location of founders", value: u.location || b.location || "" },
+      { label: "how do you plan to spend", value: fact(biz, "spend") || fact(biz, "500k") || "", textarea: true },
+      { label: "What problem are you solving", value: b.problem || "", textarea: true },
+      { label: "closest comparables", value: b.differentiators || "", textarea: true },
+      { label: "Product Link", value: b.website || "" },
+      { label: "What changed in the tech or market", value: fact(biz, "timing") || fact(biz, "why now") || b.rawFacts || "", textarea: true },
+      { label: "Dune Dashboard", value: "" },
+      { label: "Google Analytics", value: "", textarea: true },
+      { label: "target segment", value: b.targetUsers || "", textarea: true },
+      { label: "wedge into the market", value: b.businessModel || b.differentiators || "", textarea: true },
+      { label: "traction have you achieved", value: b.traction || "", textarea: true },
+      { label: "Runway at current burn", value: "12" },
+      { label: "What attracts you the most about Nitro", value: fact(biz, "nitro") || fact(biz, "accelerator") || `The density of high-signal founders and the NYC residency. ${b.productName || "Our product"} is at a stage where concentrated feedback from experienced operators would dramatically accelerate our trajectory.`, textarea: true },
+      { label: "Pick one of the mentors", value: fact(biz, "mentor") || "", textarea: true },
+      { label: "What did you get done last week", value: fact(biz, "last week") || fact(user, "last week") || "", textarea: true },
+    ],
+    radios: [
+      { section: "committed full-time", value: "yes" },
+      { section: "raised funding before", value: "no" },
+      { section: "currently fundraising", value: "yes" },
+      { section: "exclusively in Nitro", value: "yes" },
+      { section: "attend the full 1-month NYC", value: "yes" },
+    ],
+    checkboxes: ["MVP / demo exists"],
+  };
+}
+
+export async function genericFill(page, user, biz) {
+  const u = user?.profile || {};
+  const b = biz?.profile || {};
+  const fact = (p, k) => getCustomFact(p, k);
+
+  const fieldMap = [
+    { hints: ["company", "project name", "organization"], value: b.productName || b.companyName || b.name || "" },
+    { hints: ["email"], value: u.email || "" },
+    { hints: ["full name", "your name", "first name"], value: u.fullName || "" },
+    { hints: ["one-line", "one liner", "tagline", "short description"], value: b.oneLiner || "" },
+    { hints: ["what are you building", "describe your product", "about your project"], value: b.solution || "", textarea: true },
+    { hints: ["role", "title", "position"], value: u.currentRole || "" },
+    { hints: ["x handle", "twitter"], value: fact(user, "x handle") || fact(user, "twitter") || "" },
+    { hints: ["linkedin"], value: u.linkedIn || "" },
+    { hints: ["telegram"], value: fact(user, "telegram") || "" },
+    { hints: ["github"], value: u.github || "" },
+    { hints: ["website", "url", "product link"], value: b.website || u.portfolio || "" },
+    { hints: ["phone", "tel"], value: u.phone || "" },
+    { hints: ["location", "city", "where are you based"], value: u.location || b.location || "" },
+    { hints: ["bio", "about yourself", "tell us about you"], value: u.bio || "", textarea: true },
+    { hints: ["problem", "what problem"], value: b.problem || "", textarea: true },
+    { hints: ["solution", "how does it work"], value: b.solution || "", textarea: true },
+    { hints: ["traction", "progress", "metrics"], value: b.traction || "", textarea: true },
+    { hints: ["target", "customer", "user"], value: b.targetUsers || "", textarea: true },
+    { hints: ["business model", "revenue", "monetiz"], value: b.businessModel || "", textarea: true },
+    { hints: ["differentiator", "competitive", "unique"], value: b.differentiators || "", textarea: true },
+    { hints: ["why you", "right founder", "why are you"], value: u.bio || "", textarea: true },
+  ];
+
+  let filled = 0, skipped = 0;
+  for (const f of fieldMap) {
+    if (!f.value) { skipped++; continue; }
+    for (const hint of f.hints) {
+      const ok = await fillByLabel(page, hint, f.value, { textarea: f.textarea });
+      if (ok) {
+        console.log(`  + "${hint}" = "${f.value.slice(0, 60)}${f.value.length > 60 ? "..." : ""}"`);
+        filled++;
+        break;
+      }
+    }
+  }
+  return { filled, skipped };
+}
+
+export async function fillForm(page, formUrl, user, biz) {
+  console.log(`\n  Filling form...\n`);
+  await sleep(2000);
+
+  if (formUrl.includes("nitroacc.xyz")) {
+    const data = buildNitroData(user, biz);
+    let filled = 0, skipped = 0;
+
+    for (const f of data.fields) {
+      if (!f.value) { skipped++; continue; }
+      const ok = await fillByLabel(page, f.label, f.value, { textarea: f.textarea });
+      if (ok) {
+        console.log(`  + "${f.label}" = "${f.value.slice(0, 60)}${f.value.length > 60 ? "..." : ""}"`);
+        filled++;
+      } else {
+        console.log(`  x "${f.label}" — no matching input found`);
+      }
+      await sleep(150);
+    }
+
+    for (const r of data.radios) {
+      const ok = await clickRadio(page, r.section, r.value);
+      console.log(`  ${ok ? "+" : "x"} radio: "${r.section}" = ${r.value}`);
+      await sleep(200);
+    }
+
+    for (const c of data.checkboxes) {
+      const ok = await clickCheckbox(page, c);
+      console.log(`  ${ok ? "+" : "x"} checkbox: "${c}"`);
+      await sleep(150);
+    }
+
+    console.log(`\n  Filled ${filled}, skipped ${skipped} (empty persona fields).`);
+  } else {
+    const { filled, skipped } = await genericFill(page, user, biz);
+    console.log(`\n  Filled ${filled}, skipped ${skipped} (empty or no match).`);
+  }
+
+  console.log(`\n  FORM NOT SUBMITTED — review in Chrome and submit manually.\n`);
+}

package/lib/local.js

@@ -0,0 +1,156 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+export function findFastformsDir() {
+  const local = join(process.cwd(), ".fastforms");
+  if (existsSync(local)) return local;
+
+  const global = join(homedir(), ".fastforms");
+  if (existsSync(global)) return global;
+
+  return null;
+}
+
+export function ensureDir(dir) {
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function readJson(path) {
+  try { return JSON.parse(readFileSync(path, "utf-8")); } catch { return null; }
+}
+
+function writeJson(path, data) {
+  writeFileSync(path, JSON.stringify(data, null, 2) + "\n");
+}
+
+/**
+ * Normalize flat local format into the shape fill.js expects:
+ *   { name, profile: { ...fields }, customFacts: [...] }
+ */
+function normalizeUser(raw) {
+  if (!raw) return null;
+  const { name, facts, ...rest } = raw;
+  return {
+    name: name || "default",
+    profile: {
+      fullName: rest.fullName || "",
+      email: rest.email || "",
+      phone: rest.phone || "",
+      location: rest.location || "",
+      linkedIn: rest.linkedIn || "",
+      github: rest.github || "",
+      portfolio: rest.portfolio || "",
+      currentRole: rest.role || rest.currentRole || "",
+      bio: rest.bio || "",
+      keySkills: rest.keySkills || "",
+      favoriteProjects: rest.favoriteProjects || "",
+      rawFacts: rest.rawFacts || "",
+    },
+    customFacts: factsToArray(facts),
+    customPreferences: [],
+    dumps: [],
+  };
+}
+
+function normalizeBusiness(raw) {
+  if (!raw) return null;
+  const { name, facts, ...rest } = raw;
+  return {
+    name: name || "default business",
+    profile: {
+      name: name || "",
+      companyName: rest.companyName || rest.company || name || "",
+      productName: rest.productName || rest.product || name || "",
+      website: rest.website || "",
+      category: rest.category || "",
+      location: rest.location || "",
+      oneLiner: rest.oneLiner || "",
+      targetUsers: rest.targetUsers || "",
+      problem: rest.problem || "",
+      solution: rest.solution || "",
+      traction: rest.traction || "",
+      businessModel: rest.businessModel || "",
+      differentiators: rest.differentiators || "",
+      value: rest.value || "",
+      rawFacts: rest.rawFacts || "",
+    },
+    customFacts: factsToArray(facts),
+    customPreferences: [],
+    dumps: [],
+  };
+}
+
+function factsToArray(facts) {
+  if (!facts || typeof facts !== "object") return [];
+  return Object.entries(facts).map(([key, value], i) => ({
+    id: `fact-${i}`,
+    key,
+    value: String(value),
+    enabled: true,
+  }));
+}
+
+export function loadLocalPersonas(dir) {
+  const userPath = join(dir, "user.json");
+  const bizPath = join(dir, "business.json");
+
+  const rawUser = readJson(userPath);
+  const rawBiz = readJson(bizPath);
+
+  const personas = rawUser ? [normalizeUser(rawUser)] : [];
+  const businessPersonas = rawBiz ? [normalizeBusiness(rawBiz)] : [];
+
+  return { personas, businessPersonas };
+}
+
+export function saveUserPersona(dir, data) {
+  ensureDir(dir);
+  writeJson(join(dir, "user.json"), data);
+}
+
+export function saveBusinessPersona(dir, data) {
+  ensureDir(dir);
+  writeJson(join(dir, "business.json"), data);
+}
+
+export function loadDefaults(dir) {
+  return readJson(join(dir, "defaults.json")) || {};
+}
+
+export function saveDefaults(dir, patch) {
+  const current = loadDefaults(dir);
+  writeJson(join(dir, "defaults.json"), { ...current, ...patch });
+}
+
+export function userTemplate() {
+  return {
+    name: "",
+    fullName: "",
+    email: "",
+    role: "",
+    location: "",
+    linkedIn: "",
+    github: "",
+    bio: "",
+    facts: {},
+  };
+}
+
+export function businessTemplate() {
+  return {
+    name: "",
+    oneLiner: "",
+    website: "",
+    category: "",
+    location: "",
+    problem: "",
+    solution: "",
+    targetUsers: "",
+    traction: "",
+    businessModel: "",
+    differentiators: "",
+    facts: {},
+  };
+}

package/lib/personas.js

@@ -0,0 +1,176 @@
+import puppeteer from "puppeteer-core";
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { createInterface } from "readline";
+
+const FASTFORMS_URL = "https://293-fastforms.vercel.app/";
+const PERSONA_URL = "https://293-fastforms.vercel.app/persona";
+const CONFIG_PATH = join(homedir(), ".fastforms.json");
+
+const STORAGE_KEYS = {
+  personas: "fastforms.personas.v1",
+  businessPersonas: "fastforms.businessPersonas.v1",
+  applications: "fastforms.applications.v1",
+};
+
+function loadConfig() {
+  try { return JSON.parse(readFileSync(CONFIG_PATH, "utf-8")); } catch { return {}; }
+}
+
+function saveConfig(patch) {
+  writeFileSync(CONFIG_PATH, JSON.stringify({ ...loadConfig(), ...patch }, null, 2));
+}
+
+function ask(prompt) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((r) => rl.question(prompt, (a) => { rl.close(); r(a.trim()); }));
+}
+
+export async function connectToChrome(port = 9222) {
+  return puppeteer.connect({ browserURL: `http://127.0.0.1:${port}` });
+}
+
+export async function pullPersonas(browser) {
+  const pages = await browser.pages();
+  let tab = pages.find((p) => p.url().includes("293-fastforms"));
+  let opened = false;
+
+  if (tab) {
+    console.log("  Using existing FastForms tab.");
+  } else {
+    tab = await browser.newPage();
+    await tab.goto(FASTFORMS_URL, { waitUntil: "networkidle2", timeout: 30_000 });
+    console.log("  Opened FastForms tab.");
+    opened = true;
+  }
+
+  const dump = await tab.evaluate((keys) => {
+    const out = {};
+    for (const [name, sk] of Object.entries(keys)) {
+      const raw = localStorage.getItem(sk);
+      if (raw) try { out[name] = JSON.parse(raw); } catch { out[name] = raw; }
+    }
+    return out;
+  }, STORAGE_KEYS);
+
+  if (opened) await tab.close();
+  return dump;
+}
+
+export function pickPersona(list, hint, keys) {
+  if (!list?.length) return null;
+  if (!hint) return list[0];
+  const h = hint.toLowerCase();
+  for (const k of keys) {
+    const match = list.find((p) => {
+      const val = k.split(".").reduce((o, s) => o?.[s], p);
+      return typeof val === "string" && val.toLowerCase().includes(h);
+    });
+    if (match) return match;
+  }
+  return list[0];
+}
+
+export function getCustomFact(persona, key) {
+  if (!persona) return "";
+  const h = key.toLowerCase();
+  return (persona.customFacts || []).find(
+    (f) => f.enabled !== false && f.key?.toLowerCase().includes(h)
+  )?.value || "";
+}
+
+function printPersonaSummary(label, persona, profileKeys) {
+  if (!persona) return;
+  const p = persona.profile || {};
+  console.log(`\n  ${label}: ${persona.name}`);
+  for (const [key, display] of profileKeys) {
+    const val = p[key];
+    if (val) console.log(`    ${display}: ${String(val).slice(0, 80)}${String(val).length > 80 ? "..." : ""}`);
+  }
+  const facts = (persona.customFacts || []).filter((f) => f.enabled !== false && f.value);
+  if (facts.length) console.log(`    Custom facts: ${facts.length}`);
+}
+
+export function showPersonaDetails(user, biz) {
+  printPersonaSummary("User persona", user, [
+    ["fullName", "Name"],
+    ["email", "Email"],
+    ["currentRole", "Role"],
+    ["location", "Location"],
+    ["linkedIn", "LinkedIn"],
+    ["github", "GitHub"],
+  ]);
+  printPersonaSummary("Business persona", biz, [
+    ["companyName", "Company"],
+    ["productName", "Product"],
+    ["oneLiner", "One-liner"],
+    ["website", "Website"],
+    ["category", "Category"],
+  ]);
+}
+
+export async function selectPersonas(dump, userHint, bizHint) {
+  const config = loadConfig();
+  const personas = dump.personas || [];
+  const bizPersonas = dump.businessPersonas || [];
+
+  // Use defaults if no hint and defaults are saved
+  const effectiveUserHint = userHint || config.defaultUser || "";
+  const effectiveBizHint = bizHint || config.defaultBusiness || "";
+
+  let user = pickPersona(personas, effectiveUserHint, ["name", "profile.fullName"]);
+  let biz = pickPersona(bizPersonas, effectiveBizHint, ["name", "profile.companyName", "profile.productName"]);
+
+  // Interactive selection if multiple and no effective hint
+  if (!effectiveUserHint && personas.length > 1) {
+    console.log("\n  User personas:\n");
+    personas.forEach((p, i) => console.log(`    ${i + 1}. ${p.name} (${p.profile?.fullName || "?"})`));
+    const ans = await ask(`\n  Pick user persona [1-${personas.length}]: `);
+    const idx = Number(ans) - 1;
+    if (idx >= 0 && idx < personas.length) user = personas[idx];
+  }
+
+  if (!effectiveBizHint && bizPersonas.length > 1) {
+    console.log("\n  Business personas:\n");
+    bizPersonas.forEach((p, i) => console.log(`    ${i + 1}. ${p.name} (${p.profile?.companyName || "?"})`));
+    const ans = await ask(`\n  Pick business persona [1-${bizPersonas.length}]: `);
+    const idx = Number(ans) - 1;
+    if (idx >= 0 && idx < bizPersonas.length) biz = bizPersonas[idx];
+  }
+
+  return { user, biz };
+}
+
+export async function offerSetDefaults(user, biz) {
+  const config = loadConfig();
+  const userChanged = user && config.defaultUser !== user.name;
+  const bizChanged = biz && config.defaultBusiness !== biz.name;
+
+  if (!userChanged && !bizChanged) return;
+
+  const names = [user?.name, biz?.name].filter(Boolean).join(" + ");
+  const ans = await ask(`\n  Save "${names}" as default personas? [y/N]: `);
+  if (ans.toLowerCase() === "y") {
+    const patch = {};
+    if (user) patch.defaultUser = user.name;
+    if (biz) patch.defaultBusiness = biz.name;
+    saveConfig(patch);
+    console.log("  Defaults saved to ~/.fastforms.json");
+  }
+}
+
+export async function offerOpenPersonaManager(browser) {
+  const ans = await ask("\n  Open persona manager in Chrome? [y/N]: ");
+  if (ans.toLowerCase() === "y") {
+    const pages = await browser.pages();
+    const existing = pages.find((p) => p.url().includes("293-fastforms.vercel.app/persona"));
+    if (existing) {
+      await existing.bringToFront();
+    } else {
+      const tab = await browser.newPage();
+      await tab.goto(PERSONA_URL, { waitUntil: "networkidle2", timeout: 30_000 });
+    }
+    console.log("  Opened: " + PERSONA_URL);
+  }
+}

package/lib/platforms.js

@@ -0,0 +1,65 @@
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { execFileSync } from "child_process";
+
+const HOME = homedir();
+
+const PLATFORMS = {
+  darwin: {
+    chromePaths: [
+      "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+      `${HOME}/Applications/Google Chrome.app/Contents/MacOS/Google Chrome`,
+    ],
+    dataDir: join(HOME, "Library", "Application Support", "Google", "Chrome"),
+  },
+  linux: {
+    chromePaths: [
+      "/usr/bin/google-chrome-stable",
+      "/usr/bin/google-chrome",
+      "/usr/bin/chromium-browser",
+      "/usr/bin/chromium",
+      "/snap/bin/chromium",
+    ],
+    dataDir: join(HOME, ".config", "google-chrome"),
+  },
+  win32: {
+    chromePaths: [
+      join(process.env.PROGRAMFILES || "", "Google", "Chrome", "Application", "chrome.exe"),
+      join(process.env["PROGRAMFILES(X86)"] || "", "Google", "Chrome", "Application", "chrome.exe"),
+      join(process.env.LOCALAPPDATA || "", "Google", "Chrome", "Application", "chrome.exe"),
+    ],
+    dataDir: join(process.env.LOCALAPPDATA || "", "Google", "Chrome", "User Data"),
+  },
+};
+
+export function getPlatformConfig() {
+  const cfg = PLATFORMS[process.platform];
+  if (!cfg) throw new Error(`Unsupported platform: ${process.platform}`);
+  return cfg;
+}
+
+export function findChrome() {
+  const { chromePaths } = getPlatformConfig();
+  for (const p of chromePaths) {
+    if (existsSync(p)) return p;
+  }
+  return null;
+}
+
+export function getChromeVersion(chromePath) {
+  try {
+    const raw = execFileSync(chromePath, ["--version"], {
+      encoding: "utf-8",
+      timeout: 5000,
+    }).trim();
+    const match = raw.match(/(\d+)\.\d+\.\d+\.\d+/);
+    return match ? { full: match[0], major: Number(match[1]) } : null;
+  } catch {
+    return null;
+  }
+}
+
+export function getDataDir() {
+  return getPlatformConfig().dataDir;
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@1dolinski/fastforms",
+  "version": "0.1.0",
+  "description": "Fill any form fast. Manage personas on the web, fill forms from your terminal.",
+  "type": "module",
+  "bin": {
+    "fastforms": "./bin/fastforms.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "SKILL.md",
+    "README.md"
+  ],
+  "dependencies": {
+    "puppeteer-core": "^24.39.1"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/1dolinski/fastforms.git"
+  },
+  "license": "MIT",
+  "keywords": [
+    "forms",
+    "automation",
+    "chrome",
+    "puppeteer",
+    "personas"
+  ]
+}