loopable-cli 0.2.0 → 0.3.0

package/.output/server/_ssr/{connections-ypex3qUd.mjs → connections-Cqvb6Gw2.mjs}

@@ -1,10 +1,10 @@
 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-BtVRVhQ2.mjs";
-import { i as readCredential, s as writeCredential, t as deleteCredential } from "./secrets-CRnpwGBh.mjs";
+import { a as connections, i as authAttempts, s as db } from "./client-Dk3SD8Il.mjs";
+import { i as readCredential, s as writeCredential, t as deleteCredential } from "./secrets-CV5scFlt.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-ypex3qUd.js
+//#region node_modules/.nitro/vite/services/ssr/assets/connections-Cqvb6Gw2.js
 function defineManifest(manifest) {
 	return manifest;
 }
@@ -16,7 +16,7 @@ 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.",
+	help: "owner/name, one per line. acme/* works. Empty means all.",
 	placeholder: "acme/web"
 };
 var ignoreDrafts = {
@@ -29,7 +29,7 @@ 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.",
+	help: "Such as Dependabot.",
 	default: true
 };
 /**
@@ -69,7 +69,7 @@ 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.",
+	help: "Empty replies where it was asked. Or a GitHub issue URL.",
 	placeholder: "https://github.com/acme/web/issues/12"
 };
 /**
@@ -91,115 +91,80 @@ var REVIEW_PROMPT = [
 	"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.",
+var REPLY_PROMPT = [
+	"Answer this issue in a comment, the way a teammate who knows this codebase would.",
 	"",
-	"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.",
+	"Work out what the issue is asking for. If it is a question, answer it from the",
+	"code rather than from memory. If it reports a bug, find the likely cause and",
+	"point at the files and lines involved. If it asks for a change, say how you",
+	"would make it, where, and what to watch out for.",
 	"",
-	"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."
+	"Read the code; do not change it. If the issue is too vague to answer, say what",
+	"is missing rather than inventing it."
 ].join("\n");
 var githubManifest = defineManifest({
 	id: "github",
 	name: "GitHub",
-	tagline: "Pick up review requests and assigned issues.",
+	tagline: "Pick up reviews and issues sent to your team's shared GitHub account.",
 	docsUrl: "https://docs.github.com/rest",
 	icon: "Github",
 	accent: "bg-neutral-900 text-white",
 	auth: {
 		kind: "oauth_redirect",
 		scopes: GITHUB_SCOPES,
-		needsAppRegistration: true
+		needsAppRegistration: true,
+		note: "Connect the account the team will send work to. An account made for this is cleanest, but your own works too if you are happy to share it. Reviews and comments appear under its name, and it sees only the repositories it can access. Sign in to GitHub as that account first; GitHub authorizes whichever account the browser is signed in as."
 	},
-	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"]
-		}
-	],
+	triggers: [{
+		id: "github.review_requested",
+		when: "A GitHub review is requested",
+		trigger: "someone requests a review from the connected account, directly or through its team",
+		watches: "is:open is:pr review-requested:@me",
+		settings: [
+			repositories,
+			ignoreDrafts,
+			ignoreBots,
+			sizeLimit
+		],
+		runsIn: "checkout",
+		answer: "review",
+		actionId: "github.submit_review"
+	}, {
+		id: "github.issue_assigned",
+		when: "A GitHub issue is assigned",
+		trigger: "an issue is assigned to the connected account",
+		watches: "is:open is:issue assignee:@me",
+		settings: [repositories],
+		runsIn: "checkout",
+		answer: "text",
+		actionId: "github.post_issue_comment"
+	}],
+	workflows: [{
+		id: "github.review_requested",
+		name: "Review pull requests",
+		summary: "Posts a review when someone requests one from the connected account.",
+		triggerId: "github.review_requested",
+		prompt: REVIEW_PROMPT
+	}, {
+		id: "github.issue_assigned",
+		name: "Reply to issues",
+		summary: "Answers an issue in a comment when it is assigned to the connected account.",
+		triggerId: "github.issue_assigned",
+		prompt: REPLY_PROMPT
+	}],
+	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"]
+	}],
 	settings: [],
 	allowsMultipleAccounts: false,
 	byHand: {
@@ -208,86 +173,14 @@ var githubManifest = defineManifest({
 	}
 });
 /**
-* 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.
+* Read, and send. Sending is only ever to the connected account itself, the
+* way a bot answers whoever asked it; the agent never holds the token.
 */
-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 GMAIL_SCOPES = ["https://www.googleapis.com/auth/gmail.readonly", "https://www.googleapis.com/auth/gmail.send"];
 var gmailManifest = defineManifest({
 	id: "gmail",
 	name: "Gmail",
-	tagline: "Read new mail and have an agent tell you what matters.",
+	tagline: "Start a loop when an email arrives, or email an answer to the connected account.",
 	docsUrl: "https://developers.google.com/gmail/api/guides",
 	icon: "Gmail",
 	accent: "bg-[#ea4335] text-white",
@@ -296,29 +189,67 @@ var gmailManifest = defineManifest({
 		scopes: GMAIL_SCOPES,
 		needsAppRegistration: true
 	},
-	workflows: [{
+	triggers: [{
 		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",
+		when: "An email arrives",
+		trigger: "an email arrives in the connected inbox",
 		watches: "in:inbox newer_than:1d",
-		writes: "a message telling you what arrived",
 		runsIn: "temp",
 		settings: [
-			extraQuery,
-			needsMeOnly,
-			perPoll,
-			skipOwn
+			{
+				key: "extraQuery",
+				kind: "text",
+				label: "Only mail matching",
+				help: "Gmail search terms, such as from:billing@vendor.com or subject:invoice.",
+				placeholder: "from:alerts@example.com"
+			},
+			{
+				key: "needsMeOnly",
+				kind: "boolean",
+				label: "Skip mail that needs nothing",
+				help: "A quick look first decides which mail asks for something. The rest is kept, not run.",
+				default: true
+			},
+			{
+				key: "maxPerPoll",
+				kind: "select",
+				label: "At most, per check",
+				options: [
+					{
+						value: "3",
+						label: "3 emails"
+					},
+					{
+						value: "10",
+						label: "10 emails"
+					},
+					{
+						value: "25",
+						label: "25 emails"
+					}
+				],
+				default: "10"
+			},
+			{
+				key: "skipOwn",
+				kind: "boolean",
+				label: "Skip mail sent from this account",
+				default: true
+			}
 		],
-		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" },
+		actionConnectorId: "schedule",
+		actionId: "schedule.record",
 		pollEveryMs: 18e5
 	}],
-	actions: [],
+	workflows: [],
+	actions: [{
+		id: "gmail.send",
+		name: "Email this account",
+		summary: "Send the answer to the connected account's own inbox, in the same thread when it started from an email there.",
+		target: [],
+		accepts: ["text"]
+	}],
 	settings: [],
 	allowsMultipleAccounts: false,
 	byHand: { kind: "none" }
@@ -454,27 +385,20 @@ 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.",
+	help: "24-hour time, in this host's time zone.",
 	placeholder: "09:00"
 };
 var weekday = {
 	key: "weekday",
 	kind: "select",
 	label: "On",
-	help: "Only used by a loop that runs once a week.",
+	help: "For weekly loops.",
 	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
@@ -504,44 +428,175 @@ var scheduleManifest = defineManifest({
 	allowsMultipleAccounts: false,
 	byHand: { kind: "now" },
 	settings: [],
-	workflows: [{
+	triggers: [{
 		id: "schedule.recurring",
-		name: "Do something on a schedule",
-		summary: "Runs an agent in a folder you name, and keeps what it says.",
+		when: "On a schedule",
 		trigger: "the time you set comes round",
-		writes: "a note in the log",
 		runsIn: "folder",
 		settings: [
 			every,
 			at,
-			weekday,
-			folder$1
+			weekday
 		],
-		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"
 	}],
+	workflows: [{
+		id: "schedule.recurring",
+		name: "Do something on a schedule",
+		summary: "Runs the agent at the times you set, in a folder you name. The answer stays in Inbox, or goes to Slack, Lark, or GitHub.",
+		triggerId: "schedule.recurring",
+		prompt: RECURRING_PROMPT
+	}],
 	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.",
+		name: "Keep in Inbox",
+		summary: "Keeps the answer in Inbox and sends it nowhere.",
 		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"
-};
+var slackManifest = defineManifest({
+	id: "slack",
+	name: "Slack bot",
+	tagline: "Paste a bot token from a Slack app — not a Slack login. @mention or DM the bot, and it answers in the thread.",
+	docsUrl: "https://api.slack.com/apps",
+	icon: "Slack",
+	accent: "bg-[#4a154b] text-white",
+	auth: {
+		kind: "token",
+		helpUrl: "https://api.slack.com/apps",
+		note: "This is a Slack app in the workspace, not a Slack account sign-in. Create an app at api.slack.com/apps, add bot scopes (channels:history, channels:read, groups:history, groups:read, im:history, im:read, mpim:history, mpim:read, chat:write), Install to Workspace, then paste the Bot User OAuth Token. Invite the bot to any channel it should watch.",
+		fields: [{
+			key: "botToken",
+			label: "Bot User OAuth Token",
+			placeholder: "xoxb-...",
+			secret: true
+		}]
+	},
+	triggers: [{
+		id: "slack.ask",
+		when: "The Slack bot is mentioned",
+		trigger: "someone @mentions the Slack bot in a channel it is in, or DMs it",
+		runsIn: "folder",
+		settings: [],
+		answer: "text",
+		actionId: "slack.reply",
+		pollEveryMs: 6e4
+	}],
+	workflows: [{
+		id: "slack.ask",
+		name: "Do what I ask the Slack bot",
+		summary: "Runs the agent when someone @mentions the Slack bot or DMs it, and answers in the thread.",
+		triggerId: "slack.ask",
+		prompt: [
+			"Someone has sent you a message in Slack. Do what it asks, working in this directory,",
+			"and then answer them.",
+			"",
+			"You are answering into Slack. 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")
+	}],
+	actions: [{
+		id: "slack.reply",
+		name: "Reply in Slack",
+		summary: "Post a message back to the thread that asked, or to a channel you name.",
+		target: [{
+			key: "channel",
+			kind: "text",
+			label: "Channel",
+			help: "Empty replies where it was asked. Or a channel ID.",
+			placeholder: "C0123456789"
+		}],
+		accepts: ["text"]
+	}],
+	settings: [],
+	allowsMultipleAccounts: false,
+	byHand: { kind: "none" }
+});
+var feishuManifest = defineManifest({
+	id: "feishu",
+	name: "Feishu / Lark bot",
+	tagline: "Paste App ID and App Secret from a Feishu or Lark app — not a Feishu login. @mention the bot in a group, and it answers in the thread.",
+	docsUrl: "https://open.feishu.cn/app",
+	icon: "Feishu",
+	accent: "bg-[#3370ff] text-white",
+	auth: {
+		kind: "token",
+		helpUrl: "https://open.feishu.cn/app",
+		note: "This is a custom Feishu or Lark app, not a Feishu account sign-in. Create an app, enable Bot, add permissions (im:chat:readonly, im:message, im:message.group_msg, im:message:send_as_bot), create a version and publish it, then paste App ID and App Secret. Invite the bot to any group it should watch. Put lark in Open platform for Lark (international).",
+		fields: [
+			{
+				key: "appId",
+				label: "App ID",
+				placeholder: "cli_...",
+				secret: false
+			},
+			{
+				key: "appSecret",
+				label: "App Secret",
+				placeholder: "App Secret",
+				secret: true
+			},
+			{
+				key: "host",
+				label: "Open platform",
+				placeholder: "feishu or lark",
+				secret: false,
+				optional: true
+			}
+		]
+	},
+	triggers: [{
+		id: "feishu.ask",
+		when: "The Feishu / Lark bot is mentioned",
+		trigger: "someone @mentions the Feishu / Lark bot in a group it is in",
+		runsIn: "folder",
+		settings: [],
+		answer: "text",
+		actionId: "feishu.reply",
+		pollEveryMs: 6e4
+	}],
+	workflows: [{
+		id: "feishu.ask",
+		name: "Do what I ask the Feishu / Lark bot",
+		summary: "Runs the agent when someone @mentions the Feishu / Lark bot in a group, and answers in the thread.",
+		triggerId: "feishu.ask",
+		prompt: [
+			"Someone has sent you a message in Feishu. Do what it asks, working in this directory,",
+			"and then answer them.",
+			"",
+			"You are answering into Feishu. 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")
+	}],
+	actions: [{
+		id: "feishu.reply",
+		name: "Reply in Feishu / Lark",
+		summary: "Post a message back to the thread that asked, or to a chat you name.",
+		target: [{
+			key: "chat",
+			kind: "text",
+			label: "Chat ID",
+			help: "Empty replies where it was asked. Or a chat ID (oc_…).",
+			placeholder: "oc_..."
+		}],
+		accepts: ["text"]
+	}],
+	settings: [],
+	allowsMultipleAccounts: false,
+	byHand: { kind: "none" }
+});
 /**
 * 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
@@ -571,7 +626,7 @@ 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.",
+	help: "\"Me\" only arrives if you messaged the bot in the last half day.",
 	options: [{
 		value: "source",
 		label: "Whoever asked"
@@ -600,6 +655,8 @@ var ASK_PROMPT = [
 */
 var CONNECTOR_MANIFESTS = [
 	githubManifest,
+	slackManifest,
+	feishuManifest,
 	gmailManifest,
 	{
 		id: "wechat",
@@ -612,19 +669,22 @@ var CONNECTOR_MANIFESTS = [
 			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: [{
+		triggers: [{
 			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",
+			when: "The WeChat bot gets a message",
+			trigger: "someone sends the WeChat bot a message",
 			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.",
+			settings: [askers],
 			answer: "text",
 			actionId: "wechat.reply"
 		}],
+		workflows: [{
+			id: "wechat.ask",
+			name: "Do what I ask the WeChat bot",
+			summary: "Runs the agent when someone messages the WeChat bot, and answers in the chat.",
+			triggerId: "wechat.ask",
+			prompt: ASK_PROMPT
+		}],
 		actions: [{
 			id: "wechat.reply",
 			name: "Reply in the chat",
@@ -642,26 +702,106 @@ function connectorManifest(id) {
 	return CONNECTOR_MANIFESTS.find((manifest) => manifest.id === id);
 }
 /**
-* Whether this connector is somewhere you have an account.
+* Whether this connector is somewhere you have a Connection.
 *
 * 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
+* the page listing connections, 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";
 }
+/**
+* What one Connection of this connector is called in the UI.
+* A Slack or Feishu bot is a pasted app credential, not a login.
+*/
+function connectionNoun(id) {
+	return connectorManifest(id)?.auth.kind === "token" ? "bot" : "account";
+}
+/** A trigger with nothing on top: what a custom loop runs. */
+function customOn(trigger) {
+	return {
+		...trigger,
+		triggerId: trigger.id,
+		name: trigger.when,
+		summary: `When ${trigger.trigger}.`,
+		prompt: "",
+		custom: true
+	};
+}
+/**
+* What a loop runs, by the id it stores: a workflow, merged with the trigger
+* it sits on, or a trigger alone for a custom loop.
+*/
 function connectorWorkflow(connectorId, workflowId) {
-	return connectorManifest(connectorId)?.workflows.find((entry) => entry.id === workflowId);
+	const manifest = connectorManifest(connectorId);
+	if (!manifest) return void 0;
+	const defined = manifest.workflows.find((entry) => entry.id === workflowId);
+	if (defined) {
+		const trigger = manifest.triggers.find((entry) => entry.id === defined.triggerId);
+		if (!trigger) return void 0;
+		return {
+			...trigger,
+			...defined,
+			actionId: defined.actionId ?? trigger.actionId,
+			actionConnectorId: defined.actionConnectorId ?? trigger.actionConnectorId,
+			actionTarget: defined.actionTarget ?? trigger.actionTarget,
+			pollEveryMs: defined.pollEveryMs ?? trigger.pollEveryMs,
+			triggerId: trigger.id,
+			custom: false
+		};
+	}
+	const trigger = manifest.triggers.find((entry) => entry.id === workflowId);
+	return trigger ? customOn(trigger) : void 0;
 }
 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. */
+/**
+* Keeping the answer in Inbox is the clock's action, because the clock is the
+* one connector with nowhere of its own to write. To a person it is not a
+* Schedule thing at all, so it is named for where the answer stays.
+*/
+var INBOX_ONLY = {
+	connectorId: "schedule",
+	actionId: "schedule.record"
+};
+function isInboxOnly(connectorId, actionId) {
+	return connectorId === INBOX_ONLY.connectorId && actionId === INBOX_ONLY.actionId;
+}
+/** What to call a connector as a place answers go. */
+function writerName(connectorId) {
+	if (connectorId === INBOX_ONLY.connectorId) return "Inbox";
+	return connectorManifest(connectorId)?.name ?? connectorId;
+}
+/** Where a loop's answer goes, in a few words: "GitHub · Submit a review", or "Inbox only". */
+function destinationLabel(connectorId, actionId) {
+	if (isInboxOnly(connectorId, actionId)) return "Inbox only";
+	const action = connectorAction(connectorId, actionId);
+	return action ? `${writerName(connectorId)} · ${action.name}` : "No destination";
+}
+/** Connectors that can write, Inbox first, for the question of where an answer goes. */
+function writers() {
+	const all = CONNECTOR_MANIFESTS.filter((entry) => entry.actions.length > 0);
+	return [...all.filter((entry) => entry.id === INBOX_ONLY.connectorId), ...all.filter((entry) => entry.id !== INBOX_ONLY.connectorId)];
+}
+/**
+* Every workflow on offer, for the page that asks which one to turn on.
+*
+* The clock leads: it needs no account, and a scheduled job is the easiest
+* first loop to try. The rest follow the connectors' own order.
+*/
 function allWorkflows() {
-	return CONNECTOR_MANIFESTS.flatMap((connector) => connector.workflows.map((workflow) => ({
+	return [...CONNECTOR_MANIFESTS.filter((connector) => connector.id === "schedule"), ...CONNECTOR_MANIFESTS.filter((connector) => connector.id !== "schedule")].flatMap((connector) => connector.workflows.map((entry) => ({
+		connector,
+		workflow: connectorWorkflow(connector.id, entry.id)
+	})));
+}
+/** Every trigger on offer, the clock first, for choosing what starts a custom loop. */
+function allTriggers() {
+	return [...CONNECTOR_MANIFESTS.filter((connector) => connector.id === "schedule"), ...CONNECTOR_MANIFESTS.filter((connector) => connector.id !== "schedule")].flatMap((connector) => connector.triggers.map((trigger) => ({
 		connector,
-		workflow
+		trigger
 	})));
 }
 /**
@@ -1124,15 +1264,15 @@ function candidates(items, repositories) {
 	});
 }
 /**
-* What the workflow says it watches for, which is what gets asked. Taking the
+* What the trigger 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;
+function query(triggerId) {
+	const trigger = githubManifest.triggers.find((entry) => entry.id === triggerId);
+	if (!trigger?.watches) throw new Error(`GitHub cannot watch for ${triggerId}.`);
+	return trigger.watches;
 }
 async function pollGithub(input) {
 	const repositories = stringList(input.settings.repositories);
@@ -1405,13 +1545,18 @@ var githubRuntime = defineRuntime({
 	}
 });
 var BASE = "https://gmail.googleapis.com/gmail/v1/users/me";
-async function request(accessToken, path) {
+async function request(accessToken, path, init = {}) {
 	let res;
 	try {
-		res = await fetch(`${BASE}${path}`, { headers: {
-			Authorization: `Bearer ${accessToken}`,
-			Accept: "application/json"
-		} });
+		res = await fetch(`${BASE}${path}`, {
+			method: init.method ?? "GET",
+			headers: {
+				Authorization: `Bearer ${accessToken}`,
+				Accept: "application/json",
+				...init.body === void 0 ? {} : { "Content-Type": "application/json" }
+			},
+			...init.body === void 0 ? {} : { body: JSON.stringify(init.body) }
+		});
 	} catch (error) {
 		throw new TransientError(`Gmail could not be reached: ${error instanceof Error ? error.message : String(error)}`);
 	}
@@ -1420,6 +1565,7 @@ async function request(accessToken, path) {
 		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);
+		if (res.status === 403 && /insufficient.*scope|ACCESS_TOKEN_SCOPE_INSUFFICIENT/i.test(detail)) throw new Error("This Gmail connection cannot send mail. Reconnect Gmail to allow it.");
 		throw new Error(message);
 	}
 	return await res.json();
@@ -1456,6 +1602,16 @@ function getMessageHeaders(accessToken, id) {
 function getMessage(accessToken, id) {
 	return request(accessToken, `/messages/${id}?format=full`);
 }
+/** Send a message already written as RFC 2822 text, in a thread when one is given. */
+function sendMessage$2(accessToken, raw, threadId) {
+	return request(accessToken, "/messages/send", {
+		method: "POST",
+		body: threadId ? {
+			raw,
+			threadId
+		} : { raw }
+	});
+}
 /** A Gmail message id, as a ref: short, stable, and unique to the mailbox. */
 function mailRef(id) {
 	return `mail#${id}`;
@@ -1464,7 +1620,7 @@ function mailRef(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) {
+function permalink$2(id) {
 	return `https://mail.google.com/mail/u/0/#all/${id}`;
 }
 function headerOf(message, name) {
@@ -1532,7 +1688,7 @@ function attachmentNames(message) {
 	return names;
 }
 /** Enough of a message to pick it out of a list. */
-function summarise$1(message) {
+function summarise$3(message) {
 	const subject = headerOf(message, "Subject") || "(no subject)";
 	const who = senderName(headerOf(message, "From"));
 	const title = who ? `${who}: ${subject}` : subject;
@@ -1567,6 +1723,30 @@ function mailContext(message) {
 		].join("\n")
 	};
 }
+/** Base64url, as Gmail wants a raw message. */
+function base64url(text) {
+	return Buffer.from(text, "utf8").toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+/** A header value that may hold any text, encoded so non-ASCII survives. */
+function encodedWord(text) {
+	return /^[\x20-\x7e]*$/.test(text) ? text : `=?UTF-8?B?${Buffer.from(text, "utf8").toString("base64")}?=`;
+}
+/**
+* A plain-text email as Gmail's `raw`. The body is base64 so any line length
+* and any language go through untouched.
+*/
+function composeMail(input) {
+	return base64url([
+		`To: ${input.to}`,
+		`Subject: ${encodedWord(input.subject)}`,
+		...input.inReplyTo ? [`In-Reply-To: ${input.inReplyTo}`, `References: ${input.inReplyTo}`] : [],
+		"MIME-Version: 1.0",
+		"Content-Type: text/plain; charset=\"UTF-8\"",
+		"Content-Transfer-Encoding: base64",
+		"",
+		Buffer.from(input.body, "utf8").toString("base64").replace(/.{76}/g, "$&\r\n")
+	].join("\r\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
@@ -1574,9 +1754,9 @@ function mailContext(message) {
 * 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;
+	const trigger = gmailManifest.triggers.find((entry) => entry.id === workflowId);
+	if (!trigger?.watches) throw new Error(`Gmail cannot watch for ${workflowId}.`);
+	return trigger.watches;
 }
 /**
 * Missing means "the workflow's default", not "off". A loop saved before a
@@ -1611,8 +1791,8 @@ async function pollGmail(input) {
 			key: mailRef(id),
 			kind: "email",
 			ref: mailRef(id),
-			title: summarise$1(message),
-			url: permalink(id),
+			title: summarise$3(message),
+			url: permalink$2(id),
 			preview: (message.snippet ?? "").trim() || void 0,
 			payload: { messageId: id }
 		});
@@ -1737,14 +1917,14 @@ async function usableToken(credential) {
 	};
 }
 /** The mailbox, as a person would recognise it. */
-function accountOf$1(emailAddress) {
+function accountOf$3(emailAddress) {
 	return {
 		id: emailAddress,
 		label: emailAddress
 	};
 }
 /**
-* Which message this task is about. The poll keeps the id, and a pasted link
+* Which message this task is about. A task keeps the id, and a pasted link
 * carries one too, so either is enough to fetch the mail again.
 */
 function messageIdFrom(url, payload) {
@@ -1778,8 +1958,8 @@ var gmailRuntime = defineRuntime({
 		return {
 			kind: "email",
 			ref: mailRef(message.id),
-			title: summarise$1(message),
-			url: permalink(message.id),
+			title: summarise$3(message),
+			url: permalink$2(message.id),
 			context: [mailContext(message)]
 		};
 	},
@@ -1792,6 +1972,33 @@ var gmailRuntime = defineRuntime({
 			emailAddress: (await getProfile(accessToken)).emailAddress
 		}) };
 	},
+	/**
+	* Answers go to the connected account itself, the way a bot answers
+	* whoever asked it. When the run started from an email in this inbox, the
+	* answer joins that thread.
+	*/
+	async applyAction({ actionId, source, body, credential }) {
+		if (actionId !== "gmail.send") throw new Error(`Gmail cannot ${actionId}.`);
+		const { accessToken } = await usableToken(credential);
+		const profile = await getProfile(accessToken);
+		let subject = source.title || "From Loopable";
+		let threadId;
+		let inReplyTo;
+		const sourceId = source.connectorId === "gmail" ? source.ref.replace(/^mail#/, "") : "";
+		if (sourceId) {
+			const original = await getMessage(accessToken, sourceId);
+			threadId = original.threadId;
+			inReplyTo = headerOf(original, "Message-ID") || void 0;
+			const said = headerOf(original, "Subject");
+			if (said) subject = /^re:/i.test(said) ? said : `Re: ${said}`;
+		}
+		return { url: permalink$2((await sendMessage$2(accessToken, composeMail({
+			to: profile.emailAddress,
+			subject,
+			body,
+			inReplyTo
+		}), threadId)).id) };
+	},
 	auth: {
 		async startAuthorization({ redirectUri, state }) {
 			const registration = requireRegistration();
@@ -1817,12 +2024,12 @@ var gmailRuntime = defineRuntime({
 			});
 			return {
 				credential,
-				account: accountOf$1((await getProfile(credential.accessToken)).emailAddress)
+				account: accountOf$3((await getProfile(credential.accessToken)).emailAddress)
 			};
 		},
 		async identity(credential) {
 			const { accessToken, refreshed } = await usableToken(credential);
-			const account = accountOf$1((await getProfile(accessToken)).emailAddress);
+			const account = accountOf$3((await getProfile(accessToken)).emailAddress);
 			return refreshed ? {
 				account,
 				renewedCredential: refreshed
@@ -1930,6 +2137,643 @@ var scheduleRuntime = {
 	}
 };
 /**
+* Slack Web API, called with a bot token pasted from a workspace-installed app.
+* Loopable polls; Slack never has to reach this machine.
+*/
+var API$1 = "https://slack.com/api";
+async function slack(path, token, init = {}) {
+	const url = new URL(`${API$1}/${path}`);
+	for (const [key, value] of Object.entries(init.query ?? {})) url.searchParams.set(key, value);
+	let response;
+	try {
+		response = await fetch(url.href, {
+			method: init.method ?? "GET",
+			headers: {
+				Authorization: `Bearer ${token}`,
+				...init.body ? { "Content-Type": "application/json" } : {}
+			},
+			body: init.body ? JSON.stringify(init.body) : void 0
+		});
+	} catch (error) {
+		throw new TransientError(`Slack is unreachable: ${error.message}`);
+	}
+	if (response.status >= 500 || response.status === 429) throw new TransientError(`Slack answered ${response.status}`);
+	if (!response.ok) throw new Error(`Slack answered ${response.status}`);
+	return await response.json();
+}
+function refuse$1(error) {
+	if (error === "invalid_auth" || error === "not_authed" || error === "token_revoked" || error === "account_inactive") throw new Error("Slack did not accept that token.");
+	throw new Error(error ? `Slack refused: ${error}` : "Slack refused the request.");
+}
+async function authTest(botToken) {
+	const body = await slack("auth.test", botToken);
+	if (!body.ok) refuse$1(body.error);
+	const teamUrl = typeof body.url === "string" ? body.url : "";
+	const team = typeof body.team === "string" ? body.team : "";
+	const teamId = typeof body.team_id === "string" ? body.team_id : "";
+	const botUserId = typeof body.user_id === "string" ? body.user_id : "";
+	const botId = typeof body.bot_id === "string" ? body.bot_id : "";
+	const botName = typeof body.user === "string" ? body.user : "";
+	if (!teamId || !botUserId) throw new Error("Slack did not return which workspace this bot belongs to.");
+	return {
+		botToken,
+		teamId,
+		team,
+		teamUrl,
+		botUserId,
+		botId,
+		botName
+	};
+}
+async function listConversations(credential) {
+	const body = await slack("conversations.list", credential.botToken, { query: {
+		types: "public_channel,private_channel,im,mpim",
+		exclude_archived: "true",
+		limit: "200"
+	} });
+	if (!body.ok) refuse$1(body.error);
+	return (Array.isArray(body.channels) ? body.channels : []).map((raw) => {
+		const channel = raw;
+		if (!channel.id) return null;
+		return {
+			id: channel.id,
+			name: channel.name ?? "",
+			isIm: channel.is_im === true
+		};
+	}).filter((channel) => channel !== null);
+}
+async function history$1(credential, channelId, oldest) {
+	const query = {
+		channel: channelId,
+		limit: "100",
+		inclusive: "false"
+	};
+	if (oldest) query.oldest = oldest;
+	const body = await slack("conversations.history", credential.botToken, { query });
+	if (!body.ok) {
+		if (body.error === "not_in_channel" || body.error === "channel_not_found") return [];
+		refuse$1(body.error);
+	}
+	const messages = Array.isArray(body.messages) ? body.messages : [];
+	const parsed = [];
+	for (const raw of messages) {
+		const message = raw;
+		if (!message.ts) continue;
+		parsed.push({
+			ts: message.ts,
+			...message.user ? { user: message.user } : {},
+			...message.bot_id ? { botId: message.bot_id } : {},
+			text: message.text ?? "",
+			...message.thread_ts ? { threadTs: message.thread_ts } : {}
+		});
+	}
+	return parsed.sort((a, b) => Number(a.ts) - Number(b.ts));
+}
+async function postMessage(credential, input) {
+	const body = await slack("chat.postMessage", credential.botToken, {
+		method: "POST",
+		body: {
+			channel: input.channel,
+			text: input.text,
+			...input.threadTs ? { thread_ts: input.threadTs } : {}
+		}
+	});
+	if (!body.ok) refuse$1(body.error);
+	const ts = typeof body.ts === "string" ? body.ts : "";
+	const channel = typeof body.channel === "string" ? body.channel : input.channel;
+	if (!ts) throw new Error("Slack accepted the message but did not say where it landed.");
+	return {
+		ts,
+		channel
+	};
+}
+function permalink$1(credential, channel, ts) {
+	return `${credential.teamUrl.replace(/\/$/, "")}/archives/${channel}/p${ts.replace(".", "")}`;
+}
+function asAsked$2(value) {
+	const record = value;
+	if (!record || typeof record.channel !== "string" || typeof record.ts !== "string") throw new Error("This task has lost the message it was about.");
+	return {
+		channel: record.channel,
+		ts: record.ts,
+		user: typeof record.user === "string" ? record.user : void 0,
+		text: typeof record.text === "string" ? record.text : "",
+		threadTs: typeof record.threadTs === "string" ? record.threadTs : record.ts
+	};
+}
+function asCursor$1(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	const out = {};
+	for (const [key, entry] of Object.entries(value)) if (typeof entry === "string") out[key] = entry;
+	return out;
+}
+function summarise$2(text) {
+	const line = text.replace(/<@[^>]+>/g, "").replace(/\s+/g, " ").trim();
+	if (!line) return "Slack message";
+	return line.length > 80 ? `${line.slice(0, 79)}…` : line;
+}
+function isAsk$1(input) {
+	if (input.user === input.botUserId || input.messageBotId && input.messageBotId === input.botId) return false;
+	if (input.isIm) return Boolean(input.text.trim());
+	return input.text.includes(`<@${input.botUserId}>`);
+}
+function destination$1(target, source) {
+	if (typeof target.channel === "string" && target.channel.trim()) return { channel: target.channel.trim() };
+	if (source.connectorId !== "slack") throw new Error("There is no Slack channel behind this task. Choose one on the loop.");
+	const carry = source.carry ?? {};
+	if (!carry.channel) throw new Error("There is no Slack channel behind this task. Choose one on the loop.");
+	return {
+		channel: carry.channel,
+		threadTs: carry.ts
+	};
+}
+function accountOf$2(credential) {
+	return {
+		id: credential.teamId,
+		label: [credential.botName ? `@${credential.botName}` : null, credential.team || credential.teamId].filter(Boolean).join(" · "),
+		url: credential.teamUrl || void 0
+	};
+}
+var slackRuntime = {
+	async readiness() {
+		return { ready: true };
+	},
+	async poll({ workflowId, credential, cursor }) {
+		if (workflowId !== "slack.ask") throw new Error(`Slack cannot watch for ${workflowId}.`);
+		const account = credential;
+		const previous = asCursor$1(cursor);
+		const channels = await listConversations(account);
+		const next = { ...previous };
+		const signals = [];
+		for (const channel of channels) {
+			const oldest = previous[channel.id];
+			const messages = await history$1(account, channel.id, oldest);
+			if (messages.length === 0) {
+				if (!next[channel.id]) next[channel.id] = String(Date.now() / 1e3);
+				continue;
+			}
+			next[channel.id] = messages[messages.length - 1].ts;
+			if (!oldest) continue;
+			for (const message of messages) {
+				if (!isAsk$1({
+					text: message.text,
+					user: message.user,
+					messageBotId: message.botId,
+					isIm: channel.isIm,
+					botUserId: account.botUserId,
+					botId: account.botId
+				})) continue;
+				const asked = {
+					channel: channel.id,
+					ts: message.ts,
+					user: message.user,
+					text: message.text,
+					threadTs: message.threadTs ?? message.ts
+				};
+				signals.push({
+					key: `${channel.id}:${message.ts}`,
+					kind: "message",
+					ref: `${channel.id}:${message.ts}`,
+					title: summarise$2(message.text),
+					url: permalink$1(account, channel.id, message.ts),
+					payload: asked
+				});
+			}
+		}
+		return {
+			signals,
+			cursor: next
+		};
+	},
+	async resolveWorkItem({ payload }) {
+		const asked = asAsked$2(payload);
+		return {
+			kind: "message",
+			ref: `${asked.channel}:${asked.ts}`,
+			title: summarise$2(asked.text),
+			url: "",
+			carry: {
+				channel: asked.channel,
+				ts: asked.threadTs
+			},
+			context: [{
+				name: "MESSAGE.md",
+				body: [
+					`# What you were asked`,
+					``,
+					asked.text,
+					``
+				].join("\n")
+			}]
+		};
+	},
+	async applyAction({ actionId, target, source, body, credential }) {
+		if (actionId !== "slack.reply") throw new Error(`Slack cannot ${actionId}.`);
+		const account = credential;
+		const to = destination$1(target, source);
+		const posted = await postMessage(account, {
+			channel: to.channel,
+			text: body.trim(),
+			threadTs: to.threadTs
+		});
+		return { url: permalink$1(account, posted.channel, posted.ts) };
+	},
+	auth: {
+		async connectWithFields(fields) {
+			const botToken = fields.botToken?.trim() ?? "";
+			if (!botToken.startsWith("xoxb-")) throw new Error("Paste the Bot User OAuth Token from your Slack app. It starts with xoxb-.");
+			const credential = await authTest(botToken);
+			return {
+				credential,
+				account: accountOf$2(credential)
+			};
+		},
+		async identity(credential) {
+			return { account: accountOf$2(await authTest(credential.botToken)) };
+		}
+	}
+};
+/**
+* Feishu / Lark Open API, called with a custom app's id and secret.
+* Loopable polls groups the bot is in; Feishu never has to reach this machine.
+*/
+var API = {
+	feishu: "https://open.feishu.cn/open-apis",
+	lark: "https://open.larksuite.com/open-apis"
+};
+var APPLINK = {
+	feishu: "https://applink.feishu.cn/client/chat/open",
+	lark: "https://applink.larksuite.com/client/chat/open"
+};
+function parseHost(value) {
+	const raw = (value ?? "feishu").trim().toLowerCase();
+	if (!raw || raw === "feishu" || raw === "feishu.cn" || raw.includes("feishu.cn")) return "feishu";
+	if (raw === "lark" || raw === "larksuite" || raw.includes("larksuite.com") || raw.includes("larkoffice.com")) return "lark";
+	throw new Error("Open platform must be feishu (China) or lark (international).");
+}
+function refuse(code, msg) {
+	if (code === 10003 || code === 10012 || code === 10014) throw new Error("Feishu did not accept those app credentials.");
+	throw new Error(msg ? `Feishu refused: ${msg}` : "Feishu refused the request.");
+}
+async function call$1(host, path, init = {}) {
+	const url = new URL(`${API[host]}${path}`);
+	for (const [key, value] of Object.entries(init.query ?? {})) url.searchParams.set(key, value);
+	let response;
+	try {
+		response = await fetch(url.href, {
+			method: init.method ?? "GET",
+			headers: {
+				"Content-Type": "application/json; charset=utf-8",
+				...init.token ? { Authorization: `Bearer ${init.token}` } : {}
+			},
+			body: init.body ? JSON.stringify(init.body) : void 0
+		});
+	} catch (error) {
+		throw new TransientError(`Feishu is unreachable: ${error.message}`);
+	}
+	if (response.status >= 500 || response.status === 429) throw new TransientError(`Feishu answered ${response.status}`);
+	let body;
+	try {
+		body = await response.json();
+	} catch {
+		throw new Error(`Feishu answered ${response.status}`);
+	}
+	return body;
+}
+function dataOf(body) {
+	if (body.code && body.code !== 0) refuse(body.code, body.msg);
+	return body.data ?? {};
+}
+async function tenantAccessToken(host, appId, appSecret) {
+	const body = await call$1(host, "/auth/v3/tenant_access_token/internal", {
+		method: "POST",
+		body: {
+			app_id: appId,
+			app_secret: appSecret
+		}
+	});
+	if (body.code && body.code !== 0) refuse(body.code, body.msg);
+	const token = body.tenant_access_token ?? "";
+	const expire = typeof body.expire === "number" ? body.expire : 7200;
+	if (!token) throw new Error("Feishu did not return a tenant token.");
+	return {
+		token,
+		expiresAt: Date.now() + expire * 1e3 - 6e4
+	};
+}
+async function botInfo(credential) {
+	const body = await call$1(credential.host, "/bot/v3/info", { token: credential.tenantAccessToken });
+	if (body.code && body.code !== 0) refuse(body.code, body.msg);
+	const bot = body.bot ?? {};
+	const openId = typeof bot.open_id === "string" ? bot.open_id : "";
+	const name = typeof bot.app_name === "string" ? bot.app_name : "";
+	const avatarUrl = typeof bot.avatar_url === "string" ? bot.avatar_url : void 0;
+	if (!openId) throw new Error("Feishu did not return which bot this app is.");
+	return {
+		openId,
+		name,
+		...avatarUrl ? { avatarUrl } : {}
+	};
+}
+async function listChats(credential) {
+	const chats = [];
+	let pageToken = "";
+	do {
+		const query = { page_size: "100" };
+		if (pageToken) query.page_token = pageToken;
+		const data = dataOf(await call$1(credential.host, "/im/v1/chats", {
+			token: credential.tenantAccessToken,
+			query
+		}));
+		const items = Array.isArray(data.items) ? data.items : [];
+		for (const raw of items) {
+			const chat = raw;
+			if (!chat.chat_id) continue;
+			chats.push({
+				id: chat.chat_id,
+				name: chat.name ?? ""
+			});
+		}
+		pageToken = data.has_more === true && typeof data.page_token === "string" ? data.page_token : "";
+	} while (pageToken);
+	return chats;
+}
+function textOf$1(content) {
+	if (!content) return "";
+	try {
+		const parsed = JSON.parse(content);
+		return typeof parsed.text === "string" ? parsed.text : content;
+	} catch {
+		return content;
+	}
+}
+function mentionsOf(raw) {
+	if (!Array.isArray(raw)) return [];
+	return raw.map((entry) => {
+		const mention = entry;
+		return typeof mention.id === "string" ? mention.id : "";
+	}).filter(Boolean);
+}
+async function history(credential, chatId, oldestMs) {
+	const parsed = [];
+	let pageToken = "";
+	do {
+		const query = {
+			container_id_type: "chat",
+			container_id: chatId,
+			sort_type: oldestMs ? "ByCreateTimeAsc" : "ByCreateTimeDesc",
+			page_size: oldestMs ? "50" : "1"
+		};
+		if (oldestMs) query.start_time = String(Math.floor(Number(oldestMs) / 1e3));
+		if (pageToken) query.page_token = pageToken;
+		const body = await call$1(credential.host, "/im/v1/messages", {
+			token: credential.tenantAccessToken,
+			query
+		});
+		if (body.code && body.code !== 0) {
+			if (body.code === 230002 || body.code === 231203) return parsed;
+			refuse(body.code, body.msg);
+		}
+		const data = body.data ?? {};
+		const items = Array.isArray(data.items) ? data.items : [];
+		for (const raw of items) {
+			const message = raw;
+			if (!message.message_id || message.deleted) continue;
+			parsed.push({
+				id: message.message_id,
+				chatId: message.chat_id ?? chatId,
+				createTime: message.create_time ?? "",
+				text: textOf$1(message.body?.content),
+				...message.sender?.id ? { senderId: message.sender.id } : {},
+				...message.sender?.sender_type ? { senderType: message.sender.sender_type } : {},
+				mentionIds: mentionsOf(message.mentions)
+			});
+		}
+		pageToken = oldestMs && data.has_more === true && typeof data.page_token === "string" ? data.page_token : "";
+	} while (pageToken);
+	return parsed.sort((a, b) => Number(a.createTime) - Number(b.createTime));
+}
+async function replyMessage(credential, messageId, text) {
+	const data = dataOf(await call$1(credential.host, `/im/v1/messages/${messageId}/reply`, {
+		token: credential.tenantAccessToken,
+		method: "POST",
+		body: {
+			msg_type: "text",
+			content: JSON.stringify({ text })
+		}
+	}));
+	const id = typeof data.message_id === "string" ? data.message_id : "";
+	const chatId = typeof data.chat_id === "string" ? data.chat_id : "";
+	if (!id) throw new Error("Feishu accepted the reply but did not say where it landed.");
+	return {
+		id,
+		chatId
+	};
+}
+async function sendMessage$1(credential, chatId, text) {
+	const data = dataOf(await call$1(credential.host, "/im/v1/messages", {
+		token: credential.tenantAccessToken,
+		method: "POST",
+		query: { receive_id_type: "chat_id" },
+		body: {
+			receive_id: chatId,
+			msg_type: "text",
+			content: JSON.stringify({ text })
+		}
+	}));
+	const id = typeof data.message_id === "string" ? data.message_id : "";
+	const landed = typeof data.chat_id === "string" ? data.chat_id : chatId;
+	if (!id) throw new Error("Feishu accepted the message but did not say where it landed.");
+	return {
+		id,
+		chatId: landed
+	};
+}
+function permalink(host, chatId) {
+	return `${APPLINK[host]}?openChatId=${chatId}`;
+}
+function asAsked$1(value) {
+	const record = value;
+	if (!record || typeof record.chatId !== "string" || typeof record.messageId !== "string") throw new Error("This task has lost the message it was about.");
+	return {
+		chatId: record.chatId,
+		messageId: record.messageId,
+		user: typeof record.user === "string" ? record.user : void 0,
+		text: typeof record.text === "string" ? record.text : ""
+	};
+}
+function asCursor(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	const out = {};
+	for (const [key, entry] of Object.entries(value)) if (typeof entry === "string") out[key] = entry;
+	return out;
+}
+function summarise$1(text) {
+	const line = text.replace(/@_user_\d+/g, "").replace(/\s+/g, " ").trim();
+	if (!line) return "Feishu message";
+	return line.length > 80 ? `${line.slice(0, 79)}…` : line;
+}
+function isAsk(input) {
+	if (input.senderType === "app" || input.senderId === input.botOpenId) return false;
+	return input.mentionIds.includes(input.botOpenId);
+}
+function destination(target, source) {
+	if (typeof target.chat === "string" && target.chat.trim()) return { chatId: target.chat.trim() };
+	if (source.connectorId !== "feishu") throw new Error("There is no Feishu chat behind this task. Choose one on the loop.");
+	const carry = source.carry ?? {};
+	if (!carry.chatId && !carry.messageId) throw new Error("There is no Feishu chat behind this task. Choose one on the loop.");
+	return {
+		chatId: carry.chatId,
+		messageId: carry.messageId
+	};
+}
+function accountOf$1(credential) {
+	return {
+		id: credential.botOpenId,
+		label: credential.botName || credential.appId,
+		...credential.avatarUrl ? { avatarUrl: credential.avatarUrl } : {}
+	};
+}
+/**
+* Tenant tokens last two hours. Minting on every poll would trip Feishu's
+* rate limit, so a still-valid one is reused and a fresh one is stored.
+*/
+async function usable(credential) {
+	if (Date.now() < credential.expiresAt) return { credential };
+	const minted = await tenantAccessToken(credential.host, credential.appId, credential.appSecret);
+	const refreshed = {
+		...credential,
+		tenantAccessToken: minted.token,
+		expiresAt: minted.expiresAt
+	};
+	return {
+		credential: refreshed,
+		refreshed
+	};
+}
+var feishuRuntime = {
+	async readiness() {
+		return { ready: true };
+	},
+	async poll({ workflowId, credential, cursor }) {
+		if (workflowId !== "feishu.ask") throw new Error(`Feishu cannot watch for ${workflowId}.`);
+		const { credential: account } = await usable(credential);
+		const previous = asCursor(cursor);
+		const chats = await listChats(account);
+		const next = { ...previous };
+		const signals = [];
+		for (const chat of chats) {
+			const oldest = previous[chat.id];
+			const messages = await history(account, chat.id, oldest);
+			if (messages.length === 0) {
+				if (!next[chat.id]) next[chat.id] = String(Date.now());
+				continue;
+			}
+			next[chat.id] = messages[messages.length - 1].createTime;
+			if (!oldest) continue;
+			for (const message of messages) {
+				if (oldest && Number(message.createTime) <= Number(oldest)) continue;
+				if (!isAsk({
+					senderId: message.senderId,
+					senderType: message.senderType,
+					mentionIds: message.mentionIds,
+					botOpenId: account.botOpenId
+				})) continue;
+				const asked = {
+					chatId: message.chatId,
+					messageId: message.id,
+					user: message.senderId,
+					text: message.text
+				};
+				signals.push({
+					key: `${message.chatId}:${message.id}`,
+					kind: "message",
+					ref: message.id,
+					title: summarise$1(message.text),
+					url: permalink(account.host, message.chatId),
+					payload: asked
+				});
+			}
+		}
+		return {
+			signals,
+			cursor: next
+		};
+	},
+	async resolveWorkItem({ payload }) {
+		const asked = asAsked$1(payload);
+		return {
+			kind: "message",
+			ref: asked.messageId,
+			title: summarise$1(asked.text),
+			url: "",
+			carry: {
+				chatId: asked.chatId,
+				messageId: asked.messageId
+			},
+			context: [{
+				name: "MESSAGE.md",
+				body: [
+					`# What you were asked`,
+					``,
+					asked.text,
+					``
+				].join("\n")
+			}]
+		};
+	},
+	async applyAction({ actionId, target, source, body, credential }) {
+		if (actionId !== "feishu.reply") throw new Error(`Feishu cannot ${actionId}.`);
+		const { credential: account } = await usable(credential);
+		const to = destination(target, source);
+		const text = body.trim();
+		const posted = to.messageId && source.connectorId === "feishu" ? await replyMessage(account, to.messageId, text) : await sendMessage$1(account, to.chatId ?? "", text);
+		return { url: permalink(account.host, posted.chatId || to.chatId || "") };
+	},
+	auth: {
+		async connectWithFields(fields) {
+			const appId = fields.appId?.trim() ?? "";
+			const appSecret = fields.appSecret?.trim() ?? "";
+			if (!appId) throw new Error("Paste the App ID from your Feishu or Lark app.");
+			if (!appSecret) throw new Error("Paste the App Secret from your Feishu or Lark app.");
+			const host = parseHost(fields.host);
+			const minted = await tenantAccessToken(host, appId, appSecret);
+			const bot = await botInfo({
+				host,
+				tenantAccessToken: minted.token
+			});
+			const stored = {
+				appId,
+				appSecret,
+				host,
+				botOpenId: bot.openId,
+				botName: bot.name,
+				...bot.avatarUrl ? { avatarUrl: bot.avatarUrl } : {},
+				tenantAccessToken: minted.token,
+				expiresAt: minted.expiresAt
+			};
+			return {
+				credential: stored,
+				account: accountOf$1(stored)
+			};
+		},
+		async identity(credential) {
+			const { credential: fresh, refreshed } = await usable(credential);
+			const bot = await botInfo(fresh);
+			const updated = {
+				...fresh,
+				botOpenId: bot.openId,
+				botName: bot.name,
+				...bot.avatarUrl ? { avatarUrl: bot.avatarUrl } : {}
+			};
+			return {
+				account: accountOf$1(updated),
+				...refreshed ? { renewedCredential: updated } : {}
+			};
+		}
+	}
+};
+/**
 * Tencent's iLink bot API, as documented for clients that are not OpenClaw:
 * https://github.com/Tencent/openclaw-weixin/blob/main/docs/protocol.md
 *
@@ -2264,6 +3108,8 @@ function accountOf(credential) {
 /** Server-only registry. Never import this from a component. */
 var RUNTIMES = {
 	github: githubRuntime,
+	slack: slackRuntime,
+	feishu: feishuRuntime,
 	gmail: gmailRuntime,
 	wechat: {
 		async readiness() {
@@ -2539,4 +3385,4 @@ async function checkConnection(id) {
 	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 };
+export { startAuthAttempt as _, connectionNoun as a, writerName as b, connectorRuntime as c, destinationLabel as d, isInboxOnly as f, saveAuthorizedConnection as g, removeConnection as h, checkConnection as i, connectorWorkflow as l, needsAccount as m, allTriggers as n, connectorAction as o, listConnections as p, allWorkflows as r, connectorManifest as s, CONNECTOR_MANIFESTS as t, credentialForConnector as u, takeAuthAttempt as v, writers as x, updateConnectionSettings as y };