thursday-agent 0.9.0 → 0.10.0

package/seed-skills/insta/instagram/scripts/compose.mjs

@@ -0,0 +1,329 @@
+#!/usr/bin/env node
+/**
+ * Takes pictures through Instagram's post composer up to its last screen — files,
+ * crop set to the post's ratio (the composer starts every post at square), past
+ * filters, caption typed, AI label set — and stops there. It never presses Share:
+ * that is one click on the last screen's header, made only once posting is allowed.
+ *
+ *   node compose.mjs --ratio 4:5 --caption caption.txt [--ai-label] [--shot last.png] <picture>...
+ *   node compose.mjs --discard        close an open composer and throw its draft away
+ */
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { fail, inPage, orFail, parseArgs } from "./lib.mjs";
+import { SEL } from "./selectors.mjs";
+
+const opts = parseArgs();
+
+if (opts.discard) {
+  const done = orFail(
+    await inPage(
+      async (page, { SEL }) => {
+        for (let i = 0; i < 3; i++) {
+          const open = await page.locator(SEL.composer).count();
+          if (!open) return { closed: true };
+          const last = page.locator(SEL.composer).last();
+          // The discard question: a small dialog of two buttons, the first one destructive
+          const confirm =
+            (await last.getAttribute("aria-label")) === null &&
+            (await last.locator("button, [role=button]").count()) === 2 &&
+            (await last.locator(SEL.caption).count()) === 0;
+          if (confirm)
+            await last.locator("button, [role=button]").first().click();
+          else await page.keyboard.press("Escape");
+          await page.waitForTimeout(1000);
+        }
+        return (await page.locator(SEL.composer).count())
+          ? {
+              error:
+                "The composer did not close. Snapshot it and close it by hand.",
+            }
+          : { closed: true };
+      },
+      { SEL },
+    ),
+  );
+  if (done.closed) console.log("No composer open; any draft was discarded.");
+  process.exit(0);
+}
+
+const files = opts._.map((f) => resolve(f));
+const ratio = String(opts.ratio ?? "");
+if (!files.length || !SEL.cropOptions.includes(ratio) || !opts.caption)
+  fail(
+    `usage: node compose.mjs --ratio ${SEL.cropOptions.join("|")} --caption <file> [--ai-label] [--shot last.png] <picture>...`,
+  );
+if (files.length > 20) fail("A post holds at most 20 pictures.");
+const caption = readFileSync(opts.caption, "utf8").replace(/\r/g, "").trim();
+if (caption.length > 2200)
+  fail(`The caption is ${caption.length} characters; the limit is 2200.`);
+
+const started = Date.now();
+const done = orFail(
+  await inPage(
+    async (page, { files, ratio, caption, aiLabel, shot, SEL }) => {
+      const dialog = () => page.locator(SEL.composer).last();
+      if (
+        (await page.locator(`${SEL.composer} ${SEL.caption}`).count()) ||
+        (await page.locator(`${SEL.composer} ${SEL.fileInput}`).count())
+      )
+        return {
+          error:
+            "A composer is already open. Run with --discard first, or finish it by hand.",
+        };
+      if (
+        !/instagram\.com/.test(page.url()) ||
+        /\/accounts\/|\/challenge\//.test(page.url())
+      )
+        await page.goto("https://www.instagram.com/", {
+          waitUntil: "domcontentloaded",
+        });
+
+      // A narrow window swaps the sidebar for a bottom bar in another order: work wide
+      const viewport = page.viewportSize();
+      if (viewport && viewport.width < SEL.wideWidth)
+        await page.setViewportSize({
+          width: SEL.wideWidth,
+          height: Math.max(viewport.height, 900),
+        });
+
+      // Create, then the menu's first entry (Post), until a dialog takes files. The
+      // menu's entries land in the page right after Create's own link
+      const shown = () =>
+        page.locator(SEL.sidebarAction).evaluateAll((all) =>
+          all.map((a, i) => ({
+            i,
+            x: a.getBoundingClientRect().x,
+            w: a.getBoundingClientRect().width,
+          })),
+        );
+      await page
+        .locator(SEL.sidebarAction)
+        .first()
+        .waitFor({ timeout: 15000 })
+        .catch(() => {});
+      const side = (await shown()).filter((a) => a.w > 0 && a.x < 120);
+      if (side.length <= SEL.createIndex)
+        return {
+          error:
+            "Selectors changed: no Create entry in the sidebar (SEL.sidebarAction). Snapshot and fix selectors.mjs.",
+        };
+      const create = side[SEL.createIndex].i;
+      const input = page.locator(`${SEL.composer} ${SEL.fileInput}`);
+      // Twice at most: a menu left open closes on the first press
+      for (let i = 0; i < 2 && !(await input.count()); i++) {
+        const count = await page.locator(SEL.sidebarAction).count();
+        await page.locator(SEL.sidebarAction).nth(create).click();
+        await page.waitForTimeout(1000);
+        if ((await page.locator(SEL.sidebarAction).count()) > count) {
+          await page
+            .locator(SEL.sidebarAction)
+            .nth(create + 1)
+            .click();
+          await input
+            .waitFor({ state: "attached", timeout: 8000 })
+            .catch(() => {});
+        }
+      }
+      if (!(await input.count())) {
+        await page.keyboard.press("Escape");
+        return {
+          error:
+            "Selectors changed: Create did not open a composer that takes files (SEL.createIndex). Snapshot and fix selectors.mjs.",
+        };
+      }
+      await input.setInputFiles(files);
+
+      // The crop step: files taken, a preview drawn
+      const cropping = await page
+        .waitForFunction(
+          (SEL) => {
+            const d = [...document.querySelectorAll(SEL.composer)].at(-1);
+            return (
+              d &&
+              !d.querySelector(SEL.fileInput) &&
+              [...d.querySelectorAll(SEL.preview)].some(
+                (i) => i.getBoundingClientRect().width > 200,
+              )
+            );
+          },
+          SEL,
+          { timeout: 30000 },
+        )
+        .then(() => true)
+        .catch(() => false);
+      if (!cropping)
+        return {
+          error:
+            "The composer did not reach its crop step after the files went in (a file refused, or the page changed). Snapshot and look.",
+        };
+
+      // The crop toggle is the leftmost icon along the preview's bottom edge
+      const toggled = await dialog().evaluate((d) => {
+        const box = d.getBoundingClientRect();
+        const icons = [...d.querySelectorAll("button, [role=button]")]
+          .filter((b) => !b.innerText.trim() && b.querySelector("svg"))
+          .map((b) => ({ b, r: b.getBoundingClientRect() }))
+          .filter(({ r }) => r.width > 0 && r.bottom > box.bottom - 90)
+          .sort((a, b) => a.r.x - b.r.x);
+        if (!icons.length) return false;
+        icons[0].b.setAttribute("data-kit-crop", "");
+        return true;
+      });
+      if (!toggled)
+        return {
+          error:
+            "Selectors changed: no crop control on the crop step. Snapshot and fix compose.mjs.",
+        };
+      await page.locator("[data-kit-crop]").first().click();
+      await page.waitForTimeout(700);
+      const picked = await dialog().evaluate((d, ratio) => {
+        const options = [...d.querySelectorAll("button, [role=button]")];
+        const square = options.findIndex((b) =>
+          b.textContent.trim().startsWith("1:1"),
+        );
+        if (square < 1) return false;
+        const target =
+          ratio === "original"
+            ? options[square - 1]
+            : options.find((b) => b.textContent.trim().startsWith(ratio));
+        if (!target) return false;
+        target.setAttribute("data-kit-ratio", "");
+        return true;
+      }, ratio);
+      if (!picked)
+        return {
+          error:
+            "Selectors changed: the crop menu has no ratio options. Snapshot and fix compose.mjs.",
+        };
+      await page.locator("[data-kit-ratio]").click();
+      await page.waitForTimeout(800);
+      // The crop is the frame the picture shows through, not the picture itself
+      const measured = await dialog().evaluate((d, preview) => {
+        const el = [...d.querySelectorAll(preview)]
+          .filter((e) => e.getBoundingClientRect().width > 200)
+          .sort(
+            (a, b) =>
+              b.getBoundingClientRect().width - a.getBoundingClientRect().width,
+          )[0];
+        if (!el) return null;
+        let { left, top, right, bottom } = el.getBoundingClientRect();
+        for (
+          let a = el.parentElement;
+          a && a !== d.parentElement;
+          a = a.parentElement
+        ) {
+          if (getComputedStyle(a).overflow === "visible") continue;
+          const r = a.getBoundingClientRect();
+          left = Math.max(left, r.left);
+          top = Math.max(top, r.top);
+          right = Math.min(right, r.right);
+          bottom = Math.min(bottom, r.bottom);
+        }
+        return bottom > top ? (right - left) / (bottom - top) : null;
+      }, SEL.preview);
+      const want = { "1:1": 1, "4:5": 0.8, "16:9": 16 / 9 }[ratio];
+      if (want && (!measured || Math.abs(measured - want) / want > 0.03))
+        return {
+          error: `The crop did not take: the preview is ${measured?.toFixed(3)} wide per tall, not ${ratio}. Snapshot and set it by hand.`,
+        };
+      await page
+        .locator("[data-kit-crop]")
+        .first()
+        .click()
+        .catch(() => {});
+
+      // Crop, then filters, then the caption: two Nexts and never a third, since the
+      // caption step's header button in the same place is Share
+      for (let i = 0; i < 2; i++) {
+        if (await dialog().locator(SEL.caption).count()) break;
+        const before = await dialog().getAttribute("aria-label");
+        const next = await dialog().evaluate((d) => {
+          const top = d.getBoundingClientRect().top;
+          const header = [...d.querySelectorAll("button, [role=button]")]
+            .map((b) => ({ b, r: b.getBoundingClientRect() }))
+            .filter(
+              ({ b, r }) =>
+                b.innerText.trim() && r.width > 0 && r.top < top + 60,
+            )
+            .sort((a, b) => b.r.x - a.r.x)[0];
+          if (!header) return false;
+          for (const e of d.querySelectorAll("[data-kit-next]"))
+            e.removeAttribute("data-kit-next");
+          header.b.setAttribute("data-kit-next", "");
+          return true;
+        });
+        if (!next)
+          return {
+            error:
+              "Selectors changed: no Next in the composer's header. Snapshot and go on by hand.",
+          };
+        await dialog().locator("[data-kit-next]").click();
+        await page
+          .waitForFunction(
+            ([sel, before]) =>
+              [...document.querySelectorAll(sel)]
+                .at(-1)
+                ?.getAttribute("aria-label") !== before,
+            [SEL.composer, before],
+            { timeout: 10000 },
+          )
+          .catch(() => {});
+      }
+      const box = dialog().locator(SEL.caption).first();
+      await box.waitFor({ timeout: 10000 }).catch(() => {});
+      if (!(await box.count()))
+        return {
+          error:
+            "The composer did not reach its caption step in two Nexts. Snapshot and go on by hand.",
+        };
+
+      let label = null;
+      const toggle = dialog().locator(SEL.aiLabel).first();
+      if (await toggle.count()) {
+        // The input itself does not take a click; the switch drawn around it does
+        if ((await toggle.isChecked()) !== aiLabel)
+          await toggle.locator("xpath=..").click({ timeout: 5000 });
+        await page.waitForTimeout(400);
+        label = await toggle.isChecked();
+      }
+      await box.click();
+      const lines = caption.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        if (i) await page.keyboard.press("Enter");
+        if (lines[i]) await page.keyboard.insertText(lines[i]);
+      }
+      await page.waitForTimeout(500);
+      const typed = (await box.innerText()).replace(/\r/g, "").trim();
+
+      // Close the tag suggestions typing a # opens, without Escape (which asks to discard)
+      await dialog()
+        .locator("h1, h2, [role=heading]")
+        .first()
+        .click({ timeout: 3000 })
+        .catch(() => {});
+      await page.waitForTimeout(300);
+      if (shot) await dialog().screenshot({ path: shot, scale: "css" });
+      if (viewport && viewport.width < SEL.wideWidth)
+        await page.setViewportSize(viewport);
+      return { measured, typed, label };
+    },
+    {
+      files,
+      ratio,
+      caption,
+      aiLabel: Boolean(opts["ai-label"]),
+      shot: opts.shot ? resolve(opts.shot) : null,
+      SEL,
+    },
+  ),
+);
+
+const same = done.typed.replace(/\s+/g, " ") === caption.replace(/\s+/g, " ");
+console.log(
+  `On the last screen: ${files.length} picture(s) at ${ratio}${done.measured ? ` (preview ${done.measured.toFixed(3)})` : ""}, ` +
+    `caption ${done.typed.length} chars${same ? "" : " — NOT the same as the file; fix it in the composer"}, ` +
+    `AI label ${done.label === null ? "not offered" : done.label ? "on" : "off"}. Share is not pressed.` +
+    `${opts.shot ? ` Screenshot: ${resolve(opts.shot)}.` : ""} ${((Date.now() - started) / 1000).toFixed(1)}s`,
+);
+if (!same) process.exit(1);

package/seed-skills/insta/instagram/scripts/image-size.mjs

@@ -0,0 +1,30 @@
+import { closeSync, openSync, readSync } from "node:fs";
+
+/** Width and height of a PNG or JPEG, read from its header; null for anything else. */
+export function imageSize(path) {
+  const fd = openSync(path, "r");
+  try {
+    const head = Buffer.alloc(64 * 1024);
+    const n = readSync(fd, head, 0, head.length, 0);
+    if (head.readUInt32BE(0) === 0x89504e47)
+      return { w: head.readUInt32BE(16), h: head.readUInt32BE(20) };
+    if (head[0] === 0xff && head[1] === 0xd8) {
+      // Walk the JPEG segments to the first frame header
+      for (let i = 2; i + 9 < n; ) {
+        if (head[i] !== 0xff) return null;
+        const marker = head[i + 1];
+        const len = head.readUInt16BE(i + 2);
+        if (
+          marker >= 0xc0 &&
+          marker <= 0xcf &&
+          ![0xc4, 0xc8, 0xcc].includes(marker)
+        )
+          return { w: head.readUInt16BE(i + 7), h: head.readUInt16BE(i + 5) };
+        i += 2 + len;
+      }
+    }
+    return null;
+  } finally {
+    closeSync(fd);
+  }
+}

package/seed-skills/insta/instagram/scripts/inbox.mjs

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+/**
+ * Lists DM threads from the inbox page without opening any of them — opening a
+ * thread marks it seen. One line a thread: unread mark, name, last message, when, id.
+ *
+ *   node inbox.mjs [--folder primary|general|requests] [--max 30] [--unread] [--json]
+ */
+import { fail, inPage, oneLine, orFail, parseArgs, stamp } from "./lib.mjs";
+import { SEL } from "./selectors.mjs";
+
+const opts = parseArgs();
+const folder = opts.folder ?? "primary";
+if (!SEL.folders[folder])
+  fail(`--folder is one of ${Object.keys(SEL.folders).join(", ")}`);
+const max = Number(opts.max ?? 30);
+
+const started = Date.now();
+const found = orFail(
+  await inPage(
+    async (page, { url, tab, SEL, max }) => {
+      if (!page.url().startsWith(url))
+        await page.goto(url, { waitUntil: "domcontentloaded" });
+      if (tab != null) {
+        const pick = page.locator(SEL.folderTab).nth(tab);
+        await pick.waitFor({ timeout: 15000 }).catch(() => {});
+        if (
+          (await pick.count()) &&
+          (await pick.getAttribute("aria-selected")) !== "true"
+        )
+          await pick.click();
+      }
+      // Loaded when the list is there and its loading placeholders are gone
+      await page
+        .waitForFunction(
+          (SEL) => {
+            const list = document.querySelector(SEL.inboxList);
+            return (
+              list &&
+              (list.querySelector(SEL.inboxRow) ||
+                !list.querySelector("[role=status]"))
+            );
+          },
+          SEL,
+          { timeout: 15000 },
+        )
+        .catch(() => {});
+      await page.waitForTimeout(500);
+
+      const count = () =>
+        page.evaluate(
+          (SEL) =>
+            document.querySelectorAll(`${SEL.inboxList} ${SEL.inboxRow}`)
+              .length,
+          SEL,
+        );
+      // More threads load as the list scrolls
+      for (let n = await count(), tries = 0; n < max && tries < 20; tries++) {
+        await page.evaluate((SEL) => {
+          const row = document.querySelector(
+            `${SEL.inboxList} ${SEL.inboxRow}`,
+          );
+          for (let e = row?.parentElement; e; e = e.parentElement)
+            if (e.scrollHeight > e.clientHeight + 4) {
+              e.scrollTop = e.scrollHeight;
+              break;
+            }
+        }, SEL);
+        const grew = await page
+          .waitForFunction(
+            ([SEL, n]) =>
+              document.querySelectorAll(`${SEL.inboxList} ${SEL.inboxRow}`)
+                .length > n,
+            [SEL, n],
+            { timeout: 3000 },
+          )
+          .then(() => true)
+          .catch(() => false);
+        if (!grew) break;
+        n = await count();
+      }
+
+      return page.evaluate(
+        ({ SEL, max }) => {
+          if (/\/accounts\/login|\/challenge\//.test(location.pathname))
+            return {
+              error: `Not signed in (${location.pathname}). Borrow the kept sign-in, goto the inbox, run again.`,
+            };
+          const list = document.querySelector(SEL.inboxList);
+          if (!list)
+            return {
+              error: document.querySelector("main")
+                ? "Selectors changed: no thread list (SEL.inboxList). Snapshot the inbox once and fix selectors.mjs."
+                : "No inbox on the page: something covers it (a dialog, a daily time-limit screen). Snapshot, close it, run again.",
+            };
+          const fiberOf = (el) =>
+            el[Object.keys(el).find((k) => k.startsWith("__reactFiber"))];
+          const findProp = (el, name) => {
+            for (let f = fiberOf(el), d = 0; f && d < 30; f = f.return, d++) {
+              const p = f.memoizedProps;
+              if (!p || typeof p !== "object") continue;
+              if (p[name] != null) return p[name];
+              for (const v of Object.values(p))
+                if (v && typeof v === "object" && v[name] != null)
+                  return v[name];
+            }
+            return null;
+          };
+          const rows = [...list.querySelectorAll(SEL.inboxRow)].slice(0, max);
+          const threads = rows.map((row) => {
+            const lines = row.innerText
+              .split("\n")
+              .map((l) => l.trim())
+              .filter((l) => l && l !== "·");
+            const abbr = row.querySelector("abbr");
+            return {
+              id: findProp(row, SEL.threadIdProp),
+              name: lines[0] ?? "",
+              last: lines[1] ?? "",
+              ago: abbr?.getAttribute("aria-label") || abbr?.innerText || "",
+              at: Number(findProp(row, SEL.lastActivityProp)) || null,
+              unread: [...row.querySelectorAll("span")].some(
+                (s) =>
+                  Number(getComputedStyle(s).fontWeight) >= SEL.unreadWeight,
+              ),
+            };
+          });
+          if (threads.length && threads.every((t) => !t.id))
+            return {
+              error:
+                "Selectors changed: rows found but no thread id (SEL.threadIdProp). Fix selectors.mjs.",
+            };
+          return { threads };
+        },
+        { SEL, max },
+      );
+    },
+    {
+      url: `https://www.instagram.com${SEL.folders[folder].url}`,
+      tab: SEL.folders[folder].tab,
+      SEL,
+      max,
+    },
+  ),
+);
+
+let threads = found.threads;
+if (opts.unread) threads = threads.filter((t) => t.unread);
+if (opts.json) {
+  process.stdout.write(`${JSON.stringify(threads)}\n`);
+} else {
+  for (const t of threads)
+    console.log(
+      `${t.unread ? "* " : "  "}${oneLine(t.name, 40)} — ${oneLine(t.last, 80)} · ${t.at ? stamp(t.at) : t.ago} · ${t.id ?? "no id"}`,
+    );
+  const unread = found.threads.filter((t) => t.unread).length;
+  console.log(
+    `${found.threads.length} threads in ${folder}, ${unread} unread (*). ${((Date.now() - started) / 1000).toFixed(1)}s`,
+  );
+}

package/seed-skills/insta/instagram/scripts/lib.mjs

@@ -0,0 +1,91 @@
+import { execFile } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+/**
+ * Runs `fn(page, args, helpers)` in this shell's own browser session
+ * (PLAYWRIGHT_CLI_SESSION) through `playwright-cli run-code`, and resolves to what
+ * it returned. `fn` and each helper are sent as source, so they see nothing of
+ * their module: what they need comes in `args`. They run in a bare VM beside the
+ * browser — no timers, no require — so waits are `page.waitForTimeout` and
+ * `page.waitForFunction`, and files are written by the caller from what returns.
+ */
+export async function inPage(fn, args = {}, helpers = {}) {
+  const lib = Object.entries(helpers)
+    .map(([name, helper]) => `${name}: ${helper}`)
+    .join(", ");
+  const code = `async page => (${fn})(page, ${JSON.stringify(args)}, { ${lib} })`;
+  // One argument is capped (128 KB on Linux): longer code goes as a file
+  const dir = code.length > 64_000 ? mkdtempSync(join(tmpdir(), "run-")) : null;
+  if (dir) writeFileSync(join(dir, "code.js"), code);
+  const out = await new Promise((resolve) =>
+    execFile(
+      "playwright-cli",
+      dir
+        ? ["--raw", "run-code", `--filename=${join(dir, "code.js")}`]
+        : ["--raw", "run-code", code],
+      { encoding: "utf8", maxBuffer: 256 * 1024 * 1024 },
+      (error, stdout, stderr) => {
+        if (dir) rmSync(dir, { recursive: true, force: true });
+        if (!error) return resolve(stdout.trim());
+        const said = `${stdout ?? ""}${stderr ?? ""}`.trim();
+        fail(
+          /not open|no (open )?browser/i.test(said)
+            ? "No browser is open in this session. `playwright-cli open`, sign in, then run this again."
+            : `The browser answered with an error:\n${said.slice(0, 800)}`,
+        );
+      },
+    ),
+  );
+  if (!out) return undefined;
+  try {
+    return JSON.parse(out);
+  } catch {
+    fail(`Unexpected answer from the browser:\n${out.slice(0, 800)}`);
+  }
+}
+
+/** `--name value` and `--flag` pairs, and the rest as positionals. */
+export function parseArgs(argv = process.argv.slice(2)) {
+  const opts = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (!a.startsWith("--")) {
+      opts._.push(a);
+      continue;
+    }
+    const [key, inline] = a.slice(2).split("=", 2);
+    if (inline !== undefined) opts[key] = inline;
+    else if (argv[i + 1] !== undefined && !argv[i + 1].startsWith("--"))
+      opts[key] = argv[++i];
+    else opts[key] = true;
+  }
+  return opts;
+}
+
+export function fail(message) {
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+}
+
+/** A page-side answer `{ error }` stops the script with that message. */
+export function orFail(result) {
+  if (result && typeof result === "object" && result.error) fail(result.error);
+  return result;
+}
+
+/** Local time, minutes precision: what a person reads, and what `--since` takes. */
+export const stamp = (ms) => {
+  if (!ms) return "?";
+  const d = new Date(Number(ms));
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
+};
+
+export const oneLine = (text, max) => {
+  const flat = String(text ?? "")
+    .replace(/\s+/g, " ")
+    .trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+};