@reserendipity/dsh-superagent 0.0.0-stage → 0.1.0

package/lib/host-BIWKSB5j.js

@@ -0,0 +1,124 @@
+import { createHash } from "node:crypto";
+//#region src/core/model.ts
+/** Stable key of a thread across the whole domain. */
+const threadKey = (ref) => `${ref.source}:${ref.id}`;
+/**
+* Normalizes valid timestamps to `Date#toISOString` form so stored timestamps compare lexicographically in memory and SQL;
+* values that do not parse as a timestamp are returned unchanged.
+*/
+function isoTime(value) {
+	const time = Date.parse(value);
+	return Number.isFinite(time) ? new Date(time).toISOString() : value;
+}
+/**
+* The tickets whose worker decides a person's follow-up: those it reached on their own Threads that can still decide it
+* and did not hand it back. A ticket can while it is live, also once a person dropped its Subscription to the Thread, and
+* while it is ended, not by a person, with the Trigger waiting to resume it. None once a person sent it to Eval, or while
+* an Eval holds it, which an earlier version may have queued. While a ticket owns it, the message goes to no Eval, and the
+* main Session may only stop the work on it.
+*/
+function followupOwners(trigger, records) {
+	if (!trigger.human) return [];
+	const disposition = records.triggers.disposition(trigger.id);
+	if (!disposition || disposition.requeued) return [];
+	const returned = new Set(disposition.handbacks?.map((item) => item.ticketId));
+	const reached = disposition.fanout.filter((id) => !returned.has(id) && !disposition.context?.includes(id));
+	if (!reached.length || records.threads.get(threadKey(trigger.threads[0]))?.evaluating?.triggerIds.includes(trigger.id)) return [];
+	return reached.filter((id) => {
+		const ticket = records.tickets.get(id);
+		return !!ticket && (liveTicket(ticket) || ticket.ended?.by !== "human" && ticket.inputs.some((input) => input.kind === "trigger" && input.triggerId === trigger.id && ticket.undelivered.includes(input.id)));
+	});
+}
+/**
+* Whether a Decision settled what a person's message asks for: a stop on it, taken or refused, decides only that ticket's
+* work, routing it to a ticket leaves it to that ticket's worker, and an unavailable one decided nothing.
+*/
+const settled = (decision) => !["stop", "unavailable"].includes(decision.kind) && !decision.reason.some((reason) => [
+	"stopNotExplicit",
+	"stopUnknown",
+	"routed"
+].includes(reason.code));
+/** Whether a ticket is open: it has not ended. */
+const liveTicket = (ticket) => !ticket.ended;
+/** How a ticket ended. */
+const ticketOutcome = (ticket) => ticket.ended?.outcome;
+const runningAssignment = (ticket) => ticket.assignments.find((assignment) => assignment.state === "running");
+/**
+* Whether a Trigger reached a ticket: it started the ticket, came to it as an Input, or is on a Thread the ticket subscribes
+* to; with `context` false, not a Thread the ticket follows only for context, where its worker may read but not write.
+*/
+function reached(ticket, trigger, thread, context = true) {
+	if (ticket.origin.triggerId === trigger.id) return true;
+	const input = ticket.inputs.some((item) => item.kind === "trigger" && item.triggerId === trigger.id);
+	return trigger.threads.some((ref) => {
+		const current = thread(threadKey(ref));
+		return current?.subscriptions.includes(ticket.id) === true && (context || !current.context?.includes(ticket.id));
+	}) || input && (context || !trigger.threads.every((ref) => thread(threadKey(ref))?.context?.includes(ticket.id)));
+}
+const latestAssignment = (ticket) => ticket.assignments.at(-1);
+/** The latest report any of a ticket's Assignments made, which is what the ticket last said. */
+const latestReport = (ticket) => ticket.assignments.findLast((assignment) => assignment.report)?.report;
+/**
+* Until when a ticket's worker had a turn to read what reached it: its latest report, but a progress report when `progress`
+* is false, or the end of its latest turn, whichever is later.
+*/
+function readUntil(ticket, progress = true) {
+	return [(ticket.assignments.findLast((assignment) => assignment.report && (progress || assignment.report.state !== "progress"))?.report)?.at ?? "", ...ticket.assignments.map((assignment) => assignment.idleAt ?? "")].reduce((a, b) => a > b ? a : b);
+}
+/**
+* Whether a ticket waits for a person: its latest Assignment reported blocked or failed, and no person's message reached it
+* since. A later report that is neither, a person's message, or a retry, which starts a new Assignment, lifts it.
+*/
+function waitsForPerson(ticket) {
+	const report = latestAssignment(ticket)?.report;
+	if (report?.state !== "blocked" && report?.state !== "failed") return false;
+	return !ticket.inputs.some((input) => input.kind === "trigger" && input.human && !input.context && input.at > report.at);
+}
+//#endregion
+//#region src/core/ids.ts
+/** Stable content-derived identifiers; equal inputs always produce the same id. */
+function key(...values) {
+	return createHash("sha256").update(JSON.stringify(values)).digest("hex").slice(0, 32);
+}
+//#endregion
+//#region src/infra/text.ts
+/** Word counting and string formatting utilities for IM message limits and templates. */
+const words = new Intl.Segmenter("zh", { granularity: "word" });
+/** Counts word-like segments across Chinese, English, and mixed text, ignoring punctuation. */
+function wordCount(text) {
+	let count = 0;
+	for (const segment of words.segment(text)) if (segment.isWordLike) count++;
+	return count;
+}
+/** Validates that an outgoing IM Markdown message does not exceed `IM_WORDS` (link labels and URLs both count toward the limit). */
+function checkedImText(text) {
+	const count = wordCount(text);
+	if (count > 100) throw new Error(`IM message has ${count} words; maximum is 100. Rewrite as a short high-level update. Do not split it into multiple messages.`);
+	return text;
+}
+const fill = (template, values) => template.replace(/\{(\w+)\}/g, (_, name) => values[name] ?? "");
+/** Case-insensitive comparison for GitHub logins and repository names. */
+const sameName = (a, b) => a.toLowerCase() === b.toLowerCase();
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+//#endregion
+//#region src/sources/host.ts
+/** Fixed English health templates (`{name}` placeholders); the panel localizes each `code` in the interface language. */
+const HEALTH_TEXT = {
+	setupPending: "Waiting for the deployment check",
+	sourceOff: "Off",
+	feishuCliUnset: "The Source is on, and its bot lark-cli is not set",
+	feishuBotMissing: "Waiting for the Feishu bot",
+	pollFailures: "{count} consecutive failed polls; last: {error}"
+};
+function health(state, code, values = {}) {
+	return {
+		state,
+		detail: fill(HEALTH_TEXT[code], values),
+		code,
+		...Object.keys(values).length ? { values } : {}
+	};
+}
+/** The context of one Source instance: `instance` defaults to the kind, which is the single-instance case. */
+const sourceContext = (host, kind, instance) => host.context(kind, instance);
+//#endregion
+export { settled as _, fill as a, waitsForPerson as b, key as c, latestAssignment as d, latestReport as f, runningAssignment as g, readUntil as h, escapeRegExp as i, followupOwners as l, reached as m, sourceContext as n, sameName as o, liveTicket as p, checkedImText as r, wordCount as s, health as t, isoTime as u, threadKey as v, ticketOutcome as y };

package/lib/inbox-watch.d.ts

@@ -0,0 +1,43 @@
+import { _ as output, c as ZodObject, f as ZodString, r as ZodDefault, s as ZodNumber, x as $strict } from "./schemas-lx-F2nnt.js";
+import { U as Trigger, l as OutboundMessage } from "./intake-TNIkqilh.js";
+import { n as SourceKind, r as SourceContext, t as DeliveredMessage } from "./kind--8woUEex.js";
+import { Context } from "@deepseek-ai/cordis";
+//#region src/sources/inbox.d.ts
+declare const InboxConfigSchema: ZodObject<{
+  inboxDir: ZodDefault<ZodString>;
+  actor: ZodDefault<ZodString>;
+  pollSeconds: ZodDefault<ZodNumber>;
+}, $strict>;
+type InboxConfig = output<typeof InboxConfigSchema>;
+/** The inbox root: the configured absolute directory, or `<stateDir>/inbox` when unset. */
+declare function inboxDir(deployment: {
+  stateDir: string;
+}, config: InboxConfig): string;
+/** One pending task file as the poll sees it. */
+interface InboxFile {
+  path: string;
+  relPath: string;
+  content: string;
+  mtimeMs: number;
+}
+/** The Trigger of one task file; unchanged replays share one id, edits and re-drops do not. */
+declare function inboxTrigger(file: InboxFile, config: InboxConfig, root: string): Trigger;
+/**
+ * Renders the Thread's reply file from the pipeline's own receipts, oldest delivery first. Content that no receipt backs -
+ * a block a worker wrote straight into the file - is therefore gone after the next delivery, which is the point: the file
+ * is the delivery record, and only the Channel delivers. Without `delivered` (a caller outside the pipeline) the single
+ * message is appended once, keyed by its id, as before.
+ */
+declare function sendInbox(_host: Pick<SourceContext, 'commands'>, message: OutboundMessage, delivered?: readonly DeliveredMessage[]): Promise<'sent' | 'gone'>;
+declare const inboxKind: SourceKind<InboxConfig>;
+/** Read pending files in the inbox, take in each, and archive it under done/. Advance nothing else: the move is the cursor. */
+declare function pollInbox(ctx: SourceContext, config: InboxConfig, signal: AbortSignal): Promise<{
+  read: number;
+  moved: number;
+  failed: number;
+}>;
+declare const name = "dsh-superagent-inbox";
+declare const inject: string[];
+declare function apply(ctx: Context): void;
+//#endregion
+export { InboxConfig, InboxFile, apply, inboxDir, inboxKind, inboxTrigger, inject, name, pollInbox, sendInbox };

package/lib/inbox-watch.js

@@ -0,0 +1,343 @@
+import { c as key, n as sourceContext, t as health, v as threadKey } from "./host-BIWKSB5j.js";
+import { c as object, r as array, s as number, u as string } from "./schemas-MhNERx8d.js";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import { createHash } from "node:crypto";
+import { setTimeout } from "node:timers/promises";
+//#region src/sources/inbox.ts
+const SOURCE = "inbox";
+const ARCHIVE = "done";
+const MAX_TEXT_CHARS = 2e5;
+const InboxConfigSchema = object({
+	/** Absolute inbox directory; empty means `<stateDir>/inbox`. The `done/` subdirectory holds archived tasks and replies. */
+	inboxDir: string().trim().max(500).default(""),
+	/** Stable actor id dropped files are attributed to; it is the sender name on the Policy's allowed list. */
+	actor: string().regex(/^[a-z0-9_-]{1,64}$/).default("local"),
+	/** Polling interval in seconds. */
+	pollSeconds: number().int().min(5).max(3600).default(10)
+}).strict();
+/** The inbox root: the configured absolute directory, or `<stateDir>/inbox` when unset. */
+function inboxDir(deployment, config) {
+	return config.inboxDir ? resolve(config.inboxDir) : join(deployment.stateDir, "inbox");
+}
+const fileUrl = (path) => `file:///${path.replaceAll("\\", "/")}`;
+/** The Trigger of one task file; unchanged replays share one id, edits and re-drops do not. */
+function inboxTrigger(file, config, root) {
+	const hash = createHash("sha256").update(file.content).digest("hex").slice(0, 16);
+	const stableId = key(SOURCE, file.relPath);
+	const id = key(SOURCE, file.relPath, String(Math.floor(file.mtimeMs)), hash);
+	const text = file.content.length > MAX_TEXT_CHARS ? `${file.content.slice(0, MAX_TEXT_CHARS)}\n\n[truncated: the file holds ${file.content.length} characters]` : file.content;
+	const url = fileUrl(file.path);
+	return {
+		id,
+		source: SOURCE,
+		threads: [{
+			source: SOURCE,
+			id: stableId
+		}],
+		actor: {
+			source: SOURCE,
+			id: config.actor
+		},
+		human: true,
+		addressed: "direct",
+		at: new Date(file.mtimeMs).toISOString(),
+		text,
+		url,
+		channel: {
+			source: SOURCE,
+			thread: threadKey({
+				source: SOURCE,
+				id: stableId
+			}),
+			address: {
+				file: file.relPath,
+				path: file.path,
+				reply: join(root, ARCHIVE, `${file.relPath.replaceAll(/[\\/]/g, "__")}.reply.md`)
+			}
+		},
+		meta: {
+			file: file.relPath,
+			path: file.path,
+			stableId
+		}
+	};
+}
+/** One delivered message exactly as it appears in the reply file. */
+const block = (message, at, file) => `<!-- msg:${message.id} -->\n**${message.kind} · ${at} · ${file}**\n\n${message.text}\n\n`;
+/**
+* Renders the Thread's reply file from the pipeline's own receipts, oldest delivery first. Content that no receipt backs -
+* a block a worker wrote straight into the file - is therefore gone after the next delivery, which is the point: the file
+* is the delivery record, and only the Channel delivers. Without `delivered` (a caller outside the pipeline) the single
+* message is appended once, keyed by its id, as before.
+*/
+async function sendInbox(_host, message, delivered) {
+	const { reply, file } = message.channel.address;
+	if (!reply) throw new Error("Missing inbox reply path");
+	mkdirSync(dirname(reply), { recursive: true });
+	const name = String(file ?? "");
+	if (!delivered) {
+		let existing = "";
+		try {
+			existing = readFileSync(reply, "utf8");
+		} catch {}
+		if (!existing.includes(`<!-- msg:${message.id} -->`)) appendFileSync(reply, block(message, (/* @__PURE__ */ new Date()).toISOString(), name));
+		return "sent";
+	}
+	const record = /* @__PURE__ */ new Map();
+	for (const item of delivered) if (!record.has(item.id)) record.set(item.id, block(item, item.sentAt ?? (/* @__PURE__ */ new Date()).toISOString(), name));
+	if (!record.has(message.id)) record.set(message.id, block(message, (/* @__PURE__ */ new Date()).toISOString(), name));
+	const temporary = `${reply}.tmp-${process.pid}`;
+	writeFileSync(temporary, [...record.values()].join(""));
+	renameSync(temporary, reply);
+	return "sent";
+}
+const inboxKind = {
+	kind: SOURCE,
+	title: {
+		zh: "本地收件目录",
+		en: "Local inbox"
+	},
+	description: {
+		zh: "把 Markdown 文件放进收件目录即为向智能体直接提出工单；结果写入同目录 done 下的回信文件。单人部署无需第二个 GitHub 账号。",
+		en: "Dropping a Markdown file into the inbox is a direct request to the agent; results land in a reply file under done/. A single-operator deployment needs no second GitHub account."
+	},
+	schema: InboxConfigSchema,
+	fields: [
+		{
+			key: "inboxDir",
+			type: "text",
+			label: {
+				zh: "收件目录",
+				en: "Inbox directory"
+			},
+			hint: {
+				zh: "绝对路径；留空用状态目录下的 inbox。目录里每个 .md 文件是一张请求，处理完连同回信移入 done。",
+				en: "Absolute path; empty means inbox under the state directory. Each .md file is one request; processed files and replies move to done/."
+			}
+		},
+		{
+			key: "actor",
+			type: "text",
+			label: {
+				zh: "本机发起人",
+				en: "Local sender"
+			},
+			hint: {
+				zh: "文件请求归属的发送者 id，须出现在策略名单里才能发起工作。",
+				en: "The sender id dropped files are attributed to; it must be on the Policy list to originate work."
+			}
+		},
+		{
+			key: "pollSeconds",
+			type: "number",
+			advanced: true,
+			min: 5,
+			max: 3600,
+			label: {
+				zh: "轮询间隔 / 秒",
+				en: "Polling interval / seconds"
+			}
+		}
+	],
+	health: [SOURCE],
+	scope: () => ({
+		listened: true,
+		observed: true,
+		row: SOURCE
+	}),
+	channel: {
+		allowed: (address) => typeof address.reply === "string" && address.reply.length > 0,
+		send: sendInbox,
+		link: (address) => ({
+			url: address.path ? fileUrl(address.path) : "",
+			label: {
+				zh: `本地任务 ${address.file ?? ""}`,
+				en: `Local task ${address.file ?? ""}`
+			}
+		})
+	},
+	threadContext: {
+		messageId: (trigger) => String(trigger.meta.stableId ?? ""),
+		read: async (_commands, trigger) => {
+			const messages = [{
+				id: String(trigger.meta.stableId ?? ""),
+				from: trigger.actor.id,
+				at: trigger.at,
+				text: trigger.text
+			}];
+			return {
+				messages,
+				body: { messages }
+			};
+		}
+	},
+	policy: {
+		schema: object({ allowed: array(object({
+			id: string().min(1),
+			name: string().trim().max(100).optional()
+		}).strict()).default([{
+			id: "local",
+			name: "本机"
+		}]) }).strict(),
+		fields: [{
+			key: "allowed",
+			type: "rows",
+			label: {
+				zh: "能发起工作的发送者",
+				en: "Senders who may originate work"
+			},
+			columns: [{
+				key: "id",
+				type: "text",
+				label: {
+					zh: "发送者",
+					en: "Sender"
+				}
+			}, {
+				key: "name",
+				type: "text",
+				label: {
+					zh: "名字",
+					en: "Name"
+				},
+				optional: true
+			}]
+		}],
+		explicit: {
+			zh: "把任务文件放进收件目录。",
+			en: "Drop a task file into the inbox."
+		},
+		rows: () => [{
+			id: SOURCE,
+			label: {
+				zh: "收件目录",
+				en: "Inbox"
+			},
+			note: {
+				zh: "本机的文件投放",
+				en: "Local file drops"
+			},
+			cells: {
+				listedUnaddressed: true,
+				unlistedAddressed: true,
+				unlistedUnaddressed: true
+			}
+		}]
+	},
+	environment: {
+		variables: [{
+			key: "DSH_SUPERAGENT_INBOX_FILE",
+			description: {
+				zh: "接下工单的本地任务文件名；工单不是从收件目录来的时为空",
+				en: "The inbox task file that started the ticket; empty when the ticket did not start on this Source"
+			}
+		}],
+		values: ({ trigger }) => ({ DSH_SUPERAGENT_INBOX_FILE: trigger?.source === SOURCE ? String(trigger.meta.file ?? "") : "" })
+	}
+};
+/** Read pending files in the inbox, take in each, and archive it under done/. Advance nothing else: the move is the cursor. */
+async function pollInbox(ctx, config, signal) {
+	const root = inboxDir(ctx.deployment, config);
+	if (!existsSync(root)) mkdirSync(root, { recursive: true });
+	const names = readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".md")).map((entry) => entry.name).sort();
+	const archive = join(root, ARCHIVE);
+	let read = 0, moved = 0, failed = 0;
+	for (const name of names) {
+		if (signal.aborted) throw new Error("The inbox Source stopped during the read");
+		let file;
+		try {
+			const path = join(root, name);
+			const st = statSync(path);
+			file = {
+				path,
+				relPath: name,
+				content: readFileSync(path, "utf8"),
+				mtimeMs: st.mtimeMs
+			};
+		} catch {
+			failed++;
+			continue;
+		}
+		read++;
+		try {
+			const trigger = inboxTrigger(file, config, root);
+			await ctx.receive(trigger);
+			ctx.threads.describe(threadKey(trigger.threads[0]), {
+				url: trigger.url,
+				facts: { file: {
+					label: {
+						zh: "任务文件",
+						en: "Task file"
+					},
+					value: name
+				} }
+			});
+			if (!existsSync(archive)) mkdirSync(archive, { recursive: true });
+			let target = join(archive, name);
+			if (existsSync(target)) target = join(archive, `${basename(name, extname(name))}-${Math.floor(file.mtimeMs)}${extname(name)}`);
+			if (existsSync(target)) target = join(archive, `${basename(name, extname(name))}-${Date.now()}${extname(name)}`);
+			renameSync(file.path, target);
+			moved++;
+		} catch {
+			failed++;
+		}
+	}
+	return {
+		read,
+		moved,
+		failed
+	};
+}
+async function watch$1(ctx, signal) {
+	await ctx.ready;
+	if (!ctx.configured()) {
+		ctx.report(SOURCE, health("paused", "setupPending"));
+		return;
+	}
+	let failures = 0;
+	while (!signal.aborted) {
+		const config = ctx.config(SOURCE);
+		if (!config) ctx.report(SOURCE, health("paused", "sourceOff"));
+		else {
+			const at = (/* @__PURE__ */ new Date()).toISOString();
+			try {
+				const { read, moved, failed } = await pollInbox(ctx, config, signal);
+				failures = 0;
+				ctx.report(SOURCE, {
+					state: "ready",
+					detail: `${read} files, ${moved} archived, ${failed} failed`,
+					at
+				});
+			} catch (error) {
+				failures += 1;
+				if (!signal.aborted && failures >= 3) ctx.report(SOURCE, health("error", "pollFailures", {
+					count: String(failures),
+					error: String(error)
+				}));
+			}
+		}
+		await setTimeout((config?.pollSeconds ?? 10) * 1e3, void 0, { signal }).catch(() => {});
+	}
+}
+const name = "dsh-superagent-inbox";
+const inject = ["orchestrator"];
+function apply(ctx) {
+	ctx.effect(() => ctx.orchestrator.sources.register(inboxKind), "inbox: source kind");
+	ctx.effect(() => {
+		const source = sourceContext(ctx.orchestrator, inboxKind);
+		const controller = new AbortController();
+		const running = watch$1(source, controller.signal).catch((error) => {
+			source.report(SOURCE, {
+				state: "error",
+				detail: String(error)
+			});
+		});
+		return async () => {
+			controller.abort();
+			await running;
+		};
+	});
+}
+//#endregion
+export { apply, inboxDir, inboxKind, inboxTrigger, inject, name, pollInbox, sendInbox };