@clubnet/seedclub 0.2.0

package/assets/extensions/seedclub/commands/signals.ts

@@ -0,0 +1,86 @@
+/**
+ * /signals command — quick list/search without LLM.
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { listSignals, searchSignals } from "../tools/signals.js";
+
+const VALID_TYPES = [
+	"twitter_account",
+	"company",
+	"person",
+	"blog",
+	"github_profile",
+	"topic",
+	"newsletter",
+	"podcast",
+	"subreddit",
+	"custom",
+];
+
+const TYPE_ALIASES: Record<string, string> = {
+	twitter: "twitter_account",
+	x: "twitter_account",
+	gh: "github_profile",
+	github: "github_profile",
+	reddit: "subreddit",
+	sub: "subreddit",
+	pod: "podcast",
+	news: "newsletter",
+};
+
+export function registerSignalsCommand(pi: ExtensionAPI) {
+	pi.registerCommand("signals", {
+		description: "List or search signals. Usage: /signals [type|search <query>]",
+		handler: async (args, ctx) => {
+			const parts = (args ?? "").trim().split(/\s+/).filter(Boolean);
+			const subcommand = parts[0]?.toLowerCase() ?? "";
+
+			// Search mode
+			if (subcommand === "search" || subcommand === "find" || subcommand === "s") {
+				const query = parts.slice(1).join(" ");
+				if (!query) {
+					ctx.ui.notify("Usage: /signals search <query>", "warning");
+					return;
+				}
+				const result = await searchSignals({ query, limit: 20 });
+				if ("error" in result) {
+					ctx.ui.notify(String(result.error), "error");
+					return;
+				}
+				if (!result.signals?.length) {
+					ctx.ui.notify(`No signals matching "${query}"`, "info");
+					return;
+				}
+				const lines = result.signals.map((s: any) => {
+					return `  ${s.name} [${s.type}]${s.tags?.length ? ` ${s.tags.join(", ")}` : ""}`;
+				});
+				ctx.ui.notify(`Found ${result.total} signals:\n${lines.join("\n")}`, "info");
+				return;
+			}
+
+			// Type filter mode
+			const typeFilter =
+				TYPE_ALIASES[subcommand] || (subcommand && VALID_TYPES.includes(subcommand) ? subcommand : undefined);
+
+			const result = await listSignals({
+				type: typeFilter,
+				limit: 25,
+			});
+
+			if ("error" in result) {
+				ctx.ui.notify(String(result.error), "error");
+				return;
+			}
+
+			if (!result.signals?.length) {
+				ctx.ui.notify(typeFilter ? `No ${typeFilter} signals` : "No signals yet. Use /add to create some.", "info");
+				return;
+			}
+
+			const lines = result.signals.map((s: any) => `  ${s.name} [${s.type}]`);
+			const header = typeFilter ? `${result.total} ${typeFilter} signals:` : `${result.total} signals:`;
+			ctx.ui.notify(`${header}\n${lines.join("\n")}`, "info");
+		},
+	});
+}

package/assets/extensions/seedclub/commands/sort.ts

@@ -0,0 +1,91 @@
+/**
+ * /sort command — sort unsorted signals into buckets.
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { getApiBase } from "../auth.js";
+import { deleteUnsortedSignals, getUnsortedSignals } from "../tools/signals.js";
+
+export async function runSortFlow(pi: ExtensionAPI, ctx: any, prefetchedResult?: any) {
+	let result = prefetchedResult;
+
+	if (!result) {
+		ctx.ui.notify("Checking for unsorted signals...", "info");
+		result = await getUnsortedSignals();
+		if ("error" in result) {
+			ctx.ui.notify(result.error, "error");
+			return;
+		}
+	}
+
+	const count = result.unsortedCount ?? result.unsorted?.length ?? 0;
+
+	if (count === 0) {
+		ctx.ui.notify("All signals are sorted.", "info");
+		return;
+	}
+
+	const choice = await ctx.ui.select(`${count} unsorted signal${count === 1 ? "" : "s"}`, [
+		"Sort automatically",
+		"Sort manually (browser)",
+		"Delete unsorted signals",
+	]);
+
+	if (!choice) return;
+
+	if (choice === "Sort automatically") {
+		return await autoSort(pi);
+	} else if (choice === "Sort manually (browser)") {
+		return await manualSort(pi, ctx);
+	} else if (choice === "Delete unsorted signals") {
+		const confirm = await ctx.ui.select(`Delete ${count} unsorted signals? This cannot be undone.`, [
+			"Yes, delete unsorted",
+			"Cancel",
+		]);
+		if (confirm !== "Yes, delete unsorted") return;
+		const del = await deleteUnsortedSignals();
+		if ("error" in del) {
+			ctx.ui.notify(del.error, "error");
+		} else {
+			ctx.ui.notify(`Deleted ${del.deleted} signals`, "info");
+		}
+	}
+}
+
+export function registerSortCommand(pi: ExtensionAPI) {
+	pi.registerCommand("sort", {
+		description: "Sort unsorted signals into buckets",
+		handler: async (args, ctx) => {
+			const arg = args?.trim().toLowerCase();
+
+			if (arg === "auto" || arg === "a") {
+				return await autoSort(pi);
+			}
+			if (arg === "manual" || arg === "m" || arg === "browse") {
+				return await manualSort(pi, ctx);
+			}
+
+			return await runSortFlow(pi, ctx);
+		},
+	});
+}
+
+async function autoSort(pi: ExtensionAPI) {
+	pi.sendUserMessage(
+		"Sort my unsorted signals. Call leaf_get_unsorted_signals first. Then score signals in batches of 20 — for each batch, call leaf_submit_sort_scores immediately before moving to the next batch. Score each signal across all 10 buckets (0-1) based on its description/content. If the user has an angel.md, weight toward their thesis. Work fast, don't explain each score.",
+	);
+}
+
+async function manualSort(pi: ExtensionAPI, ctx: any) {
+	const apiBase = getApiBase();
+	const isDev = apiBase.includes("localhost") || apiBase.includes("127.0.0.1");
+	const url = isDev ? `${apiBase}/signals` : "https://beta.seedclub.com/signals";
+
+	ctx.ui.notify(`Opening signals page...\n${url}`, "info");
+
+	const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+
+	pi.exec(openCmd, [url]).catch(() => {
+		ctx.ui.notify(`Couldn't open browser. Visit:\n${url}`, "warning");
+	});
+}

package/assets/extensions/seedclub/dia-cookies.ts

@@ -0,0 +1,126 @@
+/**
+ * Read Twitter cookies directly from Dia browser's cookie database.
+ *
+ * Dia is Chromium-based (The Browser Company) but sweet-cookie doesn't
+ * know about it. We read the encrypted cookies and decrypt them using
+ * the macOS Keychain password, same as Chrome does.
+ */
+
+import { execFileSync } from "node:child_process";
+import { createDecipheriv, pbkdf2Sync } from "node:crypto";
+import { copyFileSync, existsSync, mkdtempSync, unlinkSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+
+const DIA_COOKIES_DB = join(homedir(), "Library/Application Support/Dia/User Data/Default/Cookies");
+
+export function isDiaAvailable(): boolean {
+	return process.platform === "darwin" && existsSync(DIA_COOKIES_DB);
+}
+
+function getKeychainPassword(): string | null {
+	const attempts: string[][] = [
+		["find-generic-password", "-a", "Dia", "-w"],
+		["find-generic-password", "-s", "Dia Safe Storage", "-w"],
+	];
+	for (const args of attempts) {
+		try {
+			return execFileSync("security", args, {
+				encoding: "utf-8",
+				timeout: 5000,
+			}).trim();
+		} catch {}
+	}
+	return null;
+}
+
+function decryptValue(encrypted: Buffer, key: Buffer): string | null {
+	try {
+		const prefix = encrypted.subarray(0, 3).toString("ascii");
+		if (prefix !== "v10" && prefix !== "v11") {
+			return encrypted.toString("utf-8");
+		}
+		const iv = Buffer.alloc(16, " ");
+		const data = encrypted.subarray(3);
+		const decipher = createDecipheriv("aes-128-cbc", key, iv);
+		// Disable auto-padding so we can manually handle the output
+		decipher.setAutoPadding(false);
+		const result = Buffer.concat([decipher.update(data), decipher.final()]);
+
+		// Remove PKCS7 padding
+		const padByte = result[result.length - 1];
+		const unpadded = padByte > 0 && padByte <= 16 ? result.subarray(0, result.length - padByte) : result;
+
+		// The first block (16 bytes) may be garbled due to IV mismatch.
+		// Extract the longest trailing run of printable ASCII — that's the cookie value.
+		const raw = unpadded.toString("binary");
+		const match = raw.match(/[\x20-\x7e]+$/);
+		return match ? match[0] : null;
+	} catch {
+		return null;
+	}
+}
+
+export interface DiaCookieResult {
+	authToken: string;
+	ct0: string;
+	cookieHeader: string;
+}
+
+export function readDiaTwitterCookies(): DiaCookieResult | null {
+	if (!isDiaAvailable()) return null;
+
+	const password = getKeychainPassword();
+	if (!password) return null;
+
+	const key = pbkdf2Sync(password, "saltysalt", 1003, 16, "sha1");
+
+	// Copy DB to avoid lock contention with the running browser
+	const tmp = join(mkdtempSync(join(tmpdir(), "dia-")), "Cookies");
+	try {
+		copyFileSync(DIA_COOKIES_DB, tmp);
+	} catch {
+		return null;
+	}
+
+	try {
+			// Use sqlite3 CLI via stdin to avoid shell quoting issues
+			const sql = `SELECT hex(name), hex(encrypted_value) FROM cookies WHERE (host_key LIKE '%.x.com%' OR host_key LIKE '%.twitter.com%') AND name IN ('auth_token', 'ct0');`;
+			const raw = execFileSync("sqlite3", [tmp], {
+				encoding: "utf-8",
+				timeout: 5000,
+				input: sql,
+			}).trim();
+
+		if (!raw) return null;
+
+		let authToken: string | null = null;
+		let ct0: string | null = null;
+
+		for (const line of raw.split("\n")) {
+			const [hexName, hexValue] = line.split("|");
+			if (!hexName || !hexValue) continue;
+
+			const name = Buffer.from(hexName, "hex").toString("utf-8");
+			const encrypted = Buffer.from(hexValue, "hex");
+			const value = decryptValue(encrypted, key);
+
+			if (name === "auth_token" && value) authToken = value;
+			if (name === "ct0" && value) ct0 = value;
+		}
+
+		if (!authToken || !ct0) return null;
+
+		return {
+			authToken,
+			ct0,
+			cookieHeader: `auth_token=${authToken}; ct0=${ct0}`,
+		};
+	} catch {
+		return null;
+	} finally {
+		try {
+			unlinkSync(tmp);
+		} catch {}
+	}
+}

package/assets/extensions/seedclub/index.ts

@@ -0,0 +1,166 @@
+/**
+ * Seed Club core extension.
+ *
+ * Registers tools, commands, and auth for Seed Network.
+ * Loaded as a pi extension from ~/.seedclub/agent/extensions/
+ */
+
+import { randomBytes } from "node:crypto";
+import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { clearCredentials, setCachedToken } from "./api-client.js";
+import { getApiBase, getStoredToken, storeToken } from "./auth.js";
+import { registerAddInterceptor } from "./commands/add.js";
+import { registerSeedclubCommand } from "./commands/seedclub.js";
+import { registerSortCommand } from "./commands/sort.js";
+import { registerSignalTools } from "./tools/signals.js";
+import { getCurrentUser, registerUtilityTools } from "./tools/utility.js";
+
+export default function (pi: ExtensionAPI) {
+	// Tools (read-only signals + user info)
+	registerSignalTools(pi);
+	registerUtilityTools(pi);
+
+	// Commands — /seedclub menu, /add, /sort
+	registerSeedclubCommand(pi, { connect, disconnect });
+	registerAddInterceptor(pi);
+	registerSortCommand(pi);
+
+	// Show connection status on session start
+	pi.on("session_start", async (_event, ctx) => {
+		const stored = await getStoredToken();
+		if (stored) {
+			const isDev = stored.apiBase?.includes("localhost") || stored.apiBase?.includes("127.0.0.1");
+			ctx.ui.setStatus("seed", `seed: ${stored.email}`);
+			if (isDev) ctx.ui.setStatus("seed-api", `dev: ${stored.apiBase}`);
+		} else if (process.env.SEEDCLUB_TOKEN || process.env.SEED_NETWORK_TOKEN) {
+			ctx.ui.setStatus("seed", "seed: connected (env)");
+		}
+	});
+
+	// --- Auth handlers ---
+
+	async function connect(args: string | undefined, ctx: any) {
+		const token = args?.trim();
+		if (token) {
+			if (!token.startsWith("sn_")) {
+				ctx.ui.notify("Invalid token. Tokens start with sn_", "error");
+				return;
+			}
+			await verifyAndStore(token, ctx);
+			return;
+		}
+
+		const apiBase = getApiBase();
+		const port = await findAvailablePort();
+		const state = randomBytes(16).toString("hex");
+		const authUrl = `${apiBase}/auth/cli/authorize?port=${port}&state=${state}`;
+
+		ctx.ui.notify("Opening browser to sign in...", "info");
+
+		const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+		pi.exec(openCmd, [authUrl]).catch(() => {
+			ctx.ui.notify(`Open this link:\n${authUrl}`, "info");
+		});
+
+		try {
+			const result = await waitForCallback(port, state);
+			await verifyAndStore(result.token, ctx, result.email);
+		} catch (error) {
+			ctx.ui.notify(error instanceof Error ? error.message : "Auth failed", "error");
+		}
+	}
+
+	async function disconnect(ctx: any) {
+		await clearCredentials();
+		ctx.ui.setStatus("seed", undefined);
+		ctx.ui.notify("Logged out", "info");
+	}
+
+	async function verifyAndStore(token: string, ctx: any, emailHint?: string) {
+		const apiBase = getApiBase();
+		await storeToken(token, emailHint || "pending", apiBase);
+		setCachedToken(token, apiBase);
+
+		const result = await getCurrentUser();
+		if ("error" in result) {
+			await clearCredentials();
+			ctx.ui.notify(`Token verification failed: ${result.error}`, "error");
+			return;
+		}
+
+		await storeToken(token, result.email, apiBase);
+		ctx.ui.notify(`Connected as ${result.email}`, "success");
+		ctx.ui.setStatus("seed", `seed: ${result.email}`);
+	}
+}
+
+// --- Helpers ---
+
+function findAvailablePort(): Promise<number> {
+	return new Promise((resolve, reject) => {
+		const server = createServer();
+		server.listen(0, "127.0.0.1", () => {
+			const addr = server.address();
+			if (addr && typeof addr === "object") {
+				server.close(() => resolve(addr.port));
+			} else {
+				reject(new Error("Could not find available port"));
+			}
+		});
+		server.on("error", reject);
+	});
+}
+
+function waitForCallback(port: number, state: string): Promise<{ token: string; email: string }> {
+	return new Promise((resolve, reject) => {
+		const timeout = setTimeout(() => {
+			server.close();
+			reject(new Error("Timed out (5 min)."));
+		}, 300_000);
+
+		const server = createServer((req: IncomingMessage, res: ServerResponse) => {
+			const url = new URL(req.url || "/", `http://127.0.0.1:${port}`);
+			if (url.pathname !== "/callback") {
+				res.writeHead(404);
+				res.end();
+				return;
+			}
+
+			const done = (status: number, body: string) => {
+				res.writeHead(status, { "Content-Type": "text/html; charset=utf-8" });
+				res.end(body);
+				clearTimeout(timeout);
+				server.close();
+			};
+
+			if (url.searchParams.get("state") !== state) {
+				done(400, "<h1>Invalid state</h1>");
+				reject(new Error("Invalid state"));
+				return;
+			}
+			const error = url.searchParams.get("error");
+			if (error) {
+				done(400, `<h1>Failed</h1><p>${error}</p>`);
+				reject(new Error(error));
+				return;
+			}
+			const token = url.searchParams.get("token");
+			if (!token?.startsWith("sn_")) {
+				done(400, "<h1>Invalid token</h1>");
+				reject(new Error("Invalid token"));
+				return;
+			}
+
+			const email = url.searchParams.get("email") || "unknown";
+			done(200, `<h1>Connected</h1><p>Signed in as ${email}. You can close this tab.</p>`);
+			resolve({ token, email });
+		});
+
+		server.listen(port, "127.0.0.1");
+		server.on("error", (err) => {
+			clearTimeout(timeout);
+			reject(err);
+		});
+	});
+}

package/assets/extensions/seedclub/package-lock.json

@@ -0,0 +1,65 @@
+{
+  "name": "seedclub-extension",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "seedclub-extension",
+      "dependencies": {
+        "@connormartin/bird": "0.8.0"
+      }
+    },
+    "node_modules/@connormartin/bird": {
+      "version": "0.8.0",
+      "resolved": "https://registry.npmjs.org/@connormartin/bird/-/bird-0.8.0.tgz",
+      "integrity": "sha512-bFBn158ecVbx/EfFI+yMpSTHrCLp10/dpuuYNcbhrxroZOU9ehnguKp14pLPab6BagL0nDg46JJPOLD99I8KIw==",
+      "dependencies": {
+        "@connormartin/sweet-cookie": "0.1.0",
+        "commander": "^14.0.2",
+        "json5": "^2.2.3",
+        "kleur": "^4.1.5"
+      },
+      "bin": {
+        "bird": "dist/cli.js"
+      },
+      "engines": {
+        "node": ">=22"
+      }
+    },
+    "node_modules/@connormartin/sweet-cookie": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/@connormartin/sweet-cookie/-/sweet-cookie-0.1.0.tgz",
+      "integrity": "sha512-eHOrnuj9M4Th1yWFGvVDm5Pvdxwt0f91/k66cowh5+57t+A5cPWudyaDRQhTE6dPLj8sRanTKB3gYTrspyYuGA==",
+      "engines": {
+        "node": ">=22"
+      }
+    },
+    "node_modules/commander": {
+      "version": "14.0.3",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-14.0.3.tgz",
+      "integrity": "sha512-H+y0Jo/T1RZ9qPP4Eh1pkcQcLRglraJaSLoyOtHxu6AapkjWVCy2Sit1QQ4x3Dng8qDlSsZEet7g5Pq06MvTgw==",
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/kleur": {
+      "version": "4.1.5",
+      "resolved": "https://registry.npmjs.org/kleur/-/kleur-4.1.5.tgz",
+      "integrity": "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==",
+      "engines": {
+        "node": ">=6"
+      }
+    }
+  }
+}

package/assets/extensions/seedclub/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "seedclub-extension",
+  "private": true,
+  "type": "module",
+  "dependencies": {
+    "@connormartin/bird": "0.8.0"
+  },
+  "pi": {
+    "extensions": ["./index.ts"]
+  }
+}

package/assets/extensions/seedclub/tool-utils.ts

@@ -0,0 +1,32 @@
+/**
+ * Wraps a handler function into a tool execute function.
+ * Returns JSON results on success, clear error messages on failure.
+ */
+
+import { NotConnectedError } from "./api-client.js";
+
+export function wrapExecute(fn: (params: any) => Promise<any>) {
+	return async (_toolCallId: string, params: any, _signal: any, _onUpdate: any, _ctx: any) => {
+		try {
+			const result = await fn(params);
+			return {
+				content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
+				details: result ?? {},
+			};
+		} catch (error) {
+			if (error instanceof NotConnectedError) {
+				return {
+					content: [{ type: "text" as const, text: "Not connected to Seed Club. Run /seedclub to authenticate." }],
+					details: { notConnected: true },
+					isError: true,
+				};
+			}
+			const message = error instanceof Error ? error.message : String(error);
+			return {
+				content: [{ type: "text" as const, text: `Error: ${message}` }],
+				details: { error: message },
+				isError: true,
+			};
+		}
+	};
+}