loopable-cli 0.1.0

package/.output/server/_ssr/agents-DAOZPgO2.mjs

@@ -0,0 +1,76 @@
+import { n as createServerFn } from "./ssr.mjs";
+import { a as setDefaultAgent, i as saveAgentSettings, r as listAgents, s as testAgent } from "./agents-Btql102J.mjs";
+import { c as listRunners, t as availableAgentIds } from "./runners-DtXs4Q8a.mjs";
+import { t as createServerRpc } from "./createServerRpc-DPDrnFdH.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/agents-DAOZPgO2.js
+async function withRunners(agents) {
+	const runners = await listRunners();
+	const available = await availableAgentIds();
+	const stored = agents.find((agent) => agent.isDefault)?.agentId ?? null;
+	const implicit = !stored && available.length === 1 ? available[0] : null;
+	return agents.map((agent) => {
+		const onRunners = runners.flatMap((runner) => {
+			const entry = runner.inventory.find((item) => item.agentId === agent.agentId);
+			if (!entry?.installed) return [];
+			return [{
+				runnerId: runner.id,
+				name: runner.name,
+				status: runner.status,
+				signedIn: entry.signedIn,
+				version: entry.version
+			}];
+		});
+		const isDefault = agent.agentId === stored || agent.agentId === implicit;
+		return {
+			...agent,
+			onRunners,
+			isDefault,
+			defaultIsImplicit: isDefault && agent.agentId === implicit
+		};
+	});
+}
+var getAgentsPage_createServerFn_handler = createServerRpc({
+	id: "bde588e9b0b81a4ee619a63872d6b8b76e22db006c7a3c4351bcd56e5f76bbed",
+	name: "getAgentsPage",
+	filename: "src/server/functions/agents.ts"
+}, (opts) => getAgentsPage.__executeServer(opts));
+var getAgentsPage = createServerFn({ method: "GET" }).handler(getAgentsPage_createServerFn_handler, async () => ({ agents: await withRunners(await listAgents()) }));
+var saveAgent_createServerFn_handler = createServerRpc({
+	id: "80883b912a5a0aba2aa583b505e4e289d765a3f7fbb793a97692f439e7f960ba",
+	name: "saveAgent",
+	filename: "src/server/functions/agents.ts"
+}, (opts) => saveAgent.__executeServer(opts));
+var saveAgent = createServerFn({ method: "POST" }).inputValidator((data) => data).handler(saveAgent_createServerFn_handler, async ({ data }) => {
+	await saveAgentSettings(data.agentId, {
+		permissionMode: data.permissionMode,
+		model: data.model,
+		timeoutMs: data.timeoutMs
+	});
+	return await withRunners(await listAgents());
+});
+var chooseDefaultAgent_createServerFn_handler = createServerRpc({
+	id: "143ea51f7421d9eebec9ad31c2df8eed5aa2e5d8035473dbfad39913fd7d54c0",
+	name: "chooseDefaultAgent",
+	filename: "src/server/functions/agents.ts"
+}, (opts) => chooseDefaultAgent.__executeServer(opts));
+var chooseDefaultAgent = createServerFn({ method: "POST" }).inputValidator((data) => data).handler(chooseDefaultAgent_createServerFn_handler, async ({ data }) => {
+	await setDefaultAgent(data.agentId);
+	return await withRunners(await listAgents());
+});
+var runAgentTest_createServerFn_handler = createServerRpc({
+	id: "b0878f841b35f46b5f2dc9cbd71c5be5895ae1b8903b3b24c24dfcf86291d3e4",
+	name: "runAgentTest",
+	filename: "src/server/functions/agents.ts"
+}, (opts) => runAgentTest.__executeServer(opts));
+var runAgentTest = createServerFn({ method: "POST" }).inputValidator((data) => data).handler(runAgentTest_createServerFn_handler, async ({ data }) => {
+	const result = await testAgent(data.agentId);
+	return {
+		passed: result.passed,
+		output: result.output.slice(0, 2e3),
+		detail: result.detail ?? null,
+		durationMs: result.durationMs,
+		command: result.command
+	};
+});
+//#endregion
+export { chooseDefaultAgent_createServerFn_handler, getAgentsPage_createServerFn_handler, runAgentTest_createServerFn_handler, saveAgent_createServerFn_handler };

package/.output/server/_ssr/alert-NEiOCTOl.mjs

@@ -0,0 +1,37 @@
+import "../_runtime.mjs";
+import { U as require_jsx_runtime, W as require_react } from "../_libs/@base-ui/react+[...].mjs";
+import { t as cva } from "../_libs/class-variance-authority+clsx.mjs";
+import { V as cn } from "./router-3WmpE5b_.mjs";
+require_react();
+var import_jsx_runtime = require_jsx_runtime();
+var alertVariants = cva("group/alert relative grid w-full gap-0.5 rounded-lg border px-2.5 py-2 text-left text-sm has-data-[slot=alert-action]:relative has-data-[slot=alert-action]:pr-18 has-[>svg]:grid-cols-[auto_1fr] has-[>svg]:gap-x-2 *:[svg]:row-span-2 *:[svg]:translate-y-0.5 *:[svg]:text-current *:[svg:not([class*='size-'])]:size-4", {
+	variants: { variant: {
+		default: "bg-card text-card-foreground",
+		destructive: "bg-card text-destructive *:data-[slot=alert-description]:text-destructive/90 *:[svg]:text-current"
+	} },
+	defaultVariants: { variant: "default" }
+});
+function Alert({ className, variant, ...props }) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+		"data-slot": "alert",
+		role: "alert",
+		className: cn(alertVariants({ variant }), className),
+		...props
+	});
+}
+function AlertTitle({ className, ...props }) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+		"data-slot": "alert-title",
+		className: cn("font-medium group-has-[>svg]/alert:col-start-2 [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground", className),
+		...props
+	});
+}
+function AlertDescription({ className, ...props }) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+		"data-slot": "alert-description",
+		className: cn("text-sm text-balance text-muted-foreground md:text-pretty [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground [&_p:not(:last-child)]:mb-4", className),
+		...props
+	});
+}
+//#endregion
+export { AlertDescription as n, AlertTitle as r, Alert as t };

package/.output/server/_ssr/callback-CUINvl7M.mjs

@@ -0,0 +1,62 @@
+//#region node_modules/.nitro/vite/services/ssr/assets/callback-CUINvl7M.js
+function configuredOrigin() {
+	return process.env.LOOPABLE_BASE_URL?.replace(/\/$/, "") || null;
+}
+function isLoopbackHost(hostname) {
+	return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "::1";
+}
+/**
+* RFC1918, link-local, and loopback. A LAN App can use these as the join URL;
+* GitHub and Google will not take them as an OAuth redirect.
+*/
+function isPrivateHostname(hostname) {
+	if (isLoopbackHost(hostname)) return true;
+	const v4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(hostname);
+	if (v4) {
+		const a = Number(v4[1]);
+		const b = Number(v4[2]);
+		if (a === 10) return true;
+		if (a === 127) return true;
+		if (a === 192 && b === 168) return true;
+		if (a === 172 && b >= 16 && b <= 31) return true;
+		if (a === 169 && b === 254) return true;
+		return false;
+	}
+	const host = hostname.toLowerCase();
+	if (host.includes(":")) {
+		if (host.startsWith("fe80:") || host.startsWith("fc") || host.startsWith("fd")) return true;
+	}
+	return false;
+}
+/** Public https origin for cloud. LAN and loopback BASE_URL do not count. */
+function publicConfiguredOrigin() {
+	const base = configuredOrigin();
+	if (!base) return null;
+	try {
+		if (isPrivateHostname(new URL(base).hostname)) return null;
+		return base;
+	} catch {
+		return null;
+	}
+}
+/** Where GitHub / Gmail send the browser back. Local is always loopback. */
+function appOrigin(requestUrl) {
+	const hosted = publicConfiguredOrigin();
+	if (hosted) return hosted;
+	const url = new URL(requestUrl);
+	return `http://127.0.0.1${url.port ? `:${url.port}` : ""}`;
+}
+function callbackUrl(requestUrl, connectorId) {
+	return `${appOrigin(requestUrl)}/api/connectors/${connectorId}/callback`;
+}
+function registrableCallbackUrl(connectorId) {
+	const hosted = publicConfiguredOrigin();
+	if (hosted) return `${hosted}/api/connectors/${connectorId}/callback`;
+	return `http://127.0.0.1/api/connectors/${connectorId}/callback`;
+}
+/** Where runners and people should address this Loopable. May be a LAN IP. */
+function loopableOrigin() {
+	return configuredOrigin() ?? "http://127.0.0.1:4321";
+}
+//#endregion
+export { registrableCallbackUrl as a, loopableOrigin as i, callbackUrl as n, isLoopbackHost as r, appOrigin as t };

package/.output/server/_ssr/client-CKkOfh-s.mjs

@@ -0,0 +1,335 @@
+import { a as uniqueIndex, c as integer, i as index, n as drizzle, o as sqliteTable, r as primaryKey, s as text, t as migrate, v as sql } from "../_libs/drizzle-orm.mjs";
+import { existsSync, mkdirSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { createClient } from "@libsql/client";
+//#region node_modules/.nitro/vite/services/ssr/assets/client-CKkOfh-s.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+function isDevProfile() {
+	return process.env.LOOPABLE_DEV === "1";
+}
+function dataDir() {
+	const dir = process.env.LOOPABLE_HOME ?? join(homedir(), isDevProfile() ? ".loopable-dev" : ".loopable");
+	mkdirSync(dir, { recursive: true });
+	return dir;
+}
+function dbPath() {
+	return process.env.LOOPABLE_DB ?? join(dataDir(), "loopable.sqlite");
+}
+/** Keychain service prefix. Dev must not read or write the deploy install's secrets. */
+function secretNamespace() {
+	return process.env.LOOPABLE_SECRET_PREFIX ?? (isDevProfile() ? "loopable-dev" : "loopable");
+}
+/**
+* Where a run keeps its scratch files and its log. Not the system temp
+* directory: the dispatcher writes these and the app reads them, they are the
+* first thing to look at when a run goes wrong, and temp gets swept.
+*/
+function runDir(taskId) {
+	const dir = join(dataDir(), "runs", taskId);
+	mkdirSync(dir, { recursive: true });
+	return dir;
+}
+var schema_exports = /* @__PURE__ */ __exportAll({
+	SIGNAL_OUTCOME: () => SIGNAL_OUTCOME,
+	agentSettings: () => agentSettings,
+	appSettings: () => appSettings,
+	authAttempts: () => authAttempts,
+	connections: () => connections,
+	loops: () => loops,
+	runners: () => runners,
+	secrets: () => secrets,
+	signals: () => signals,
+	tasks: () => tasks
+});
+/**
+* One row per connected account, so a connector can be connected several times
+* (two GitHub accounts, or github.com alongside an Enterprise host). Credentials
+* live in the keychain under the row id, never in this table.
+*/
+var connections = sqliteTable("connections", {
+	id: text("id").primaryKey(),
+	connectorId: text("connector_id").notNull(),
+	status: text("status").$type().notNull().default("connected"),
+	accountId: text("account_id").notNull(),
+	accountLabel: text("account_label").notNull(),
+	accountUrl: text("account_url"),
+	avatarUrl: text("avatar_url"),
+	scopes: text("scopes"),
+	settings: text("settings", { mode: "json" }).$type().notNull().default({}),
+	cursor: text("cursor", { mode: "json" }).$type(),
+	lastSyncedAt: integer("last_synced_at", { mode: "timestamp_ms" }),
+	lastError: text("last_error"),
+	createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`),
+	updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`)
+}, (table) => [uniqueIndex("connections_account_unique").on(table.connectorId, table.accountId), index("connections_connector_idx").on(table.connectorId)]);
+/**
+* Short-lived state for an authorization that is mid-flight: the CSRF state and
+* the PKCE verifier that the callback must present. Rows are consumed on
+* callback and swept after they expire.
+*/
+var authAttempts = sqliteTable("auth_attempts", {
+	state: text("state").primaryKey(),
+	connectorId: text("connector_id").notNull(),
+	verifier: text("verifier").notNull(),
+	redirectUri: text("redirect_uri").notNull(),
+	returnTo: text("return_to"),
+	expiresAt: integer("expires_at", { mode: "timestamp_ms" }).notNull(),
+	createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`)
+});
+/**
+* One run of one loop against one thing. Kept whether it wrote anything or
+* not, because a loop that runs on its own is only trustworthy if you can see
+* afterwards what it did.
+*/
+var tasks = sqliteTable("tasks", {
+	id: text("id").primaryKey(),
+	loopId: text("loop_id").notNull().references(() => loops.id, { onDelete: "cascade" }),
+	connectorId: text("connector_id").notNull(),
+	state: text("state").$type().notNull().default("queued"),
+	/** What the task is about, resolved once so the record survives the source. */
+	sourceUrl: text("source_url").notNull(),
+	sourceKind: text("source_kind").$type().notNull(),
+	/** Names the thing inside its own connector. See `WorkItemRef`. */
+	sourceRef: text("source_ref").notNull(),
+	/** What the connector kept, when the source cannot be read twice. */
+	sourcePayload: text("source_payload", { mode: "json" }).$type(),
+	/**
+	* Identifying a link needs no network, but the title does, so it arrives
+	* when the dispatcher fetches rather than when the task is queued.
+	*/
+	sourceTitle: text("source_title"),
+	/** Set when a run was asked to stop before writing anything. */
+	dryRun: integer("dry_run", { mode: "boolean" }).notNull().default(false),
+	agentId: text("agent_id"),
+	runnerId: text("runner_id"),
+	agentCommand: text("agent_command"),
+	/** What the agent produced, which is also what gets written back. */
+	output: text("output"),
+	/**
+	* Findings that were checked against the diff and can be attached to a
+	* line. Kept because a write that failed on a bad connection has to be
+	* repeatable without paying for the review a second time.
+	*/
+	comments: text("comments", { mode: "json" }).$type(),
+	/**
+	* Which action is going to write this and where, taken from the loop when
+	* the task was queued. Kept here rather than read back off the loop so
+	* that changing a loop cannot change what a task already in the queue is
+	* about to do.
+	*/
+	actionConnectorId: text("action_connector_id").notNull(),
+	actionId: text("action_id").notNull(),
+	actionTarget: text("action_target", { mode: "json" }).$type().notNull().default({}),
+	/** Where the write landed, once it has. */
+	resultUrl: text("result_url"),
+	error: text("error"),
+	/** Everything the agent printed, streamed to disk while it runs. */
+	logPath: text("log_path"),
+	/** Same log, kept in the database so the App Worker can read it. */
+	logText: text("log_text").notNull().default(""),
+	attempts: integer("attempts").notNull().default(0),
+	/** Not claimable before this: how a retry backs off. */
+	runAfter: integer("run_after", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`),
+	/**
+	* A claim that expires. Whoever holds it renews it while working, so a
+	* task whose dispatcher died can be told apart from one still being worked on.
+	*/
+	leaseUntil: integer("lease_until", { mode: "timestamp_ms" }),
+	cancelRequested: integer("cancel_requested", { mode: "boolean" }).notNull().default(false),
+	/**
+	* Set when the task came from a signal rather than from a pasted link.
+	* The signals table already prevents a loop acting twice; this is the
+	* second lock, held by the database, in case two polls overlap.
+	*/
+	dedupeKey: text("dedupe_key"),
+	durationMs: integer("duration_ms"),
+	createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`),
+	startedAt: integer("started_at", { mode: "timestamp_ms" }),
+	updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`)
+}, (table) => [
+	index("tasks_loop_idx").on(table.loopId),
+	index("tasks_created_idx").on(table.createdAt),
+	index("tasks_claim_idx").on(table.state, table.runAfter),
+	uniqueIndex("tasks_dedupe_idx").on(table.dedupeKey)
+]);
+/**
+* One instance of one of a connector's workflows. The workflow decides what to
+* watch for, what to ask, and where to write; a loop only carries the answers
+* to the few questions the workflow asks. Settings are a JSON blob because
+* only the connector knows what can be narrowed.
+*/
+var loops = sqliteTable("loops", {
+	id: text("id").primaryKey(),
+	name: text("name").notNull(),
+	enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
+	/** Lowest first. The first matching loop wins, so order is meaningful. */
+	priority: integer("priority").notNull(),
+	connectorId: text("connector_id").notNull(),
+	workflowId: text("workflow_id").notNull(),
+	settings: text("settings", { mode: "json" }).$type().notNull().default({}),
+	/**
+	* What the agent is asked to do. Copied from the workflow when the loop is
+	* created, and the loop's own words from then on.
+	*
+	* Copied rather than referenced because this is the part a person has
+	* opinions about, and an opinion that a later release can overwrite is not
+	* worth having. It is only prose, so nothing else has to agree with it.
+	*/
+	prompt: text("prompt").notNull(),
+	/** Added after the prompt, for a note that is not worth editing it over. */
+	guidance: text("guidance"),
+	/** Null means whichever agent is currently the default. */
+	agentId: text("agent_id"),
+	/**
+	* Which action carries the answer back. Copied from the workflow when the
+	* loop is created and the loop's own from then on, so a workflow that
+	* changes its mind about where to write does not quietly move somebody's
+	* loop with it.
+	*
+	* The connector is stored apart from the one the loop watches because it
+	* need not be the same one. Being asked for a review on GitHub and
+	* answering in a chat is two connectors, and this column is what makes it
+	* one loop.
+	*/
+	actionConnectorId: text("action_connector_id").notNull(),
+	actionId: text("action_id").notNull(),
+	/** Answers to the action's own `target` fields. Empty means: back to the source. */
+	actionTarget: text("action_target", { mode: "json" }).$type().notNull().default({}),
+	/**
+	* Null until the loop has been looked at once. That first look is what
+	* separates the backlog that predates the loop from everything after it,
+	* so it is worth being able to tell the two apart.
+	*/
+	polledAt: integer("polled_at", { mode: "timestamp_ms" }),
+	/**
+	* How long to leave between looks, or null to look every time the dispatcher
+	* does.
+	*
+	* Worth having because looking often and acting cheaply pull in opposite
+	* directions. A loop that decides what is worth doing by weighing a batch
+	* has nothing to weigh when it is handed one item at a time, so for mail,
+	* where nothing turns on the next two minutes, waiting is what makes the
+	* weighing possible at all.
+	*/
+	pollEveryMs: integer("poll_every_ms"),
+	/** Why the last look failed, if it did. Cleared by a look that works. */
+	pollError: text("poll_error"),
+	/** Where a stream got to. The connector's own business. See `poll`. */
+	pollCursor: text("poll_cursor", { mode: "json" }).$type(),
+	createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`),
+	updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`)
+}, (table) => [index("loops_priority_idx").on(table.priority)]);
+/**
+* What a loop has already noticed. A loop acts once per key and never again,
+* which is the whole of not reviewing the same commit twice.
+*/
+var SIGNAL_OUTCOME = [
+	"queued",
+	"backlog",
+	"held",
+	"superseded"
+];
+var signals = sqliteTable("signals", {
+	loopId: text("loop_id").notNull().references(() => loops.id, { onDelete: "cascade" }),
+	/** The connector's own idea of identity: changing it means act again. */
+	key: text("key").notNull(),
+	outcome: text("outcome").$type().notNull(),
+	/** Enough to show and to act on later, without asking the service again. */
+	sourceKind: text("source_kind").$type().notNull(),
+	sourceRef: text("source_ref").notNull(),
+	sourcePayload: text("source_payload", { mode: "json" }).$type(),
+	sourceTitle: text("source_title").notNull(),
+	sourceUrl: text("source_url").notNull(),
+	/** In the words shown to whoever has to decide whether to run it anyway. */
+	hold: text("hold"),
+	taskId: text("task_id"),
+	seenAt: integer("seen_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`)
+}, (table) => [primaryKey({ columns: [table.loopId, table.key] }), index("signals_outcome_idx").on(table.loopId, table.outcome)]);
+/**
+* Agents are discovered on each runner, so nothing about their presence is
+* stored here. Only the choices a person makes live in this table.
+*/
+var agentSettings = sqliteTable("agent_settings", {
+	agentId: text("agent_id").primaryKey(),
+	permissionMode: text("permission_mode").$type().notNull(),
+	model: text("model"),
+	timeoutMs: integer("timeout_ms").notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`)
+});
+/** Small key/value store for single settings such as the default agent. */
+var appSettings = sqliteTable("app_settings", {
+	key: text("key").primaryKey(),
+	value: text("value", { mode: "json" }).$type().notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`)
+});
+/**
+* A joined runner that can run agents.
+*/
+/**
+* Credentials when App and Dispatcher do not share a keychain. Encrypted with
+* LOOPABLE_MASTER_KEY. Local laptop installs keep using the OS store.
+*/
+var secrets = sqliteTable("secrets", {
+	key: text("key").primaryKey(),
+	value: text("value").notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`)
+});
+var runners = sqliteTable("runners", {
+	id: text("id").primaryKey(),
+	name: text("name").notNull(),
+	hostname: text("hostname").notNull(),
+	status: text("status").$type().notNull().default("offline"),
+	inventory: text("inventory", { mode: "json" }).$type().notNull().default([]),
+	lastSeenAt: integer("last_seen_at", { mode: "timestamp_ms" }),
+	createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`)
+});
+function databaseUrl() {
+	if (process.env.LOOPABLE_DATABASE_URL) return process.env.LOOPABLE_DATABASE_URL;
+	return pathToFileURL(dbPath()).href;
+}
+function create() {
+	const client = createClient({
+		url: databaseUrl(),
+		authToken: process.env.LOOPABLE_DATABASE_AUTH_TOKEN
+	});
+	return drizzle(client, { schema: schema_exports });
+}
+function migrationsFolder() {
+	const here = fileURLToPath(new URL(".", import.meta.url));
+	return [
+		join(here, "../drizzle"),
+		join(here, "../../../drizzle"),
+		join(process.cwd(), "drizzle")
+	].find((folder) => existsSync(folder)) ?? join(process.cwd(), "drizzle");
+}
+/**
+* The dispatcher applies migrations. The App Worker has no drizzle folder on disk
+* in production, and must not race the dispatcher on a fresh database.
+*/
+async function migrateIfNeeded() {
+	if (process.env.LOOPABLE_SKIP_MIGRATE === "1") return;
+	const folder = migrationsFolder();
+	if (!existsSync(folder)) return;
+	await migrate(db(), { migrationsFolder: folder });
+}
+function rowsChanged(result) {
+	return Number(result.rowsAffected ?? result.changes ?? 0);
+}
+var cache = globalThis;
+function db() {
+	cache.__loopableDb ??= create();
+	return cache.__loopableDb;
+}
+//#endregion
+export { connections as a, loops as c, runDir as d, runners as f, tasks as g, signals as h, authAttempts as i, migrateIfNeeded as l, secrets as m, agentSettings as n, dataDir as o, secretNamespace as p, appSettings as r, db as s, __exportAll as t, rowsChanged as u };

package/.output/server/_ssr/connection-status-Bi5peUAk.mjs

@@ -0,0 +1,31 @@
+import { U as require_jsx_runtime } from "../_libs/@base-ui/react+[...].mjs";
+import { I as Badge } from "./router-3WmpE5b_.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/connection-status-Bi5peUAk.js
+var import_jsx_runtime = require_jsx_runtime();
+var LABELS = {
+	connected: {
+		text: "Connected",
+		variant: "default"
+	},
+	needs_reauth: {
+		text: "Needs reconnecting",
+		variant: "destructive"
+	},
+	error: {
+		text: "Error",
+		variant: "destructive"
+	},
+	paused: {
+		text: "Paused",
+		variant: "secondary"
+	}
+};
+function ConnectionStatusBadge({ status }) {
+	const label = LABELS[status] ?? LABELS.error;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Badge, {
+		variant: label.variant,
+		children: label.text
+	});
+}
+//#endregion
+export { ConnectionStatusBadge as t };