loopable-cli 0.1.0

package/.output/server/_ssr/connections-qnw2GVlP.mjs

@@ -0,0 +1,2542 @@
+import { d as and, f as eq, h as lt, l as asc } from "../_libs/drizzle-orm.mjs";
+import { a as connections, i as authAttempts, s as db } from "./client-CKkOfh-s.mjs";
+import { i as readCredential, s as writeCredential, t as deleteCredential } from "./secrets-Hqti-niS.mjs";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+//#region node_modules/.nitro/vite/services/ssr/assets/connections-qnw2GVlP.js
+function defineManifest(manifest) {
+	return manifest;
+}
+function defineRuntime(runtime) {
+	return runtime;
+}
+var GITHUB_SCOPES = ["repo", "notifications"];
+var repositories = {
+	key: "repositories",
+	kind: "string_list",
+	label: "Repositories",
+	help: "owner/name, one per line. Wildcards work: acme/* or */*. Leave empty for every repository you can see.",
+	placeholder: "acme/web"
+};
+var ignoreDrafts = {
+	key: "ignoreDrafts",
+	kind: "boolean",
+	label: "Skip draft pull requests",
+	default: true
+};
+var ignoreBots = {
+	key: "ignoreBots",
+	kind: "boolean",
+	label: "Skip pull requests opened by bots",
+	help: "Dependabot and friends open a great many, and each one costs a full run.",
+	default: true
+};
+/**
+* Not a quality setting so much as a cost one: the largest pull requests give
+* the shallowest reviews and take the longest to produce them.
+*/
+var sizeLimit = {
+	key: "maxChangedFiles",
+	kind: "select",
+	label: "Skip very large pull requests",
+	options: [
+		{
+			value: "0",
+			label: "Never skip"
+		},
+		{
+			value: "25",
+			label: "More than 25 files changed"
+		},
+		{
+			value: "50",
+			label: "More than 50 files changed"
+		},
+		{
+			value: "100",
+			label: "More than 100 files changed"
+		}
+	],
+	default: "50"
+};
+/**
+* Left empty by every loop that answers what it read, which is most of them.
+* Filled in when the trigger is somewhere else entirely and there is no issue
+* in it to comment on.
+*/
+var issueTarget = {
+	key: "issue",
+	kind: "text",
+	label: "Issue or pull request",
+	help: "A GitHub URL. Leave empty to write back to whatever triggered the loop.",
+	placeholder: "https://github.com/acme/web/issues/12"
+};
+/**
+* Written once, here, rather than left to whoever creates the loop. A review
+* is a well-understood job and the connector should be good at it by default.
+*/
+var REVIEW_PROMPT = [
+	"Review this pull request the way an experienced engineer on this team would.",
+	"",
+	"Look for correctness bugs, security problems, races, unhandled errors, and",
+	"changes that quietly break existing behaviour. Check whether the change is",
+	"tested, and say plainly when it is not.",
+	"",
+	"Point at specific files and lines rather than describing the change back to",
+	"its author. Say when something is done well; a review that lists only faults",
+	"reads as hostile. Skip anything a linter or formatter already enforces, and",
+	"do not restate what the diff obviously does.",
+	"",
+	"Where you cannot see enough of the code to judge something, say so instead of",
+	"guessing."
+].join("\n");
+var PLAN_PROMPT = [
+	"Write a short implementation plan for this issue.",
+	"",
+	"Say what should change, in which files where you can tell, and what to watch",
+	"out for. Stay inside what the issue actually supports: if it is too vague to",
+	"plan, say what is missing rather than inventing the requirements.",
+	"",
+	"Do not write the implementation."
+].join("\n");
+var IMPLEMENT_PROMPT = [
+	"Implement this issue in the checkout you are in.",
+	"",
+	"Read enough of the surrounding code first that what you write looks like it",
+	"belongs: the same patterns, the same names, the same way of handling errors.",
+	"Where the project has tests for work like this, add one.",
+	"",
+	"Stay inside what the issue asks for. A change that also tidies three other",
+	"things is a change nobody can review. If the issue is too vague to implement,",
+	"or doing it properly needs a decision that is not yours to make, reply with",
+	"exactly NOTHING_TO_DO rather than guessing: an unwanted pull request costs",
+	"more attention than a missing one.",
+	"",
+	"Run the project's tests if you can work out how, and say in your description",
+	"whether you did and what happened."
+].join("\n");
+var githubManifest = defineManifest({
+	id: "github",
+	name: "GitHub",
+	tagline: "Pick up review requests and assigned issues.",
+	docsUrl: "https://docs.github.com/rest",
+	icon: "Github",
+	accent: "bg-neutral-900 text-white",
+	auth: {
+		kind: "oauth_redirect",
+		scopes: GITHUB_SCOPES,
+		needsAppRegistration: true
+	},
+	workflows: [
+		{
+			id: "github.review_requested",
+			name: "Review pull requests I am asked to review",
+			summary: "Reads the change and posts a review whenever someone asks for yours.",
+			trigger: "your review is requested, either directly or through a team you belong to",
+			watches: "is:open is:pr review-requested:@me",
+			writes: "a review on the pull request, as a comment rather than an approval",
+			settings: [
+				repositories,
+				ignoreDrafts,
+				ignoreBots,
+				sizeLimit
+			],
+			prompt: REVIEW_PROMPT,
+			guidancePlaceholder: "Anything specific to your team. For example: we require a test for every new endpoint.",
+			answer: "review",
+			runsIn: "checkout",
+			actionId: "github.submit_review"
+		},
+		{
+			id: "github.issue_assigned",
+			name: "Plan issues assigned to me",
+			summary: "Posts a short implementation plan when an issue lands on you.",
+			trigger: "an issue is assigned to you",
+			watches: "is:open is:issue assignee:@me",
+			writes: "a comment on the issue",
+			settings: [repositories],
+			prompt: PLAN_PROMPT,
+			guidancePlaceholder: "Anything specific to this codebase worth knowing before planning.",
+			answer: "text",
+			runsIn: "checkout",
+			actionId: "github.post_issue_comment"
+		},
+		{
+			id: "github.issue_implement",
+			name: "Implement issues assigned to me",
+			summary: "Writes the change and opens a draft pull request.",
+			trigger: "an issue is assigned to you",
+			watches: "is:open is:issue assignee:@me",
+			writes: "a draft pull request",
+			runsIn: "checkout",
+			settings: [repositories],
+			prompt: IMPLEMENT_PROMPT,
+			guidancePlaceholder: "How work is done here. For example: every new endpoint needs a test, and we do not add dependencies without asking.",
+			answer: "code",
+			actionId: "github.open_pull_request"
+		}
+	],
+	actions: [
+		{
+			id: "github.submit_review",
+			name: "Submit a review",
+			summary: "Post a review on a pull request, as a comment rather than an approval.",
+			target: [],
+			accepts: ["text", "review"]
+		},
+		{
+			id: "github.post_issue_comment",
+			name: "Comment on an issue",
+			summary: "Post a comment on an issue or pull request.",
+			target: [issueTarget],
+			accepts: ["text"]
+		},
+		{
+			id: "github.open_pull_request",
+			name: "Open a draft pull request",
+			summary: "Open a draft pull request for the branch the agent already pushed.",
+			target: [],
+			accepts: ["code"]
+		}
+	],
+	settings: [],
+	allowsMultipleAccounts: false,
+	byHand: {
+		kind: "link",
+		placeholder: "https://github.com/acme/web/pull/123"
+	}
+});
+/**
+* Reading is the whole of it. Gmail has no send scope here on purpose: an
+* agent that can reply as you, to anyone, is a different and much larger thing
+* to agree to than one that reads your inbox and tells you about it.
+*/
+var GMAIL_SCOPES = ["https://www.googleapis.com/auth/gmail.readonly"];
+/**
+* Gmail's own search, appended to what the workflow already asks. This is the
+* setting that makes the difference between a useful loop and a firehose, so
+* it leads.
+*/
+var extraQuery = {
+	key: "extraQuery",
+	kind: "text",
+	label: "Narrow it down",
+	help: "Gmail search terms, added to the query above. For example: from:bank.example.com, or subject:invoice, or -from:notifications@github.com.",
+	placeholder: "from:boss@example.com"
+};
+/**
+* A cap on how many mails one look can turn into runs, which is a cost limit
+* rather than a filter: every mail past it is still noticed on the next poll,
+* because nothing has marked it as dealt with.
+*/
+var perPoll = {
+	key: "maxPerPoll",
+	kind: "select",
+	label: "At most, per look",
+	help: "Each mail costs a full agent run. A quiet mailbox never reaches this; a busy one should be narrowed above rather than raised here.",
+	options: [
+		{
+			value: "3",
+			label: "3 messages"
+		},
+		{
+			value: "10",
+			label: "10 messages"
+		},
+		{
+			value: "25",
+			label: "25 messages"
+		}
+	],
+	default: "10"
+};
+/**
+* The setting that decides whether a quiet mailbox is quiet. Without it every
+* receipt arrives as a notification saying a receipt arrived, which costs a
+* run each and trains you to stop looking.
+*/
+var needsMeOnly = {
+	key: "needsMeOnly",
+	kind: "boolean",
+	label: "Only tell me when it needs me",
+	help: "One cheap look at everything that arrived decides which mails are actually asking something of you, from the sender, subject and first line. The rest wait in the backlog with a reason, so you can still run one if this got it wrong.",
+	default: true
+};
+var skipOwn = {
+	key: "skipOwn",
+	kind: "boolean",
+	label: "Skip mail I sent",
+	help: "Your own messages show up in threads you are part of, and being told about what you just sent is not useful.",
+	default: true
+};
+var TELL_ME_PROMPT = [
+	"Read the email in EMAIL.md and tell me what it says.",
+	"",
+	"You are writing a phone notification, not a summary document. Two or three",
+	"sentences. No headings, no bullet lists, no preamble like \"this email is\".",
+	"Lead with who it is from and what they want.",
+	"",
+	"Say plainly if it needs something from me and by when. If there is a",
+	"deadline, an amount of money, a date, or a link I have to act on, include it",
+	"exactly as written rather than describing it.",
+	"",
+	"If it is an automated notification, a newsletter, or otherwise needs nothing",
+	"from me, say so in one line and stop."
+].join("\n");
+var gmailManifest = defineManifest({
+	id: "gmail",
+	name: "Gmail",
+	tagline: "Read new mail and have an agent tell you what matters.",
+	docsUrl: "https://developers.google.com/gmail/api/guides",
+	icon: "Gmail",
+	accent: "bg-[#ea4335] text-white",
+	auth: {
+		kind: "oauth_redirect",
+		scopes: GMAIL_SCOPES,
+		needsAppRegistration: true
+	},
+	workflows: [{
+		id: "gmail.new_mail",
+		name: "Tell me about new mail",
+		summary: "Reads mail as it arrives and sends you a short account of it somewhere you look.",
+		trigger: "mail arrives in your inbox",
+		watches: "in:inbox newer_than:1d",
+		writes: "a message telling you what arrived",
+		runsIn: "temp",
+		settings: [
+			extraQuery,
+			needsMeOnly,
+			perPoll,
+			skipOwn
+		],
+		prompt: TELL_ME_PROMPT,
+		guidancePlaceholder: "What you care about in your mail. For example: I only need to know about anything involving money or a deadline.",
+		answer: "text",
+		actionConnectorId: "wechat",
+		actionId: "wechat.reply",
+		actionTarget: { to: "me" },
+		pollEveryMs: 18e5
+	}],
+	actions: [],
+	settings: [],
+	allowsMultipleAccounts: false,
+	byHand: { kind: "none" }
+});
+var WEEKDAY_NAMES = [
+	"Sunday",
+	"Monday",
+	"Tuesday",
+	"Wednesday",
+	"Thursday",
+	"Friday",
+	"Saturday"
+];
+function parseTime(at) {
+	const match = /^\s*(\d{1,2})\s*:\s*(\d{2})\s*$/.exec(at);
+	if (!match) throw new Error(`"${at}" is not a time. Write it as 09:00, on a 24-hour clock.`);
+	const hour = Number(match[1]);
+	const minute = Number(match[2]);
+	if (hour > 23 || minute > 59) throw new Error(`There is no such time as ${at}.`);
+	return {
+		hour,
+		minute
+	};
+}
+/**
+* The schedule a loop's settings describe.
+*
+* Throws rather than falling back to a default, because a loop that was meant
+* to run at seven and quietly runs at midnight is worse than one that says it
+* cannot read its own settings.
+*/
+function scheduleFrom(settings) {
+	const every = typeof settings.every === "string" ? settings.every : "day";
+	const at = typeof settings.at === "string" && settings.at.trim() !== "" ? settings.at : "09:00";
+	if (every === "hour") return {
+		every: "hour",
+		minute: parseTime(at).minute
+	};
+	if (every === "day") return {
+		every: "day",
+		...parseTime(at)
+	};
+	if (every === "weekday") return {
+		every: "weekday",
+		...parseTime(at)
+	};
+	if (every === "week") {
+		const raw = typeof settings.weekday === "string" ? Number(settings.weekday) : 1;
+		return {
+			every: "week",
+			weekday: Number.isInteger(raw) && raw >= 0 && raw <= 6 ? raw : 1,
+			...parseTime(at)
+		};
+	}
+	throw new Error(`Loopable does not know how to run something "${every}".`);
+}
+/** A local wall-clock time on the day `days` before `from`. */
+function on(from, days, hour, minute) {
+	return new Date(from.getFullYear(), from.getMonth(), from.getDate() - days, hour, minute, 0, 0);
+}
+/** Whether this schedule accepts a day, which only the weekday one restricts. */
+function accepts(schedule, when) {
+	const day = when.getDay();
+	if (schedule.every === "weekday") return day >= 1 && day <= 5;
+	if (schedule.every === "week") return day === schedule.weekday;
+	return true;
+}
+/**
+* The most recent time this schedule came round at or before `now`.
+*
+* Searched backwards a day at a time rather than computed, because "the last
+* weekday" and "the last Tuesday" are the same question asked of a calendar,
+* and a fortnight of candidates is nothing to look through.
+*/
+function lastDue(schedule, now) {
+	if (schedule.every === "hour") {
+		const thisHour = new Date(now.getFullYear(), now.getMonth(), now.getDate(), now.getHours(), schedule.minute, 0, 0);
+		if (thisHour <= now) return thisHour;
+		return /* @__PURE__ */ new Date(thisHour.getTime() - 36e5);
+	}
+	for (let days = 0; days < 15; days += 1) {
+		const candidate = on(now, days, schedule.hour, schedule.minute);
+		if (candidate <= now && accepts(schedule, candidate)) return candidate;
+	}
+	throw new Error("Could not work out when this last came round.");
+}
+/**
+* The run owed since `after`, or null when none is.
+*
+* At most one, and the most recent, on purpose. A laptop shut for a week owes
+* a morning summary, not seven of them, and the one worth having is today's.
+* Which of the missed ones is chosen matters because the caller records it: the
+* older ones are passed over rather than queued behind it.
+*/
+function dueSince(schedule, after, now) {
+	const last = lastDue(schedule, now);
+	return last > after ? last : null;
+}
+/**
+* A clock, as a source of work.
+*
+* It is a connector because everything downstream of a trigger already works:
+* a loop watches something, what it notices is deduplicated, becomes a task,
+* runs an agent and is written somewhere by an action. A time coming round is
+* simply another thing to notice. What makes this one unusual is only that
+* there is no account, which is what `auth: none` says.
+*/
+var every = {
+	key: "every",
+	kind: "select",
+	label: "How often",
+	options: [
+		{
+			value: "hour",
+			label: "Every hour"
+		},
+		{
+			value: "day",
+			label: "Every day"
+		},
+		{
+			value: "weekday",
+			label: "Every weekday"
+		},
+		{
+			value: "week",
+			label: "Once a week"
+		}
+	],
+	default: "day"
+};
+var at = {
+	key: "at",
+	kind: "text",
+	label: "At",
+	help: "On a 24-hour clock, in this host's own time zone. Only the minutes are used by an hourly loop.",
+	placeholder: "09:00"
+};
+var weekday = {
+	key: "weekday",
+	kind: "select",
+	label: "On",
+	help: "Only used by a loop that runs once a week.",
+	options: WEEKDAY_NAMES.map((name, index) => ({
+		value: String(index),
+		label: name
+	})),
+	default: "1"
+};
+var folder$1 = {
+	key: "folder",
+	kind: "text",
+	label: "Folder to work in",
+	help: "An absolute path. Nothing arrives to be looked at on a schedule, so this is the whole of what the agent is given.",
+	placeholder: "/Users/you/code/web"
+};
+/**
+* Deliberately a frame rather than a job. Every other workflow ships a prompt
+* because "review a pull request" is a problem worth solving once and getting
+* right; what to do at nine in the morning is not that kind of problem, and
+* the only person who knows it is the one setting the loop up. So this ships
+* something that works on the day it is turned on, and says plainly that it is
+* meant to be replaced.
+*/
+var RECURRING_PROMPT = [
+	"Nothing has arrived: this is running because the time came round.",
+	"",
+	"Look over the folder you are in and report anything that someone working",
+	"here would want to know today. Uncommitted work left sitting, a branch",
+	"well behind its base, failing checks, dependencies with published security",
+	"advisories: whatever is actually true of this checkout right now.",
+	"",
+	"Be brief and concrete. Name files and branches. Say nothing about what you",
+	"looked at and found fine."
+].join("\n");
+var scheduleManifest = defineManifest({
+	id: "schedule",
+	name: "Schedule",
+	tagline: "Run a loop when the time comes round, rather than when something arrives.",
+	icon: "Clock",
+	accent: "bg-slate-700 text-white",
+	auth: { kind: "none" },
+	allowsMultipleAccounts: false,
+	byHand: { kind: "now" },
+	settings: [],
+	workflows: [{
+		id: "schedule.recurring",
+		name: "Do something on a schedule",
+		summary: "Runs an agent in a folder you name, and keeps what it says.",
+		trigger: "the time you set comes round",
+		writes: "a note in the log",
+		runsIn: "folder",
+		settings: [
+			every,
+			at,
+			weekday,
+			folder$1
+		],
+		prompt: RECURRING_PROMPT,
+		guidancePlaceholder: "Anything that holds every time this runs. For example: this repository releases on Thursdays, so say if anything is unmerged by Wednesday evening.",
+		answer: "text",
+		actionId: "schedule.record"
+	}],
+	actions: [{
+		id: "schedule.record",
+		name: "Keep it in the log",
+		summary: "Leaves the answer here and sends it nowhere. Every run is recorded anyway, so this is what to use until it is worth pushing somewhere.",
+		target: [],
+		accepts: ["text", "review"]
+	}]
+});
+/**
+* Where the agent runs. Asking a phone "what broke the build" is only worth
+* anything if the agent can read the build, so this workflow works in a real
+* checkout rather than an empty directory.
+*/
+var folder = {
+	key: "folder",
+	kind: "text",
+	label: "Folder to work in",
+	help: "An absolute path to a checkout on this host. The agent runs here, so it can read the code you are asking about.",
+	placeholder: "/Users/you/code/your-project"
+};
+/**
+* A bot bound to your account can be messaged by other people, and this
+* workflow runs a coding agent on a runner. Answering only yourself is the
+* default because the alternative hands strangers your terminal.
+*/
+var askers = {
+	key: "askers",
+	kind: "select",
+	label: "Who can ask",
+	options: [{
+		value: "me",
+		label: "Only me"
+	}, {
+		value: "anyone",
+		label: "Anyone who messages the bot"
+	}],
+	default: "me"
+};
+/**
+* Whoever asked is the answer for a loop that a message started, and the only
+* case WeChat handles properly: the reply carries the token off the message it
+* is answering. A loop triggered somewhere else has no message behind it and
+* so no token, which the help says plainly rather than letting someone find
+* out from a notification that never arrives.
+*/
+var recipient = {
+	key: "to",
+	kind: "select",
+	label: "Who to send it to",
+	help: "WeChat only reliably delivers a reply to a conversation you started. Sending to yourself out of the blue is refused unless you have written to the bot in the last half day or so, which makes this a poor fit for anything that has to arrive overnight.",
+	options: [{
+		value: "source",
+		label: "Whoever asked"
+	}, {
+		value: "me",
+		label: "Me"
+	}],
+	default: "source"
+};
+var ASK_PROMPT = [
+	"Someone has sent you a message. Do what it asks, working in this directory,",
+	"and then answer them.",
+	"",
+	"You are answering into a chat on a phone. Be brief: a couple of short",
+	"paragraphs at most, no headings, no bullet lists unless you are genuinely",
+	"listing things. Plain sentences.",
+	"",
+	"If the message asks a question about this code, read enough of it to answer",
+	"properly rather than guessing. If it asks for a change, make the change and",
+	"say in one line what you did. If the message is too vague to act on, say what",
+	"you need to know instead of assuming."
+].join("\n");
+/**
+* Client-safe registry. Imports are explicit rather than a glob so the bundler
+* can see exactly what ships and so a typo fails the build.
+*/
+var CONNECTOR_MANIFESTS = [
+	githubManifest,
+	gmailManifest,
+	{
+		id: "wechat",
+		name: "WeChat",
+		tagline: "Bind a bot to your WeChat by scanning a code.",
+		docsUrl: "https://github.com/Tencent/openclaw-weixin/blob/main/docs/protocol.md",
+		icon: "Wechat",
+		accent: "bg-[#07c160] text-white",
+		auth: {
+			kind: "qr_scan",
+			note: "Scanning binds a bot to your WeChat account. Loopable can then read what people send that bot and answer as it, and nothing else on your account."
+		},
+		workflows: [{
+			id: "wechat.ask",
+			name: "Do what I ask the bot",
+			summary: "Runs your agent on a runner when you message the bot, and answers in the chat.",
+			trigger: "you send the bot a message",
+			writes: "a reply in the chat",
+			runsIn: "folder",
+			settings: [folder, askers],
+			prompt: ASK_PROMPT,
+			guidancePlaceholder: "Anything the agent should know about this project before it starts. For example: run pnpm test before saying a change works.",
+			answer: "text",
+			actionId: "wechat.reply"
+		}],
+		actions: [{
+			id: "wechat.reply",
+			name: "Reply in the chat",
+			summary: "Send a message back to whoever asked.",
+			target: [recipient],
+			accepts: ["text"]
+		}],
+		settings: [],
+		allowsMultipleAccounts: false,
+		byHand: { kind: "none" }
+	},
+	scheduleManifest
+];
+function connectorManifest(id) {
+	return CONNECTOR_MANIFESTS.find((manifest) => manifest.id === id);
+}
+/**
+* Whether this connector is somewhere you have an account.
+*
+* Asked in three places that would otherwise each assume every connector is:
+* the page listing accounts, the check for what stands between a loop and
+* running, and the fetch of a credential for a run.
+*/
+function needsAccount(id) {
+	return connectorManifest(id)?.auth.kind !== "none";
+}
+function connectorWorkflow(connectorId, workflowId) {
+	return connectorManifest(connectorId)?.workflows.find((entry) => entry.id === workflowId);
+}
+function connectorAction(connectorId, actionId) {
+	return connectorManifest(connectorId)?.actions.find((entry) => entry.id === actionId);
+}
+/** Every workflow on offer, for the page that asks which one to turn on. */
+function allWorkflows() {
+	return CONNECTOR_MANIFESTS.flatMap((connector) => connector.workflows.map((workflow) => ({
+		connector,
+		workflow
+	})));
+}
+/**
+* App registrations Loopable ships. End users never set these; they only click
+* Connect. A client on the user's machine cannot keep clientSecret confidential,
+* which both GitHub and Google accept for public clients. PKCE is what secures
+* the exchange. Env or config/oauth-app.json override this for GitHub Enterprise
+* or a private registration.
+*/
+var SHIPPED = {
+	github: {
+		clientId: "Ov23lilxTpmZdHyRCH5f",
+		clientSecret: "478c0e954e7c573763f128ba80054aca3fe5724e"
+	},
+	gmail: {
+		clientId: "477908327191-4juu8vo8bffs63hoqlul1u2fqdch27i7.apps.googleusercontent.com",
+		clientSecret: "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"
+	}
+};
+function shippedOAuthApp(connectorId) {
+	return SHIPPED[connectorId] ?? null;
+}
+function oauthAppRegistration(connectorId) {
+	return fromEnv(connectorId) ?? fromFile(connectorId) ?? shippedOAuthApp(connectorId);
+}
+/** LOOPABLE_GITHUB_CLIENT_ID and friends, for a private or Enterprise app. */
+function fromEnv(connectorId) {
+	const prefix = `LOOPABLE_${connectorId.toUpperCase()}_CLIENT_`;
+	return pick(process.env[`${prefix}ID`], process.env[`${prefix}SECRET`]);
+}
+/**
+* Optional override in config/oauth-app.json. Gitignored. Either an object per
+* connector or, for GitHub alone, the two keys at the top level.
+*/
+function fromFile(connectorId) {
+	let file;
+	try {
+		file = join(process.cwd(), "config", "oauth-app.json");
+		if (!existsSync(file)) return null;
+	} catch {
+		return null;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(readFileSync(file, "utf8"));
+	} catch {
+		return null;
+	}
+	const nested = parsed[connectorId];
+	if (nested && typeof nested === "object") {
+		const entry = nested;
+		return pick(entry.clientId, entry.clientSecret);
+	}
+	if (connectorId !== "github") return null;
+	const flat = parsed;
+	return pick(flat.clientId, flat.clientSecret);
+}
+function pick(id, secret) {
+	const clientId = typeof id === "string" ? id.trim() : "";
+	const clientSecret = typeof secret === "string" ? secret.trim() : "";
+	return clientId && clientSecret ? {
+		clientId,
+		clientSecret
+	} : null;
+}
+/**
+* Worth trying again: the service was unreachable, overloaded, or asked us to
+* slow down. Connectors raise this so the dispatcher can retry without knowing
+* anything about a particular service's status codes.
+*/
+var TransientError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "TransientError";
+	}
+};
+async function request$1(accessToken, path, init = {}) {
+	let res;
+	try {
+		res = await fetch(`https://api.github.com${path}`, {
+			...init,
+			headers: {
+				Authorization: `Bearer ${accessToken}`,
+				Accept: "application/vnd.github+json",
+				"User-Agent": "loopable",
+				"X-GitHub-Api-Version": "2022-11-28",
+				...init.headers
+			}
+		});
+	} catch (error) {
+		throw new TransientError(`GitHub could not be reached: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (!res.ok) {
+		const detail = (await res.text()).slice(0, 300);
+		const message = `GitHub ${res.status} on ${path}: ${detail}`;
+		const rateLimited = res.status === 403 && /rate limit|abuse|try again/i.test(detail);
+		if (res.status === 429 || res.status >= 500 || rateLimited) throw new TransientError(message);
+		throw new Error(message);
+	}
+	return await res.json();
+}
+function getPull(accessToken, repo, number) {
+	return request$1(accessToken, `/repos/${repo}/pulls/${number}`);
+}
+function getIssue(accessToken, repo, number) {
+	return request$1(accessToken, `/repos/${repo}/issues/${number}`);
+}
+function getRepo(accessToken, repo) {
+	return request$1(accessToken, `/repos/${repo}`);
+}
+function listPullFiles(accessToken, repo, number) {
+	return request$1(accessToken, `/repos/${repo}/pulls/${number}/files?per_page=100`);
+}
+/**
+* Search is capped at one page on purpose. A hundred things waiting on you is
+* already past the point where running an agent on all of them is the right
+* answer, and paginating would only make a bad situation more expensive.
+*/
+async function searchIssues(accessToken, query) {
+	return (await request$1(accessToken, `/search/issues?q=${encodeURIComponent(query)}&per_page=100&advanced_search=true`)).items;
+}
+/**
+* Reviews are submitted as COMMENT, never APPROVE: a loop may say what it
+* thinks, but whether a pull request is approved stays a human judgement.
+*
+* A comment on a line outside the diff makes GitHub refuse the whole review,
+* so callers check their anchors before getting here.
+*/
+function submitReview(accessToken, repo, pull, body, comments = []) {
+	return request$1(accessToken, `/repos/${repo}/pulls/${pull}/reviews`, {
+		method: "POST",
+		body: JSON.stringify({
+			event: "COMMENT",
+			body,
+			...comments.length > 0 ? { comments } : {}
+		})
+	});
+}
+function postIssueComment(accessToken, repo, issue, body) {
+	return request$1(accessToken, `/repos/${repo}/issues/${issue}/comments`, {
+		method: "POST",
+		body: JSON.stringify({ body })
+	});
+}
+/**
+* Opens a pull request for a branch that has already been pushed.
+*
+* Draft, always. This runs unattended, and the difference between a colleague
+* finding something to look at and a colleague being asked to review something
+* nobody has read is the one flag.
+*/
+function createPullRequest(accessToken, repo, input) {
+	return request$1(accessToken, `/repos/${repo}/pulls`, {
+		method: "POST",
+		body: JSON.stringify({
+			...input,
+			draft: true
+		})
+	});
+}
+/**
+* The pull request already open for a branch, if there is one.
+*
+* A retry pushes the same branch again, and asking GitHub to open a second
+* pull request for it fails. Finding the first one instead turns a retry into
+* what a person would expect: the change updated, not an error.
+*/
+async function pullForBranch(accessToken, repo, owner, branch) {
+	return (await request$1(accessToken, `/repos/${repo}/pulls?head=${encodeURIComponent(`${owner}:${branch}`)}&state=open`))[0] ?? null;
+}
+async function getViewer(accessToken) {
+	const res = await fetch("https://api.github.com/user", { headers: {
+		Authorization: `Bearer ${accessToken}`,
+		Accept: "application/vnd.github+json",
+		"User-Agent": "loopable",
+		"X-GitHub-Api-Version": "2022-11-28"
+	} });
+	if (!res.ok) throw new Error(`GitHub ${res.status} on /user: ${(await res.text()).slice(0, 200)}`);
+	return {
+		user: await res.json(),
+		scopes: (res.headers.get("x-oauth-scopes") ?? "").split(",").map((scope) => scope.trim()).filter(Boolean)
+	};
+}
+/**
+* A unified patch, read twice: once to write line numbers into it, and once to
+* know which of those numbers a comment may be attached to.
+*
+* The numbers are put in the diff on purpose. An agent can work them out from
+* the @@ headers, and gets them wrong often enough that reviews end up pointing
+* a few lines off, which is worse than useless in a review. Telling it the
+* number costs a few characters per line and removes the arithmetic.
+*/
+var HUNK = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
+/**
+* Only lines that survive into the new file get a number, because those are
+* the only ones a comment on the right-hand side can be attached to. A removed
+* line is shown, and deliberately left unnumbered so it cannot be aimed at.
+*/
+function annotate(patch) {
+	const out = [];
+	const lines = [];
+	let next = 0;
+	for (const line of patch.split("\n")) {
+		const hunk = HUNK.exec(line);
+		if (hunk) {
+			next = Number(hunk[1]);
+			out.push(`      | ${line}`);
+			continue;
+		}
+		if (next === 0 || line.startsWith("\\")) {
+			out.push(`      | ${line}`);
+			continue;
+		}
+		const marker = line[0] ?? " ";
+		const content = line.slice(1);
+		if (marker === "-") {
+			out.push(`-     | ${content}`);
+			continue;
+		}
+		out.push(`${marker}${String(next).padStart(5)} | ${content}`);
+		lines.push(next);
+		next += 1;
+	}
+	return {
+		text: out.join("\n"),
+		lines
+	};
+}
+/** Said once at the top of the file, rather than above every patch. */
+var ANNOTATION_LEGEND = ["Each line is shown as `<marker><line number> | <content>`, where the number", "is the line in the new version of the file. Removed lines have no number."].join("\n");
+var HOSTS = /* @__PURE__ */ new Set(["github.com", "www.github.com"]);
+/**
+* Accepts what a person actually copies out of the address bar, and checks the
+* host properly: matching "github.com" anywhere in the text would accept
+* https://notgithub.com/acme/web/pull/1 and then go and fetch acme/web from
+* the real GitHub.
+*/
+function parseGithubUrl(input) {
+	const trimmed = input.trim();
+	if (!trimmed) return null;
+	let url;
+	try {
+		url = new URL(/^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`);
+	} catch {
+		return null;
+	}
+	if (!HOSTS.has(url.hostname.toLowerCase())) return null;
+	const match = url.pathname.match(/^\/([^/]+)\/([^/]+)\/(pull|issues)\/(\d+)/);
+	if (!match) return null;
+	const [, owner, name, kind, number] = match;
+	return {
+		repo: `${owner}/${name}`,
+		kind: kind === "pull" ? "pull_request" : "issue",
+		number: Number(number)
+	};
+}
+/** How GitHub names a thing everywhere outside itself: `owner/name#12`. */
+function githubRef(repo, number) {
+	return `${repo}#${number}`;
+}
+/**
+* The other direction, for the point where a write has to name a repository
+* and a number again. Throws rather than returns null: a ref that this
+* connector wrote and cannot read back is a bug, not a bad input.
+*/
+function parseGithubRef(ref) {
+	const match = ref.match(/^([^/\s]+\/[^/\s#]+)#(\d+)$/);
+	if (!match) throw new Error(`Not a GitHub ref: ${ref}`);
+	return {
+		repo: match[1],
+		number: Number(match[2])
+	};
+}
+/**
+* Generous, because a review written against half a diff is worse than no
+* review: the agent hedges everything it could not see. Nothing is cut while
+* the whole diff fits, and where a cut is unavoidable it is announced, so the
+* agent knows to stay quiet about the rest instead of guessing.
+*/
+var TOTAL_LIMIT = 2e5;
+/** No file is cut below this, however many files there are. */
+var MIN_PER_FILE = 8e3;
+/**
+* A file's patch as the agent sees it, and the lines it may comment on. A cut
+* patch keeps only the anchors that are still visible: a comment on a line the
+* agent was never shown would be a guess.
+*/
+function patchOf(file, budget) {
+	const patch = file.patch;
+	if (!patch) return {
+		body: file.status === "renamed" ? "_Renamed, no content change._" : "_No diff available._",
+		lines: []
+	};
+	const whole = patch.length <= budget ? patch : patch.slice(0, patch.lastIndexOf("\n", budget));
+	const { text, lines } = annotate(whole);
+	const block = `\`\`\`diff\n${text}\n\`\`\``;
+	if (patch.length <= budget) return {
+		body: block,
+		lines
+	};
+	return {
+		body: [block, `**The diff for this file was cut here: ${patch.slice(whole.length).split("\n").length} more lines are not shown. Do not draw conclusions about the part you cannot see.**`].join("\n\n"),
+		lines
+	};
+}
+function diffOf(files) {
+	const share = files.reduce((sum, file) => sum + (file.patch?.length ?? 0), 0) <= TOTAL_LIMIT ? Number.POSITIVE_INFINITY : Math.max(MIN_PER_FILE, Math.floor(TOTAL_LIMIT / files.length));
+	const sections = [ANNOTATION_LEGEND];
+	const commentable = {};
+	let budget = TOTAL_LIMIT;
+	let shown = 0;
+	for (const file of files) {
+		if (budget <= 0) break;
+		const counts = [file.additions === void 0 ? null : `+${file.additions}`, file.deletions === void 0 ? null : `-${file.deletions}`].filter(Boolean).join(" ");
+		const { body, lines } = patchOf(file, Math.min(share, budget));
+		sections.push(`### ${file.filename}\n\n${file.status}${counts ? ` ${counts}` : ""}\n\n${body}`);
+		if (lines.length > 0) commentable[file.filename] = lines;
+		budget -= body.length;
+		shown += 1;
+	}
+	const omitted = files.length - shown;
+	if (omitted > 0) sections.push(`**${omitted} more changed files are not shown at all: ${files.slice(shown).map((file) => file.filename).join(", ")}**`);
+	return {
+		body: sections.join("\n\n"),
+		commentable
+	};
+}
+function filesOverview(files) {
+	if (files.length === 0) return "_No files changed._";
+	return files.map((file) => {
+		const counts = [file.additions === void 0 ? null : `+${file.additions}`, file.deletions === void 0 ? null : `-${file.deletions}`].filter(Boolean).join(" ");
+		return `- ${file.filename} (${file.status}${counts ? ` ${counts}` : ""})`;
+	}).join("\n");
+}
+/**
+* Metadata for the agent. The Connection token stays here: it is used to read
+* the pull request and to know which lines a comment may land on. Clone URL and
+* ref are written into the files the agent reads, with no token on them.
+*/
+async function resolveWorkItem(url, accessToken) {
+	const parsed = parseGithubUrl(url);
+	if (!parsed) throw new Error("That does not look like a GitHub pull request or issue link.");
+	const cloneUrl = `https://github.com/${parsed.repo}.git`;
+	if (parsed.kind === "pull_request") {
+		const pull = await getPull(accessToken, parsed.repo, parsed.number);
+		const files = await listPullFiles(accessToken, parsed.repo, parsed.number);
+		return {
+			kind: "pull_request",
+			commentable: diffOf(files).commentable,
+			checkout: {
+				url: cloneUrl,
+				ref: `pull/${parsed.number}/head`,
+				sha: pull.head.sha,
+				base: pull.base.ref,
+				repo: parsed.repo
+			},
+			ref: githubRef(parsed.repo, pull.number),
+			title: pull.title,
+			url: pull.html_url,
+			context: [{
+				name: "PULL_REQUEST.md",
+				body: [
+					`# ${pull.title}`,
+					``,
+					`Repository: ${parsed.repo}`,
+					`Pull request: #${pull.number}`,
+					`Opened by: ${pull.user.login}`,
+					`Draft: ${pull.draft ? "yes" : "no"}`,
+					`URL: ${pull.html_url}`,
+					``,
+					`Clone: ${cloneUrl}`,
+					`Ref: pull/${parsed.number}/head`,
+					``,
+					`## Description`,
+					``,
+					pull.body?.trim() || "_No description._",
+					``,
+					`## Changed files`,
+					``,
+					filesOverview(files)
+				].join("\n")
+			}]
+		};
+	}
+	const issue = await getIssue(accessToken, parsed.repo, parsed.number);
+	const repo = await getRepo(accessToken, parsed.repo);
+	return {
+		kind: "issue",
+		checkout: {
+			url: cloneUrl,
+			ref: repo.default_branch,
+			base: repo.default_branch,
+			repo: parsed.repo
+		},
+		ref: githubRef(parsed.repo, issue.number),
+		title: issue.title,
+		url: issue.html_url,
+		context: [{
+			name: "ISSUE.md",
+			body: [
+				`# ${issue.title}`,
+				``,
+				`Repository: ${parsed.repo}`,
+				`Issue: #${issue.number}`,
+				`Opened by: ${issue.user.login}`,
+				`URL: ${issue.html_url}`,
+				``,
+				`Clone: ${cloneUrl}`,
+				`Ref: ${repo.default_branch}`,
+				``,
+				`## Description`,
+				``,
+				issue.body?.trim() || "_No description._"
+			].join("\n")
+		}]
+	};
+}
+/**
+* Search tells you which repository a result came from only through its API
+* URL, so the owner and name are read back out of it.
+*/
+function repoFromApiUrl(url) {
+	const match = /^https:\/\/api\.github\.com\/repos\/([^/]+)\/([^/]+)$/.exec(url);
+	return match ? `${match[1]}/${match[2]}` : null;
+}
+/** An empty list means every repository the account can see. */
+function repoMatches(repo, patterns) {
+	if (patterns.length === 0) return true;
+	const target = repo.toLowerCase();
+	return patterns.some((pattern) => {
+		const escaped = pattern.trim().toLowerCase().replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*");
+		return escaped !== "" && new RegExp(`^${escaped}$`).test(target);
+	});
+}
+/** Apps get a login ending in [bot]; the type is set for both apps and users. */
+function isBot(user) {
+	return user.type === "Bot" || user.login.endsWith("[bot]");
+}
+function stringList(value) {
+	return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+/**
+* Missing means "the workflow's default", not "off". A loop saved before a
+* setting existed must behave as if it had been there all along.
+*/
+function boolean$1(value, fallback) {
+	return typeof value === "boolean" ? value : fallback;
+}
+function count$1(value, fallback) {
+	const parsed = typeof value === "string" ? Number.parseInt(value, 10) : NaN;
+	return Number.isFinite(parsed) ? parsed : fallback;
+}
+function candidates(items, repositories) {
+	return items.flatMap((item) => {
+		const repo = repoFromApiUrl(item.repository_url);
+		return repo && repoMatches(repo, repositories) ? [{
+			repo,
+			item
+		}] : [];
+	});
+}
+/**
+* What the workflow says it watches for, which is what gets asked. Taking the
+* query from the manifest is the point: it is shown on the loop page, and a
+* search that quietly differed from the one on screen would be the worst kind
+* of wrong.
+*/
+function query(workflowId) {
+	const workflow = githubManifest.workflows.find((entry) => entry.id === workflowId);
+	if (!workflow?.watches) throw new Error(`GitHub cannot watch for ${workflowId}.`);
+	return workflow.watches;
+}
+async function pollGithub(input) {
+	const repositories = stringList(input.settings.repositories);
+	if (input.workflowId === "github.review_requested") {
+		const items = await searchIssues(input.accessToken, query(input.workflowId));
+		const ignoreDrafts = boolean$1(input.settings.ignoreDrafts, true);
+		const ignoreBots = boolean$1(input.settings.ignoreBots, true);
+		const maxFiles = count$1(input.settings.maxChangedFiles, 50);
+		const signals = [];
+		for (const { repo, item } of candidates(items, repositories)) {
+			if (ignoreBots && isBot(item.user)) continue;
+			if (ignoreDrafts && item.draft) continue;
+			const pull = await getPull(input.accessToken, repo, item.number);
+			if (ignoreDrafts && pull.draft) continue;
+			const tooBig = maxFiles > 0 && pull.changed_files > maxFiles;
+			signals.push({
+				key: `${githubRef(repo, item.number)}@${pull.head.sha}`,
+				kind: "pull_request",
+				ref: githubRef(repo, item.number),
+				title: item.title,
+				url: item.html_url,
+				hold: tooBig ? `${pull.changed_files} files changed, over this loop's ${maxFiles}` : void 0
+			});
+		}
+		return signals;
+	}
+	if (input.workflowId === "github.issue_assigned") return candidates(await searchIssues(input.accessToken, query(input.workflowId)), repositories).map(({ repo, item }) => ({
+		key: githubRef(repo, item.number),
+		kind: "issue",
+		ref: githubRef(repo, item.number),
+		title: item.title,
+		url: item.html_url
+	}));
+	throw new Error(`GitHub cannot watch for ${input.workflowId}.`);
+}
+function createPkce$1() {
+	const verifier = randomBytes(32).toString("base64url");
+	return {
+		verifier,
+		challenge: createHash("sha256").update(verifier).digest("base64url")
+	};
+}
+function buildAuthorizeUrl$1(input) {
+	return `https://github.com/login/oauth/authorize?${new URLSearchParams({
+		client_id: input.clientId,
+		redirect_uri: input.redirectUri,
+		scope: GITHUB_SCOPES.join(" "),
+		state: input.state,
+		code_challenge: input.challenge,
+		code_challenge_method: "S256"
+	}).toString()}`;
+}
+async function postToken$1(payload, fetchImpl) {
+	const text = await (await fetchImpl("https://github.com/login/oauth/access_token", {
+		method: "POST",
+		headers: {
+			Accept: "application/json",
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify(payload)
+	})).text();
+	let body;
+	try {
+		body = JSON.parse(text);
+	} catch {
+		throw new Error(`GitHub returned a non-JSON response: ${text.slice(0, 200)}`);
+	}
+	const error = typeof body.error === "string" ? body.error : "";
+	if (error) {
+		const description = typeof body.error_description === "string" ? body.error_description : error;
+		throw new Error(description);
+	}
+	const accessToken = typeof body.access_token === "string" ? body.access_token : "";
+	if (!accessToken) throw new Error("GitHub did not return an access token");
+	const expiresIn = Number(body.expires_in);
+	return {
+		accessToken,
+		refreshToken: typeof body.refresh_token === "string" ? body.refresh_token : void 0,
+		expiresAt: Number.isFinite(expiresIn) && expiresIn > 0 ? Date.now() + expiresIn * 1e3 - 6e4 : void 0
+	};
+}
+function exchangeCode$1(input, fetchImpl = fetch) {
+	return postToken$1({
+		client_id: input.clientId,
+		client_secret: input.clientSecret,
+		code: input.code,
+		redirect_uri: input.redirectUri,
+		code_verifier: input.verifier
+	}, fetchImpl);
+}
+function refreshCredential$1(input, fetchImpl = fetch) {
+	return postToken$1({
+		client_id: input.clientId,
+		client_secret: input.clientSecret,
+		grant_type: "refresh_token",
+		refresh_token: input.refreshToken
+	}, fetchImpl);
+}
+function requireRegistration$1() {
+	const registration = oauthAppRegistration("github");
+	if (!registration) throw new Error("GitHub is not configured in this build: the OAuth app registration is missing.");
+	return registration;
+}
+function accountFrom(user) {
+	return {
+		id: String(user.user.id),
+		label: user.user.login,
+		url: user.user.html_url,
+		avatarUrl: user.user.avatar_url,
+		scopes: user.scopes
+	};
+}
+/**
+* Where the loop was triggered, read as a GitHub ref. Only possible when
+* GitHub is where it came from: another connector's ref is a label this one
+* has no business taking apart, so a loop that crosses services has to say
+* where the answer goes instead of leaving it to be guessed.
+*/
+function sourceRef(source, what) {
+	if (source.connectorId !== "github") throw new Error(`${what} needs a GitHub issue or pull request. Choose one on the loop.`);
+	return parseGithubRef(source.ref);
+}
+function namedRef(url) {
+	const parsed = parseGithubUrl(url);
+	if (!parsed) throw new Error(`That is not a GitHub issue or pull request: ${url}`);
+	return {
+		repo: parsed.repo,
+		number: parsed.number
+	};
+}
+/** The agent was asked for a subject line first, so this is that line. */
+function titleOf(body) {
+	const clean = (body.split("\n").find((line) => line.trim() !== "")?.trim() ?? "").replace(/^#+\s*/, "");
+	return clean.length > 120 ? `${clean.slice(0, 117)}…` : clean || "Changes from Loopable";
+}
+/**
+* The description, with the two things the agent cannot say for itself: what
+* this came from, and how big it is. Both are what a person checks first when
+* a pull request appears that they did not open.
+*/
+function pullBody(input) {
+	const closes = input.source.connectorId === "github" && input.source.kind === "issue" ? `Closes #${parseGithubRef(input.source.ref).number}` : `From [${input.source.title}](${input.source.url})`;
+	const size = input.stat ? `\n\n<details><summary>Files changed</summary>\n\n\`\`\`\n${input.stat}\n\`\`\`\n\n</details>` : "";
+	return `${closes}\n\n${input.body}${size}`;
+}
+/**
+* Returns a usable access token, refreshing it when the stored one has expired.
+* The refreshed credential is handed back so the caller can persist it.
+*/
+async function usableToken$1(credential) {
+	if (!credential.expiresAt || Date.now() < credential.expiresAt) return { accessToken: credential.accessToken };
+	if (!credential.refreshToken) throw new Error("The GitHub token expired and there is no refresh token. Reconnect the account.");
+	const registration = requireRegistration$1();
+	const refreshed = await refreshCredential$1({
+		clientId: registration.clientId,
+		clientSecret: registration.clientSecret,
+		refreshToken: credential.refreshToken
+	});
+	return {
+		accessToken: refreshed.accessToken,
+		refreshed
+	};
+}
+var githubRuntime = defineRuntime({
+	async readiness() {
+		if (oauthAppRegistration("github")) return { ready: true };
+		return {
+			ready: false,
+			reason: "This build has no GitHub app registration.",
+			fixHint: "Set LOOPABLE_GITHUB_CLIENT_ID and LOOPABLE_GITHUB_CLIENT_SECRET to use your own OAuth app."
+		};
+	},
+	identifyLink(url) {
+		const parsed = parseGithubUrl(url);
+		if (!parsed) return null;
+		return {
+			kind: parsed.kind,
+			ref: githubRef(parsed.repo, parsed.number)
+		};
+	},
+	async resolveWorkItem({ url, credential }) {
+		const { accessToken } = await usableToken$1(credential);
+		return resolveWorkItem(url, accessToken);
+	},
+	async poll({ workflowId, settings, credential }) {
+		const { accessToken } = await usableToken$1(credential);
+		return { signals: await pollGithub({
+			workflowId,
+			settings,
+			accessToken
+		}) };
+	},
+	async applyAction({ actionId, target, source, body, comments, changes, credential }) {
+		const { accessToken } = await usableToken$1(credential);
+		if (actionId === "github.submit_review") {
+			const { repo, number } = sourceRef(source, "A review");
+			if (source.kind !== "pull_request") throw new Error("A review can only be submitted on a pull request.");
+			return { url: (await submitReview(accessToken, repo, number, body, (comments ?? []).map((comment) => ({
+				path: comment.path,
+				line: comment.line,
+				side: "RIGHT",
+				...comment.startLine !== void 0 ? {
+					start_line: comment.startLine,
+					start_side: "RIGHT"
+				} : {},
+				body: comment.body
+			})))).html_url };
+		}
+		if (actionId === "github.post_issue_comment") {
+			const named = typeof target.issue === "string" ? target.issue.trim() : "";
+			const { repo, number } = named ? namedRef(named) : sourceRef(source, "A comment");
+			return { url: (await postIssueComment(accessToken, repo, number, body)).html_url };
+		}
+		if (actionId === "github.open_pull_request") {
+			if (!changes) throw new Error("There is no branch to open a pull request for.");
+			const repo = changes.repo;
+			if (!/^[^/\s]+\/[^/\s]+$/.test(repo)) throw new Error(`Not a GitHub repository: ${repo}`);
+			const owner = repo.split("/")[0];
+			const existing = await pullForBranch(accessToken, repo, owner, changes.branch);
+			if (existing) return { url: existing.html_url };
+			return { url: (await createPullRequest(accessToken, repo, {
+				title: titleOf(body),
+				body: pullBody({
+					body,
+					source,
+					stat: changes.stat
+				}),
+				head: changes.branch,
+				base: changes.base
+			})).html_url };
+		}
+		throw new Error(`GitHub cannot ${actionId}.`);
+	},
+	auth: {
+		async startAuthorization({ redirectUri, state }) {
+			const registration = requireRegistration$1();
+			const { verifier, challenge } = createPkce$1();
+			return {
+				verifier,
+				redirectUrl: buildAuthorizeUrl$1({
+					clientId: registration.clientId,
+					redirectUri,
+					state,
+					challenge
+				})
+			};
+		},
+		async completeAuthorization({ code, redirectUri, verifier }) {
+			const registration = requireRegistration$1();
+			const credential = await exchangeCode$1({
+				clientId: registration.clientId,
+				clientSecret: registration.clientSecret,
+				code,
+				redirectUri,
+				verifier
+			});
+			return {
+				credential,
+				account: accountFrom(await getViewer(credential.accessToken))
+			};
+		},
+		async identity(credential) {
+			const { accessToken, refreshed } = await usableToken$1(credential);
+			const account = accountFrom(await getViewer(accessToken));
+			return refreshed ? {
+				account,
+				renewedCredential: refreshed
+			} : { account };
+		}
+	}
+});
+var BASE = "https://gmail.googleapis.com/gmail/v1/users/me";
+async function request(accessToken, path) {
+	let res;
+	try {
+		res = await fetch(`${BASE}${path}`, { headers: {
+			Authorization: `Bearer ${accessToken}`,
+			Accept: "application/json"
+		} });
+	} catch (error) {
+		throw new TransientError(`Gmail could not be reached: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (!res.ok) {
+		const detail = (await res.text()).slice(0, 300);
+		const message = `Gmail ${res.status} on ${path}: ${detail}`;
+		const backoff = res.status === 403 && /rateLimitExceeded|userRateLimitExceeded/i.test(detail);
+		if (res.status === 429 || res.status >= 500 || backoff) throw new TransientError(message);
+		throw new Error(message);
+	}
+	return await res.json();
+}
+function getProfile(accessToken) {
+	return request(accessToken, "/profile");
+}
+/**
+* Message ids matching a Gmail search, newest first.
+*
+* One page only, like the GitHub search: past a certain number of unanswered
+* things, running an agent over all of them is the wrong answer and paging
+* would only make it a more expensive wrong answer.
+*/
+async function listMessages(accessToken, query, max) {
+	return ((await request(accessToken, `/messages?q=${encodeURIComponent(query)}&maxResults=${max}`)).messages ?? []).map((entry) => entry.id);
+}
+/**
+* Just enough to recognise a message, without pulling its body down.
+*
+* Polling only needs to say what arrived and title it, and bodies are the
+* expensive part of a mailbox. The whole message is fetched later, once
+* something is actually going to be done with it.
+*/
+function getMessageHeaders(accessToken, id) {
+	return request(accessToken, `/messages/${id}?format=metadata${[
+		"From",
+		"To",
+		"Subject",
+		"Date",
+		"List-Id"
+	].map((name) => `&metadataHeaders=${name}`).join("")}`);
+}
+function getMessage(accessToken, id) {
+	return request(accessToken, `/messages/${id}?format=full`);
+}
+/** A Gmail message id, as a ref: short, stable, and unique to the mailbox. */
+function mailRef(id) {
+	return `mail#${id}`;
+}
+/**
+* Where to send someone who wants to see the mail itself. Gmail has no
+* per-message API link, but the web client will open one by id.
+*/
+function permalink(id) {
+	return `https://mail.google.com/mail/u/0/#all/${id}`;
+}
+function headerOf(message, name) {
+	const wanted = name.toLowerCase();
+	return (message.payload?.headers ?? []).find((header) => header.name.toLowerCase() === wanted)?.value.trim() ?? "";
+}
+/** The address out of `Some One <one@example.com>`, or the whole thing if bare. */
+function addressOf(from) {
+	const angled = /<([^>]+)>/.exec(from);
+	return (angled ? angled[1] : from).trim().toLowerCase();
+}
+/** The name out of `Some One <one@example.com>`, falling back to the address. */
+function senderName(from) {
+	return from.split("<")[0].trim().replace(/^"|"$/g, "") || addressOf(from);
+}
+function decode(data) {
+	return Buffer.from(data, "base64url").toString("utf8");
+}
+/**
+* Tags out, text kept, in the order a reader would meet it.
+*
+* Only reached for mail that carries no plain text part at all. It is not
+* trying to be a renderer: an agent reading this needs the words and roughly
+* where the line breaks were, and everything else is noise it would have to
+* see past.
+*/
+function htmlToText(html) {
+	return html.replace(/<(script|style)\b[^>]*>[\s\S]*?<\/\1>/gi, "").replace(/<br\s*\/?>/gi, "\n").replace(/<\/(p|div|tr|li|h[1-6])>/gi, "\n").replace(/<li\b[^>]*>/gi, "- ").replace(/<[^>]+>/g, "").replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, "\"").replace(/&#39;|&apos;/gi, "'").replace(/[ \t]+/g, " ").replace(/ *\n */g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+/**
+* The readable body, preferring what the sender wrote as text.
+*
+* A message is a tree, and a normal one from a normal client has both a plain
+* and an HTML version of the same words. Taking plain text where it exists
+* avoids ever having to guess at markup; the walk below collects both on one
+* pass and only falls back when there was no text part.
+*/
+function bodyText(message) {
+	const plain = [];
+	const html = [];
+	const walk = (part) => {
+		if (!part) return;
+		const type = (part.mimeType ?? "").toLowerCase();
+		if (!(Boolean(part.filename) || Boolean(part.body?.attachmentId)) && part.body?.data) {
+			if (type === "text/plain") plain.push(decode(part.body.data));
+			else if (type === "text/html") html.push(decode(part.body.data));
+		}
+		for (const child of part.parts ?? []) walk(child);
+	};
+	walk(message.payload);
+	const text = plain.join("\n").trim();
+	if (text) return text;
+	const markup = html.join("\n").trim();
+	return markup ? htmlToText(markup) : (message.snippet ?? "").trim();
+}
+/** The attachments, named only. Nothing downloads them; the agent should know. */
+function attachmentNames(message) {
+	const names = [];
+	const walk = (part) => {
+		if (!part) return;
+		if (part.filename) names.push(part.filename);
+		for (const child of part.parts ?? []) walk(child);
+	};
+	walk(message.payload);
+	return names;
+}
+/** Enough of a message to pick it out of a list. */
+function summarise$1(message) {
+	const subject = headerOf(message, "Subject") || "(no subject)";
+	const who = senderName(headerOf(message, "From"));
+	const title = who ? `${who}: ${subject}` : subject;
+	return title.length > 120 ? `${title.slice(0, 119)}…` : title;
+}
+/**
+* A long mail is cut rather than sent whole. What follows this is an agent
+* with a context window and, at the end of the chain, a phone: a mailing list
+* digest read to the last line helps nobody and costs the run.
+*/
+var BODY_LIMIT = 2e4;
+/** The mail as the agent reads it: one file, headers first, then the words. */
+function mailContext(message) {
+	const body = bodyText(message);
+	const clipped = body.length > BODY_LIMIT ? `${body.slice(0, BODY_LIMIT)}\n\n[cut here: the message is longer than this]` : body;
+	const attachments = attachmentNames(message);
+	const date = headerOf(message, "Date");
+	return {
+		name: "EMAIL.md",
+		body: [
+			`# ${headerOf(message, "Subject") || "(no subject)"}`,
+			``,
+			`From: ${headerOf(message, "From") || "(unknown)"}`,
+			...headerOf(message, "To") ? [`To: ${headerOf(message, "To")}`] : [],
+			...date ? [`Date: ${date}`] : [],
+			...attachments.length > 0 ? [`Attachments (not included here): ${attachments.join(", ")}`] : [],
+			``,
+			`---`,
+			``,
+			clipped || "(this message has no readable text)",
+			``
+		].join("\n")
+	};
+}
+/**
+* What the workflow says it watches for, which is what gets asked. Taken from
+* the manifest rather than written again here, because it is shown on the loop
+* page and a query that quietly differed from the one on screen would be the
+* worst kind of wrong.
+*/
+function baseQuery(workflowId) {
+	const workflow = gmailManifest.workflows.find((entry) => entry.id === workflowId);
+	if (!workflow?.watches) throw new Error(`Gmail cannot watch for ${workflowId}.`);
+	return workflow.watches;
+}
+/**
+* Missing means "the workflow's default", not "off". A loop saved before a
+* setting existed must behave as if it had been there all along.
+*/
+function boolean(value, fallback) {
+	return typeof value === "boolean" ? value : fallback;
+}
+function count(value, fallback) {
+	const parsed = typeof value === "string" ? Number.parseInt(value, 10) : NaN;
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function text(value) {
+	return typeof value === "string" ? value.trim() : "";
+}
+/** What Loopable asks Gmail: the workflow's query, then whatever the loop adds. */
+function queryFor(workflowId, settings) {
+	const extra = text(settings.extraQuery);
+	return extra ? `${baseQuery(workflowId)} ${extra}` : baseQuery(workflowId);
+}
+async function pollGmail(input) {
+	if (input.workflowId !== "gmail.new_mail") throw new Error(`Gmail cannot watch for ${input.workflowId}.`);
+	const max = count(input.settings.maxPerPoll, 10);
+	const ids = await listMessages(input.accessToken, queryFor(input.workflowId, input.settings), max);
+	const skipOwn = boolean(input.settings.skipOwn, true);
+	const me = input.emailAddress.toLowerCase();
+	const signals = [];
+	for (const id of ids) {
+		const message = await getMessageHeaders(input.accessToken, id);
+		if (skipOwn && addressOf(headerOf(message, "From")) === me) continue;
+		signals.push({
+			key: mailRef(id),
+			kind: "email",
+			ref: mailRef(id),
+			title: summarise$1(message),
+			url: permalink(id),
+			preview: (message.snippet ?? "").trim() || void 0,
+			payload: { messageId: id }
+		});
+	}
+	return signals;
+}
+var AUTHORIZE = "https://accounts.google.com/o/oauth2/v2/auth";
+var TOKEN = "https://oauth2.googleapis.com/token";
+var REVOKE = "https://oauth2.googleapis.com/revoke";
+function createPkce() {
+	const verifier = randomBytes(32).toString("base64url");
+	return {
+		verifier,
+		challenge: createHash("sha256").update(verifier).digest("base64url")
+	};
+}
+function buildAuthorizeUrl(input) {
+	return `${AUTHORIZE}?${new URLSearchParams({
+		client_id: input.clientId,
+		redirect_uri: input.redirectUri,
+		response_type: "code",
+		scope: GMAIL_SCOPES.join(" "),
+		state: input.state,
+		code_challenge: input.challenge,
+		code_challenge_method: "S256",
+		access_type: "offline",
+		prompt: "consent"
+	}).toString()}`;
+}
+/** Google's token endpoint takes a form, not JSON, and answers JSON either way. */
+async function postToken(payload, fetchImpl) {
+	const text = await (await fetchImpl(TOKEN, {
+		method: "POST",
+		headers: {
+			Accept: "application/json",
+			"Content-Type": "application/x-www-form-urlencoded"
+		},
+		body: new URLSearchParams(payload).toString()
+	})).text();
+	let body;
+	try {
+		body = JSON.parse(text);
+	} catch {
+		throw new Error(`Google returned a non-JSON response: ${text.slice(0, 200)}`);
+	}
+	const error = typeof body.error === "string" ? body.error : "";
+	if (error) {
+		const description = typeof body.error_description === "string" ? body.error_description : error;
+		if (error === "invalid_grant") throw new Error(`Google will not renew this connection (${description}). Connect Gmail again.`);
+		throw new Error(description);
+	}
+	const accessToken = typeof body.access_token === "string" ? body.access_token : "";
+	if (!accessToken) throw new Error("Google did not return an access token");
+	const expiresIn = Number(body.expires_in);
+	return {
+		accessToken,
+		refreshToken: typeof body.refresh_token === "string" ? body.refresh_token : void 0,
+		expiresAt: Number.isFinite(expiresIn) && expiresIn > 0 ? Date.now() + expiresIn * 1e3 - 6e4 : void 0
+	};
+}
+function exchangeCode(input, fetchImpl = fetch) {
+	return postToken({
+		client_id: input.clientId,
+		client_secret: input.clientSecret,
+		code: input.code,
+		redirect_uri: input.redirectUri,
+		code_verifier: input.verifier,
+		grant_type: "authorization_code"
+	}, fetchImpl);
+}
+/**
+* A renewed access token, keeping the refresh token we already hold.
+*
+* Google's refresh response has no refresh_token in it. Taking the response at
+* face value, as the GitHub flow can, would store a credential with no way to
+* renew itself and break the account an hour later.
+*/
+async function refreshCredential(input, fetchImpl = fetch) {
+	const renewed = await postToken({
+		client_id: input.clientId,
+		client_secret: input.clientSecret,
+		refresh_token: input.refreshToken,
+		grant_type: "refresh_token"
+	}, fetchImpl);
+	return {
+		...renewed,
+		refreshToken: renewed.refreshToken ?? input.refreshToken
+	};
+}
+async function revokeCredential(credential, fetchImpl = fetch) {
+	const token = credential.refreshToken ?? credential.accessToken;
+	await fetchImpl(`${REVOKE}?token=${encodeURIComponent(token)}`, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" }
+	});
+}
+function requireRegistration() {
+	const registration = oauthAppRegistration("gmail");
+	if (!registration) throw new Error("Gmail is not configured in this build: the OAuth app registration is missing.");
+	return registration;
+}
+/**
+* A usable access token, renewed when the stored one has expired. The renewed
+* credential is handed back so the caller stores it instead of asking Google
+* again on the next call.
+*
+* Google's access tokens last an hour, so unlike GitHub this path is the
+* normal one rather than the exception.
+*/
+async function usableToken(credential) {
+	if (!credential.expiresAt || Date.now() < credential.expiresAt) return { accessToken: credential.accessToken };
+	if (!credential.refreshToken) throw new Error("The Gmail token expired and there is no refresh token. Connect Gmail again.");
+	const registration = requireRegistration();
+	const refreshed = await refreshCredential({
+		clientId: registration.clientId,
+		clientSecret: registration.clientSecret,
+		refreshToken: credential.refreshToken
+	});
+	return {
+		accessToken: refreshed.accessToken,
+		refreshed
+	};
+}
+/** The mailbox, as a person would recognise it. */
+function accountOf$1(emailAddress) {
+	return {
+		id: emailAddress,
+		label: emailAddress
+	};
+}
+/**
+* Which message this task is about. The poll keeps the id, and a pasted link
+* carries one too, so either is enough to fetch the mail again.
+*/
+function messageIdFrom(url, payload) {
+	const kept = payload ?? {};
+	if (typeof kept.messageId === "string" && kept.messageId) return kept.messageId;
+	const fromUrl = /[#/]([A-Za-z0-9_-]{8,})$/.exec(url.trim());
+	if (fromUrl) return fromUrl[1];
+	throw new Error("This task has lost the message it was about.");
+}
+var gmailRuntime = defineRuntime({
+	async readiness() {
+		if (oauthAppRegistration("gmail")) return { ready: true };
+		return {
+			ready: false,
+			reason: "This build has no Google app registration.",
+			fixHint: "Set LOOPABLE_GMAIL_CLIENT_ID and LOOPABLE_GMAIL_CLIENT_SECRET to use your own OAuth app."
+		};
+	},
+	identifyLink(url) {
+		const trimmed = url.trim();
+		if (!/^https:\/\/mail\.google\.com\//.test(trimmed)) return null;
+		const id = /[#/]([A-Za-z0-9_-]{8,})$/.exec(trimmed);
+		return id ? {
+			kind: "email",
+			ref: mailRef(id[1])
+		} : null;
+	},
+	async resolveWorkItem({ url, payload, credential }) {
+		const { accessToken } = await usableToken(credential);
+		const message = await getMessage(accessToken, messageIdFrom(url, payload));
+		return {
+			kind: "email",
+			ref: mailRef(message.id),
+			title: summarise$1(message),
+			url: permalink(message.id),
+			context: [mailContext(message)]
+		};
+	},
+	async poll({ workflowId, settings, credential }) {
+		const { accessToken } = await usableToken(credential);
+		return { signals: await pollGmail({
+			workflowId,
+			settings,
+			accessToken,
+			emailAddress: (await getProfile(accessToken)).emailAddress
+		}) };
+	},
+	auth: {
+		async startAuthorization({ redirectUri, state }) {
+			const registration = requireRegistration();
+			const { verifier, challenge } = createPkce();
+			return {
+				verifier,
+				redirectUrl: buildAuthorizeUrl({
+					clientId: registration.clientId,
+					redirectUri,
+					state,
+					challenge
+				})
+			};
+		},
+		async completeAuthorization({ code, redirectUri, verifier }) {
+			const registration = requireRegistration();
+			const credential = await exchangeCode({
+				clientId: registration.clientId,
+				clientSecret: registration.clientSecret,
+				code,
+				redirectUri,
+				verifier
+			});
+			return {
+				credential,
+				account: accountOf$1((await getProfile(credential.accessToken)).emailAddress)
+			};
+		},
+		async identity(credential) {
+			const { accessToken, refreshed } = await usableToken(credential);
+			const account = accountOf$1((await getProfile(accessToken)).emailAddress);
+			return refreshed ? {
+				account,
+				renewedCredential: refreshed
+			} : { account };
+		},
+		async revoke(credential) {
+			await revokeCredential(credential);
+		}
+	}
+});
+/** How a time is written where a person will read it back. */
+function readable(when) {
+	return when.toLocaleString(void 0, {
+		weekday: "short",
+		day: "numeric",
+		month: "short",
+		hour: "2-digit",
+		minute: "2-digit"
+	});
+}
+function signalFor(due) {
+	return {
+		kind: "occurrence",
+		key: due.toISOString(),
+		ref: readable(due),
+		title: `Due ${readable(due)}`,
+		url: "",
+		payload: { due: due.toISOString() }
+	};
+}
+var scheduleRuntime = {
+	/** Nothing to register and nothing to install: a clock is always ready. */
+	async readiness() {
+		return { ready: true };
+	},
+	/**
+	* There is no account, so none of this is reachable. `identity` is required
+	* of every connector because every other one has a stored credential to
+	* prove still works, and this one has nothing to prove.
+	*/
+	auth: { async identity() {
+		throw new Error("A schedule has no account.");
+	} },
+	/**
+	* Whether a time has come round since the last one that did.
+	*
+	* The cursor is the occurrence this loop last fired, and it moves only when
+	* one fires. On a first look there is nothing to compare against, so the
+	* cursor is set to now and nothing is returned: turning a loop on should not
+	* immediately run this morning's, which is what would happen if the last
+	* occurrence counted as owed.
+	*/
+	async poll({ settings, cursor }) {
+		const schedule = scheduleFrom(settings);
+		const now = /* @__PURE__ */ new Date();
+		const since = typeof cursor === "string" ? new Date(cursor) : null;
+		if (!since || Number.isNaN(since.getTime())) return {
+			signals: [],
+			cursor: now.toISOString()
+		};
+		const due = dueSince(schedule, since, now);
+		if (!due) return {
+			signals: [],
+			cursor: cursor ?? void 0
+		};
+		return {
+			signals: [signalFor(due)],
+			cursor: due.toISOString()
+		};
+	},
+	/**
+	* A run somebody asked for is about the moment they asked, not about the
+	* last time the clock came round. Waiting until nine tomorrow to find out
+	* whether a loop works is no way to shape one.
+	*/
+	itemForNow() {
+		return {
+			kind: "occurrence",
+			ref: readable(/* @__PURE__ */ new Date())
+		};
+	},
+	/**
+	* Writes nothing anywhere.
+	*
+	* Which is worth having as an action rather than as a gap, because a loop
+	* needs somewhere for its answer to go before it will run at all, and until
+	* a reliable destination exists this is the honest one: every run is already
+	* recorded, so the answer is kept where a person will look for it. Returns
+	* no address because the task's own page is the address.
+	*/
+	async applyAction({ actionId }) {
+		if (actionId !== "schedule.record") throw new Error(`A schedule cannot ${actionId}.`);
+		return { url: "" };
+	},
+	/**
+	* There is nothing to fetch: the occurrence is the whole of what happened,
+	* and the poll already wrote it down. Anything run from the button rather
+	* than by the clock has no occurrence behind it and is about now.
+	*/
+	async resolveWorkItem({ payload }) {
+		return {
+			...signalFor(payload && typeof payload === "object" && "due" in payload && typeof payload.due === "string" ? new Date(payload.due) : /* @__PURE__ */ new Date()),
+			context: []
+		};
+	}
+};
+/**
+* Tencent's iLink bot API, as documented for clients that are not OpenClaw:
+* https://github.com/Tencent/openclaw-weixin/blob/main/docs/protocol.md
+*
+* The document describes what Tencent's own client does rather than promising
+* a server contract, so anything not observed here is treated as optional and
+* a surprise is reported rather than assumed away.
+*/
+var WECHAT_API = "https://ilinkai.weixin.qq.com";
+/**
+* The version of the protocol we speak, not of Loopable. It is the plugin
+* release whose documented behaviour this client was written against, encoded
+* as 0x00MMNNPP and sent as decimal.
+*/
+var PROTOCOL = {
+	major: 2,
+	minor: 4,
+	patch: 8
+};
+var CLIENT_VERSION = String(PROTOCOL.major << 16 | PROTOCOL.minor << 8 | PROTOCOL.patch);
+/**
+* Who is calling, in the slot Tencent left for clients other than their own.
+* Sent for their observability, not for auth, and worth being honest in.
+*/
+var BASE_INFO = {
+	channel_version: `${PROTOCOL.major}.${PROTOCOL.minor}.${PROTOCOL.patch}`,
+	bot_agent: "Loopable/0.1"
+};
+var APP_HEADERS = {
+	"iLink-App-Id": "bot",
+	"iLink-App-ClientVersion": CLIENT_VERSION
+};
+/** "Base64-encoded decimal representation of a random uint32." */
+function uin() {
+	return Buffer.from(String(Math.floor(Math.random() * 4294967295))).toString("base64");
+}
+function postHeaders(token) {
+	return {
+		"Content-Type": "application/json",
+		AuthorizationType: "ilink_bot_token",
+		"X-WECHAT-UIN": uin(),
+		...APP_HEADERS,
+		...token ? { Authorization: `Bearer ${token}` } : {}
+	};
+}
+/**
+* WeChat's own trouble is not ours to fail a loop over. A refused request is
+* an answer; an unreachable host or a 5xx is a bad minute.
+*/
+async function call(url, init) {
+	let response;
+	try {
+		response = await fetch(url, init);
+	} catch (error) {
+		throw new TransientError(`WeChat is unreachable: ${error.message}`);
+	}
+	if (response.status >= 500 || response.status === 429) throw new TransientError(`WeChat answered ${response.status}`);
+	if (!response.ok) throw new Error(`WeChat answered ${response.status}`);
+	return await response.json();
+}
+async function requestQrCode() {
+	const body = await call(`${WECHAT_API}/ilink/bot/get_bot_qrcode?bot_type=3`, {
+		method: "POST",
+		headers: postHeaders(),
+		body: JSON.stringify({ local_token_list: [] })
+	});
+	if (!body.qrcode || !body.qrcode_img_content) throw new Error("WeChat did not return a login code.");
+	return {
+		qrcode: body.qrcode,
+		url: body.qrcode_img_content
+	};
+}
+function absolute(host) {
+	return host.startsWith("http") ? host : `https://${host}`;
+}
+/**
+* One look at a pending scan. Everything except a finished login is a reason
+* to look again, including a failed request: a login in progress should not be
+* thrown away over one bad response.
+*/
+async function qrCodeStatus(qrcode, host) {
+	let body;
+	try {
+		body = await call(`${absolute(host)}/ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`, { headers: APP_HEADERS });
+	} catch {
+		return {
+			state: "waiting",
+			host
+		};
+	}
+	switch (body.status) {
+		case "confirmed":
+			if (!body.bot_token) return {
+				state: "expired",
+				reason: "WeChat confirmed without a token."
+			};
+			return {
+				state: "confirmed",
+				credential: {
+					botToken: body.bot_token,
+					botId: body.ilink_bot_id ?? "",
+					userId: body.ilink_user_id ?? "",
+					baseUrl: body.baseurl ? absolute(body.baseurl) : WECHAT_API
+				}
+			};
+		case "scaned": return {
+			state: "waiting",
+			host,
+			hint: "Scanned. Confirm it on your phone."
+		};
+		case "scaned_but_redirect": return {
+			state: "waiting",
+			host: body.redirect_host ? absolute(body.redirect_host) : host,
+			hint: "Scanned. Confirm it on your phone."
+		};
+		case "need_verifycode": return {
+			state: "waiting",
+			host,
+			hint: "WeChat is asking for a verification code."
+		};
+		case "binded_redirect": return {
+			state: "expired",
+			reason: "This account is already bound somewhere else."
+		};
+		case "verify_code_blocked": return {
+			state: "expired",
+			reason: "Too many verification attempts. Start again."
+		};
+		case "expired": return { state: "expired" };
+		default: return {
+			state: "waiting",
+			host
+		};
+	}
+}
+/** A dead token, as opposed to a request WeChat merely disliked. */
+var SESSION_GONE = -14;
+/**
+* Whether WeChat refused, and why.
+*
+* It reports trouble in two fields and not always the same one: a call with a
+* dead token comes back `{errcode:-14}` with no `ret` at all, so a check that
+* reads only `ret` would call that a success and let a signed-out account look
+* connected.
+*/
+function signedOut(body) {
+	return body.ret === SESSION_GONE || body.errcode === SESSION_GONE;
+}
+function refusal(body) {
+	const bad = [body.ret, body.errcode].filter((code) => typeof code === "number").find((code) => code !== 0);
+	if (bad === void 0) return null;
+	if (bad === SESSION_GONE) return "WeChat has signed this bot out. Connect again by scanning.";
+	return body.errmsg || `WeChat refused the request (${bad}).`;
+}
+/**
+* Tells WeChat a client is up, and doubles as the proof that a stored token
+* still works: it needs nothing but the token, and a dead one is refused.
+*
+* Reading the account's config would be the obvious check and is the wrong
+* one. It mints a typing ticket, which needs a conversation, so it fails on
+* exactly the account that has just been connected and never messaged.
+*/
+async function notifyStart(credential) {
+	const refused = refusal(await call(`${credential.baseUrl}/ilink/bot/msg/notifystart`, {
+		method: "POST",
+		headers: postHeaders(credential.botToken),
+		body: JSON.stringify({ base_info: BASE_INFO })
+	}));
+	if (refused) throw new Error(refused);
+}
+/** `1` is a person typing at us. `2` is the bot, which is to say ourselves. */
+var FROM_USER = 1;
+var TEXT_ITEM = 1;
+/** What someone actually typed, with the parts we cannot read left out. */
+function textOf(message) {
+	return (message.item_list ?? []).filter((item) => item.type === TEXT_ITEM).map((item) => item.text_item?.text?.trim()).filter((text) => Boolean(text)).join("\n").trim();
+}
+function isFromPerson(message) {
+	return message.message_type === FROM_USER;
+}
+/**
+* How long to hold the connection open waiting for someone to type. This is a
+* long poll and the server decides when to answer, so the limit is ours: the
+* caller is a loop with other loops to get to, and an empty answer costs it a
+* turn rather than the whole minute.
+*/
+var WAIT_MS = 1e4;
+/**
+* Messages since the last call, and the cursor to hand back on the next one.
+*
+* Unlike everything else Loopable polls, this is a stream: what it returns, it
+* will not return again. Nothing is lost by giving up on a slow request, since
+* the cursor only moves when an answer arrives, but an answer that is thrown
+* away takes its messages with it.
+*/
+async function getUpdates(credential, cursor) {
+	const abort = new AbortController();
+	const timer = setTimeout(() => abort.abort(), WAIT_MS);
+	let body;
+	try {
+		body = await call(`${credential.baseUrl}/ilink/bot/getupdates`, {
+			method: "POST",
+			headers: postHeaders(credential.botToken),
+			body: JSON.stringify({
+				get_updates_buf: cursor,
+				base_info: BASE_INFO
+			}),
+			signal: abort.signal
+		});
+	} catch (error) {
+		if (abort.signal.aborted) return {
+			messages: [],
+			cursor
+		};
+		throw error;
+	} finally {
+		clearTimeout(timer);
+	}
+	const refused = refusal(body);
+	if (refused) throw new Error(refused);
+	return {
+		messages: body.msgs ?? [],
+		cursor: body.get_updates_buf || cursor
+	};
+}
+/**
+* Replies to whoever sent `contextToken`.
+*
+* The token comes off the message being answered and cannot be invented: it is
+* what tells WeChat which conversation this belongs to, and it goes stale
+* after a couple of days, which is why a reply is worth queueing but not worth
+* retrying for a week. `clientId` is what stops a retry saying it twice.
+*/
+async function sendMessage(credential, input) {
+	const body = await call(`${credential.baseUrl}/ilink/bot/sendmessage`, {
+		method: "POST",
+		headers: postHeaders(credential.botToken),
+		body: JSON.stringify({
+			msg: {
+				from_user_id: "",
+				to_user_id: input.toUserId,
+				client_id: input.clientId,
+				message_type: 2,
+				message_state: 2,
+				...input.contextToken ? { context_token: input.contextToken } : {},
+				item_list: [{
+					type: TEXT_ITEM,
+					text_item: { text: input.text }
+				}]
+			},
+			base_info: BASE_INFO
+		})
+	});
+	const refused = refusal(body);
+	if (!refused) return;
+	if (!input.contextToken && !signedOut(body)) throw new Error(`WeChat would not take a message nobody asked for (it said: ${refused}). It only delivers those for about half a day after you last write to the bot, so send the bot anything and this will go through.`);
+	throw new Error(refused);
+}
+/**
+* A login code lasted about two minutes when measured against the live API.
+* Told to the page so it can offer a fresh one rather than leave a dead square
+* on screen.
+*/
+var CODE_LIFETIME_MS = 11e4;
+function asAttempt(value) {
+	const record = value;
+	if (!record || typeof record.qrcode !== "string" || typeof record.host !== "string") throw new Error("This login is no longer valid. Ask for a new code.");
+	return {
+		qrcode: record.qrcode,
+		host: record.host
+	};
+}
+function asAsked(value) {
+	const record = value;
+	if (!record || typeof record.fromUserId !== "string" || typeof record.text !== "string") throw new Error("This task has lost the message it was about.");
+	return {
+		messageId: Number(record.messageId ?? 0),
+		fromUserId: record.fromUserId,
+		contextToken: typeof record.contextToken === "string" ? record.contextToken : void 0,
+		text: record.text
+	};
+}
+/** Enough of the message to recognise it in a list. */
+function summarise(text) {
+	const line = text.split("\n")[0].trim();
+	return line.length > 80 ? `${line.slice(0, 79)}…` : line;
+}
+/**
+* WeChat takes a message at a time and long ones are refused, so an answer
+* that runs on is sent in pieces rather than truncated.
+*/
+var CHUNK = 1500;
+function chunked(text) {
+	const parts = [];
+	let rest = text.trim();
+	while (rest.length > CHUNK) {
+		const window = rest.slice(0, CHUNK);
+		const cut = Math.max(window.lastIndexOf("\n\n"), window.lastIndexOf("\n"));
+		const at = cut > CHUNK / 2 ? cut : CHUNK;
+		parts.push(rest.slice(0, at).trim());
+		rest = rest.slice(at).trim();
+	}
+	if (rest) parts.push(rest);
+	return parts;
+}
+/**
+* Who the reply goes to, with the token that says which conversation it
+* belongs to when there is one.
+*
+* Answering whoever asked has that token off the message itself, and is the
+* case WeChat supports. Telling yourself about something that happened
+* elsewhere has no message behind it and so no token; that is sent anyway,
+* because refusing it would mean this cannot be offered at all, and the
+* setting says as much where it is chosen.
+*/
+function recipientFor(target, source, account) {
+	if (target.to === "me") return { userId: account.userId };
+	if (source.connectorId !== "wechat") throw new Error("There is no chat behind this task. Choose who to send it to on the loop.");
+	const carry = source.carry ?? {};
+	if (!carry.toUserId) throw new Error("There is nobody to reply to on this task.");
+	return {
+		userId: carry.toUserId,
+		contextToken: carry.contextToken
+	};
+}
+/** The account, said the way a person would recognise it. */
+function accountOf(credential) {
+	return {
+		id: credential.botId || credential.userId,
+		label: credential.botId ? `WeChat bot ${credential.botId}` : "WeChat bot"
+	};
+}
+/** Server-only registry. Never import this from a component. */
+var RUNTIMES = {
+	github: githubRuntime,
+	gmail: gmailRuntime,
+	wechat: {
+		async readiness() {
+			return { ready: true };
+		},
+		/**
+		* A stream, not a search: what this returns has already been taken off the
+		* server and will not be offered again, which is why every message it keeps
+		* carries its whole content rather than a pointer to it.
+		*/
+		async poll({ workflowId, settings, credential, cursor }) {
+			if (workflowId !== "wechat.ask") throw new Error(`WeChat cannot watch for ${workflowId}.`);
+			const account = credential;
+			const { messages, cursor: next } = await getUpdates(account, typeof cursor === "string" ? cursor : "");
+			const onlyMe = (settings.askers ?? "me") !== "anyone";
+			const signals = [];
+			for (const message of messages) {
+				if (!isFromPerson(message)) continue;
+				const text = textOf(message);
+				if (!text) continue;
+				const fromUserId = message.from_user_id ?? "";
+				const asked = {
+					messageId: message.message_id ?? 0,
+					fromUserId,
+					contextToken: message.context_token,
+					text
+				};
+				signals.push({
+					key: `msg#${asked.messageId}`,
+					kind: "message",
+					ref: `msg#${asked.messageId}`,
+					title: summarise(text),
+					url: "",
+					hold: onlyMe && fromUserId !== account.userId ? "sent by someone other than you" : void 0,
+					payload: asked
+				});
+			}
+			return {
+				signals,
+				cursor: next
+			};
+		},
+		async resolveWorkItem({ payload }) {
+			const asked = asAsked(payload);
+			return {
+				kind: "message",
+				ref: `msg#${asked.messageId}`,
+				title: summarise(asked.text),
+				url: "",
+				carry: {
+					toUserId: asked.fromUserId,
+					contextToken: asked.contextToken
+				},
+				context: [{
+					name: "MESSAGE.md",
+					body: [
+						`# What you were asked`,
+						``,
+						asked.text,
+						``
+					].join("\n")
+				}]
+			};
+		},
+		async applyAction({ actionId, target, source, body, credential }) {
+			if (actionId !== "wechat.reply") throw new Error(`WeChat cannot ${actionId}.`);
+			const account = credential;
+			const to = recipientFor(target, source, account);
+			for (const part of chunked(body)) await sendMessage(account, {
+				toUserId: to.userId,
+				contextToken: to.contextToken,
+				clientId: randomUUID(),
+				text: part
+			});
+			return { url: "" };
+		},
+		auth: {
+			async startQrLogin() {
+				const code = await requestQrCode();
+				return {
+					attempt: {
+						qrcode: code.qrcode,
+						host: WECHAT_API
+					},
+					encode: code.url,
+					expiresInMs: CODE_LIFETIME_MS
+				};
+			},
+			async pollQrLogin(value) {
+				const attempt = asAttempt(value);
+				const status = await qrCodeStatus(attempt.qrcode, attempt.host);
+				switch (status.state) {
+					case "confirmed": return {
+						state: "confirmed",
+						result: {
+							credential: status.credential,
+							account: accountOf(status.credential)
+						}
+					};
+					case "expired": return {
+						state: "expired",
+						reason: status.reason
+					};
+					case "waiting": return {
+						state: "pending",
+						attempt: {
+							qrcode: attempt.qrcode,
+							host: status.host
+						},
+						hint: status.hint
+					};
+				}
+			},
+			async identity(credential) {
+				const stored = credential;
+				await notifyStart(stored);
+				return { account: accountOf(stored) };
+			}
+		}
+	},
+	schedule: scheduleRuntime
+};
+function connectorRuntime(id) {
+	const runtime = RUNTIMES[id];
+	if (!runtime) throw new Error(`Unknown connector: ${id}`);
+	return runtime;
+}
+var ATTEMPT_TTL_MS = 6e5;
+function toView(row) {
+	return {
+		id: row.id,
+		connectorId: row.connectorId,
+		status: row.status,
+		accountLabel: row.accountLabel,
+		accountUrl: row.accountUrl,
+		avatarUrl: row.avatarUrl,
+		scopes: row.scopes ? row.scopes.split(",").filter(Boolean) : [],
+		settings: row.settings,
+		lastSyncedAt: row.lastSyncedAt?.toISOString() ?? null,
+		lastError: row.lastError,
+		createdAt: row.createdAt.toISOString()
+	};
+}
+async function listConnections() {
+	return (await db().select().from(connections).orderBy(asc(connections.createdAt)).all()).map(toView);
+}
+async function getConnection(id) {
+	return await db().select().from(connections).where(eq(connections.id, id)).get();
+}
+async function startAuthAttempt(input) {
+	const now = Date.now();
+	await db().delete(authAttempts).where(lt(authAttempts.expiresAt, new Date(now))).run();
+	await db().insert(authAttempts).values({
+		state: input.state,
+		connectorId: input.connectorId,
+		verifier: input.verifier,
+		redirectUri: input.redirectUri,
+		returnTo: input.returnTo,
+		expiresAt: new Date(now + ATTEMPT_TTL_MS)
+	}).run();
+}
+/** Consumes the attempt: a state value is only ever valid once. */
+async function takeAuthAttempt(state) {
+	const attempt = await db().select().from(authAttempts).where(eq(authAttempts.state, state)).get();
+	if (attempt) await db().delete(authAttempts).where(eq(authAttempts.state, state)).run();
+	if (!attempt) throw new Error("This authorization link is no longer valid. Start again.");
+	if (attempt.expiresAt.getTime() < Date.now()) throw new Error("The authorization took too long. Start again.");
+	return attempt;
+}
+function scopesToColumn(account) {
+	return account.scopes?.length ? account.scopes.join(",") : null;
+}
+/**
+* Stores the result of a successful authorization. Re-authorizing the same
+* account updates the existing connection instead of creating a duplicate.
+*/
+async function saveAuthorizedConnection(connectorId, result) {
+	const existing = await db().select().from(connections).where(and(eq(connections.connectorId, connectorId), eq(connections.accountId, result.account.id))).get();
+	const id = existing?.id ?? randomUUID();
+	await writeCredential(id, result.credential);
+	const values = {
+		connectorId,
+		status: "connected",
+		accountId: result.account.id,
+		accountLabel: result.account.label,
+		accountUrl: result.account.url ?? null,
+		avatarUrl: result.account.avatarUrl ?? null,
+		scopes: scopesToColumn(result.account),
+		lastError: null,
+		updatedAt: /* @__PURE__ */ new Date()
+	};
+	if (existing) await db().update(connections).set(values).where(eq(connections.id, id)).run();
+	else await db().insert(connections).values({
+		id,
+		...values
+	}).run();
+	const row = await getConnection(id);
+	if (!row) throw new Error("Failed to persist the connection");
+	return toView(row);
+}
+async function removeConnection(id) {
+	const row = await getConnection(id);
+	if (!row) return;
+	const runtime = connectorRuntime(row.connectorId);
+	if (runtime.auth.revoke) {
+		const credential = await readCredential(id);
+		if (credential) try {
+			await runtime.auth.revoke(credential);
+		} catch {}
+	}
+	await deleteCredential(id);
+	await db().delete(connections).where(eq(connections.id, id)).run();
+}
+async function updateConnectionSettings(id, settings) {
+	await db().update(connections).set({
+		settings,
+		updatedAt: /* @__PURE__ */ new Date()
+	}).where(eq(connections.id, id)).run();
+	const row = await getConnection(id);
+	if (!row) throw new Error("Connection not found");
+	return toView(row);
+}
+/**
+* A credential a run can use right now. Goes through the connection check so a
+* rotated credential is stored rather than refreshed again on the next run,
+* and so a broken connection fails here with a clear message instead of a 401
+* in the middle of the work.
+*/
+async function credentialForConnector(connectorId) {
+	if (!needsAccount(connectorId)) return { credential: null };
+	const row = await db().select().from(connections).where(eq(connections.connectorId, connectorId)).orderBy(asc(connections.createdAt)).get();
+	if (!row) throw new Error(`No ${connectorId} account is connected.`);
+	const checked = await checkConnection(row.id);
+	if (checked.status !== "connected") throw new Error(checked.lastError ?? `The ${connectorId} connection needs reconnecting.`);
+	const credential = await readCredential(row.id);
+	if (!credential) throw new Error(`No credential is stored for ${connectorId}.`);
+	return { credential };
+}
+/** Proves the stored credential still works and refreshes the shown account. */
+async function checkConnection(id) {
+	const row = await getConnection(id);
+	if (!row) throw new Error("Connection not found");
+	const runtime = connectorRuntime(row.connectorId);
+	const credential = await readCredential(id);
+	if (!credential) {
+		await db().update(connections).set({
+			status: "needs_reauth",
+			lastError: "No credential is stored for this connection.",
+			updatedAt: /* @__PURE__ */ new Date()
+		}).where(eq(connections.id, id)).run();
+		return toView(await getConnection(id));
+	}
+	try {
+		const { account, renewedCredential } = await runtime.auth.identity(credential);
+		if (renewedCredential) await writeCredential(id, renewedCredential);
+		await db().update(connections).set({
+			status: "connected",
+			accountLabel: account.label,
+			accountUrl: account.url ?? null,
+			avatarUrl: account.avatarUrl ?? null,
+			scopes: scopesToColumn(account),
+			lastError: null,
+			lastSyncedAt: /* @__PURE__ */ new Date(),
+			updatedAt: /* @__PURE__ */ new Date()
+		}).where(eq(connections.id, id)).run();
+	} catch (error) {
+		await db().update(connections).set({
+			status: "needs_reauth",
+			lastError: error instanceof Error ? error.message : String(error),
+			updatedAt: /* @__PURE__ */ new Date()
+		}).where(eq(connections.id, id)).run();
+	}
+	return toView(await getConnection(id));
+}
+//#endregion
+export { connectorManifest as a, credentialForConnector as c, removeConnection as d, saveAuthorizedConnection as f, updateConnectionSettings as h, connectorAction as i, listConnections as l, takeAuthAttempt as m, allWorkflows as n, connectorRuntime as o, startAuthAttempt as p, checkConnection as r, connectorWorkflow as s, CONNECTOR_MANIFESTS as t, needsAccount as u };