@engenty/wizards-runtime 0.0.0-stage → 0.7.5

package/apps/runtime/dist/cli/uninstall.js

@@ -0,0 +1,231 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, lstatSync, readdirSync, readlinkSync, rmdirSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve, sep } from "node:path";
+import * as p from "@clack/prompts";
+import { LOGIN_LABEL, present, removeUnit, UNIT, unloadLoginItem } from "./autostart.js";
+import { apps as allApps } from "./connect.js";
+import { findWizardsProcesses, stopProcesses } from "./processes.js";
+import { settings } from "./start.js";
+import { bad, cyan, dim, no, ok } from "./ui.js";
+export const realSystem = () => ({
+    userHome: homedir(),
+    platform: process.platform,
+    env: process.env,
+    interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+    apps: allApps,
+    processes: findWizardsProcesses,
+    stop: (pids) => stopProcesses(pids),
+    unloadLoginItem,
+    removeUnit,
+});
+/** Parts of the install folder that are the person's: kept or deleted with the data. */
+const WITH_DATA = [".env", ".env.local", "plugins"];
+function loginItemPath(system) {
+    if (system.platform === "darwin") {
+        return join(system.userHome, "Library", "LaunchAgents", `${LOGIN_LABEL}.plist`);
+    }
+    if (system.platform === "linux") {
+        const config = system.env.XDG_CONFIG_HOME || join(system.userHome, ".config");
+        return join(config, "systemd", "user", UNIT);
+    }
+    return null;
+}
+/** The links install.sh put into ~/.local/bin that point into the install. */
+function ourLinks(home, system) {
+    return ["wizards", "engenty-wizards"]
+        .map((name) => join(system.userHome, ".local", "bin", name))
+        .filter((link) => {
+        try {
+            return (lstatSync(link).isSymbolicLink() &&
+                resolve(dirname(link), readlinkSync(link)).startsWith(home + sep));
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** Works out what an uninstall takes away, without changing anything. */
+export async function makePlan(paths, system) {
+    const apps = [];
+    for (const app of system.apps(paths)) {
+        if (await app.connected().catch(() => false)) {
+            apps.push(app);
+        }
+    }
+    const item = loginItemPath(system);
+    let loginItem = null;
+    try {
+        loginItem = item && present(item) ? item : null;
+    }
+    catch {
+        // Can't look: count it as there, so the uninstall tries and says so.
+        loginItem = item;
+    }
+    const { dataDir } = settings(paths, system.env);
+    const program = [];
+    const data = existsSync(dataDir) ? [dataDir] : [];
+    for (const name of existsSync(paths.home) ? readdirSync(paths.home) : []) {
+        const path = join(paths.home, name);
+        if (path === dataDir) {
+            continue;
+        }
+        const empty = name === "plugins" && readdirSync(path).length === 0;
+        (WITH_DATA.includes(name) && !empty ? data : program).push(path);
+    }
+    return {
+        home: paths.home,
+        apps,
+        loginItem,
+        processes: system.processes(paths.home),
+        program,
+        links: ourLinks(paths.home, system),
+        data,
+    };
+}
+/** Size of a folder as `du` counts it, e.g. " (805 MB)"; "" where it can't tell. */
+function size(path) {
+    const kb = Number(spawnSync("du", ["-sk", path], { encoding: "utf8" }).stdout?.split(/\s/)[0]);
+    return kb > 0 ? ` (${kb < 1024 ? `${kb} KB` : `${Math.round(kb / 1024)} MB`})` : "";
+}
+const processes = (n) => `${n} running process${n === 1 ? "" : "es"}`;
+/** `wizards uninstall [--dry-run] [--yes] [--delete-data]`. */
+export async function uninstall(paths, options, system = realSystem()) {
+    const t = (path) => path.startsWith(system.userHome + sep) ? `~${path.slice(system.userHome.length)}` : path;
+    if (!options.dryRun && !options.yes && !system.interactive) {
+        console.error("The uninstall asks before it deletes anything, and there is no terminal to ask in.\n" +
+            "Run it with --yes (your data is kept), --yes --delete-data, or --dry-run to only look.");
+        return 2;
+    }
+    const plan = await makePlan(paths, system);
+    const steps = [
+        ...plan.apps.map((app) => `Disconnect ${app.name}`),
+        ...(plan.loginItem ? [`Remove the login item ${t(plan.loginItem)}`] : []),
+        ...(plan.processes.length ? [`Stop ${processes(plan.processes.length)}`] : []),
+        ...(plan.program.length ? [`Delete the program in ${t(plan.home)}${size(plan.home)}`] : []),
+        ...plan.links.map((link) => `Delete the command ${t(link)}`),
+    ];
+    if (!steps.length && !plan.data.length) {
+        console.log(`${ok} engenty wizards isn’t installed here.`);
+        return 0;
+    }
+    if (steps.length) {
+        console.log("\nThis removes engenty wizards:");
+    }
+    for (const step of steps) {
+        console.log(`  ${no} ${step}`);
+    }
+    if (plan.data.length) {
+        console.log(`\nYour data: ${plan.data.map((path) => t(path) + size(path)).join(", ")}`);
+        console.log(dim("  Kept unless you choose to delete it. A reinstall picks it up again."));
+    }
+    console.log("");
+    if (options.dryRun) {
+        console.log(dim("Nothing was changed (--dry-run)."));
+        return 0;
+    }
+    let deleteData = options.yes && options.deleteData;
+    if (!options.yes) {
+        if (plan.data.length) {
+            const answer = await p.confirm({
+                message: "Delete your data too? Your wizards, runs and results are gone for good.",
+                initialValue: false,
+            });
+            if (p.isCancel(answer)) {
+                return 130;
+            }
+            deleteData = answer;
+        }
+        const go = await p.confirm({
+            message: deleteData ? "Uninstall and delete your data now?" : "Uninstall now?",
+        });
+        if (p.isCancel(go) || !go) {
+            p.cancel("Nothing was changed.");
+            return 130;
+        }
+    }
+    const failed = (what, error) => console.log(`${bad} ${what}: ${error.message.split("\n")[0]}`);
+    for (const app of plan.apps) {
+        const result = await app
+            .disconnect()
+            .catch((error) => ({ ok: false, message: error.message }));
+        console.log(result.ok ? `${ok} Disconnected ${app.name}` : `${bad} ${app.name}: ${result.message}`);
+    }
+    if (plan.loginItem) {
+        try {
+            if (system.platform === "darwin") {
+                await system.unloadLoginItem();
+                rmSync(plan.loginItem, { force: true });
+            }
+            else {
+                await system.removeUnit(plan.loginItem);
+            }
+            console.log(`${ok} Removed the login item`);
+        }
+        catch (error) {
+            failed("The login item", error);
+        }
+    }
+    // Twice: an AI app's `wizards mcp` may start the studio again meanwhile.
+    for (let round = 0; round < 2; round++) {
+        const running = system.processes(paths.home);
+        if (running.length && !(await system.stop(running.map((proc) => proc.pid))).length) {
+            console.log(`${ok} Stopped ${processes(running.length)}`);
+        }
+    }
+    for (const path of [...plan.program, ...plan.links, ...(deleteData ? plan.data : [])]) {
+        try {
+            rmSync(path, { recursive: true, force: true });
+        }
+        catch (error) {
+            failed(`Couldn’t delete ${t(path)}`, error);
+        }
+    }
+    for (const dir of [plan.home, join(system.userHome, ".engenty")]) {
+        try {
+            rmdirSync(dir);
+        }
+        catch {
+            // not empty, or not there
+        }
+    }
+    // A second look: what is still there.
+    const after = await makePlan(paths, system);
+    const left = [
+        ...after.apps.map((app) => `${app.name} still lists the wizards: ${cyan(`npx wizards disconnect ${app.id}`)}`),
+        ...(after.loginItem ? [t(after.loginItem)] : []),
+        ...after.processes.map((proc) => `process ${proc.pid}: ${cyan(`kill -9 ${proc.pid}`)}`),
+        ...[...after.program, ...after.links, ...(deleteData ? after.data : [])].map(t),
+    ];
+    if (!deleteData && after.data.length) {
+        console.log(`${ok} Kept your data: ${after.data.map(t).join(", ")}`);
+    }
+    if (left.length) {
+        console.log(`\n${bad} Still there:`);
+        for (const line of left) {
+            console.log(`  ${line}`);
+        }
+        return 1;
+    }
+    console.log(`\n${ok} engenty wizards is uninstalled.\n`);
+    return 0;
+}
+/** The options of `uninstall` from its command line; a message when something is off. */
+export function parseUninstall(argv) {
+    const options = { dryRun: false, yes: false, deleteData: false };
+    for (const arg of argv) {
+        if (arg === "--dry-run") {
+            options.dryRun = true;
+        }
+        else if (arg === "--yes" || arg === "-y") {
+            options.yes = true;
+        }
+        else if (arg === "--delete-data") {
+            options.deleteData = true;
+        }
+        else if (arg !== "uninstall") {
+            return `Unknown option ${arg}. The uninstall takes --dry-run, --yes and --delete-data.`;
+        }
+    }
+    return options;
+}

package/apps/runtime/dist/cli/update.js

@@ -0,0 +1,86 @@
+import { spawn } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { autoUpdatePolicy, noteUpdated } from "./autoupdate.js";
+import { installedByScript, isCheckout, readInstallNote, writeInstallNote, } from "./home.js";
+import { runningRuntime, settings } from "./start.js";
+import { restart } from "./status.js";
+import { cmd, cyan, no, ok } from "./ui.js";
+import { currentVersion } from "./versions.js";
+/** The installer this install was made with; it also updates one. */
+const INSTALLER = "https://engenty.ai/install.sh";
+async function installer(into) {
+    const source = process.env.ENGENTY_WIZARDS_INSTALLER?.trim() || INSTALLER;
+    if (!/^https?:\/\//.test(source)) {
+        return source;
+    }
+    const response = await fetch(source);
+    const text = response.ok ? await response.text() : "";
+    // The address answers with the studio's page while a server has no installer yet.
+    if (!text.startsWith("#!")) {
+        throw new Error(`${source} didn’t return the installer.`);
+    }
+    const file = join(into, "install.sh");
+    writeFileSync(file, text, { mode: 0o700 });
+    return file;
+}
+/**
+ * Brings an install made by install.sh to the newest version by running the installer again
+ * without its questions: Node, the runtime and the command. With `restart`, a runtime that runs
+ * restarts into the new version; otherwise it says how.
+ */
+export async function update(paths, options = {}) {
+    if (!installedByScript(paths)) {
+        console.log(isCheckout()
+            ? `This is a source checkout. To update: ${cyan("git pull && pnpm install && pnpm build")}`
+            : `This copy runs from npm. To update: ${cyan("npx wizards@latest")}`);
+        return 0;
+    }
+    const before = currentVersion(paths);
+    const tmp = mkdtempSync(join(paths.home, "update-"));
+    try {
+        const script = await installer(tmp);
+        const code = await new Promise((done) => {
+            const child = spawn("bash", [script, "--no-setup"], { stdio: "inherit" });
+            child.on("error", () => done(127));
+            child.on("exit", (exit) => done(exit ?? 1));
+        });
+        if (code !== 0) {
+            return code;
+        }
+    }
+    catch (error) {
+        console.error(error.message);
+        return 1;
+    }
+    finally {
+        rmSync(tmp, { recursive: true, force: true });
+    }
+    const after = currentVersion(paths);
+    if (before && after) {
+        noteUpdated(paths, before, after);
+    }
+    if (await runningRuntime(settings(paths).dataDir)) {
+        if (options.restart) {
+            return restart(paths);
+        }
+        console.log(`  Installed. Restart engenty wizards to use the new version: ${cmd("restart")}`);
+    }
+    return 0;
+}
+/** `wizards autoupdate [on|off]`: whether updates come by themselves (autoupdate.ts). */
+export function autoUpdateCommand(paths, value) {
+    if (value && value !== "on" && value !== "off") {
+        console.error(`Use ${cmd("autoupdate on")} or ${cmd("autoupdate off")}.`);
+        return 2;
+    }
+    const installed = installedByScript(paths);
+    if (value && installed) {
+        writeInstallNote({ ...readInstallNote(paths), autoUpdate: value === "on" }, paths);
+    }
+    const policy = autoUpdatePolicy(paths, { installed });
+    console.log(policy.on
+        ? `${ok} Updates come by themselves: downloaded in the background, used from the next start.`
+        : `${no} Updates don’t come by themselves: ${policy.reason}. To update now: ${cmd("update")}`);
+    return value && !installed ? 1 : 0;
+}

package/apps/runtime/dist/cli/validate.js

@@ -0,0 +1,75 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { basename, dirname, join, relative } from "node:path";
+import { parseWizard } from "@engenty-wizards/shared/definition";
+import { PACKAGE_FILES, PACKAGE_MANIFEST } from "@engenty-wizards/shared/wizard-package";
+import { json, readManifest, readPackage } from "../services/package-file.js";
+import { bad, dim, ok } from "./ui.js";
+function workspace(folder) {
+    const root = join(folder, PACKAGE_FILES);
+    try {
+        return readdirSync(root, { recursive: true, withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name !== ".DS_Store")
+            .map((entry) => relative(root, join(entry.parentPath, entry.name)).split("\\").join("/"));
+    }
+    catch {
+        return [];
+    }
+}
+/** The definition and the workspace's paths, read the way the import reads them. */
+function read(path) {
+    const folder = statSync(path).isDirectory()
+        ? path
+        : basename(path) === PACKAGE_MANIFEST
+            ? dirname(path)
+            : null;
+    if (folder) {
+        const manifest = readManifest(json(readFileSync(join(folder, PACKAGE_MANIFEST))));
+        return { definition: manifest.definition, files: workspace(folder) };
+    }
+    const { manifest, files } = readPackage(readFileSync(path));
+    return { definition: manifest.definition, files: files.map((f) => f.path) };
+}
+export function validatePath(path) {
+    let given;
+    try {
+        given = read(path);
+    }
+    catch (err) {
+        const message = err.code === "ENOENT"
+            ? "No such file or folder."
+            : err.message;
+        return { path, ok: false, issues: [{ message }] };
+    }
+    const parsed = parseWizard(given.definition, given.files);
+    return {
+        path,
+        ok: parsed.ok && parsed.issues.length === 0,
+        steps: parsed.ok ? parsed.wizard.steps.length : undefined,
+        files: given.files.length,
+        issues: parsed.issues,
+    };
+}
+export function validateCommand(paths, asJson) {
+    if (!paths.length) {
+        console.error("Give a path: a .wizard file, an unpacked package or a wizard JSON file.");
+        return 2;
+    }
+    const results = paths.map(validatePath);
+    if (asJson) {
+        console.log(JSON.stringify(results, null, 2));
+    }
+    else {
+        for (const r of results) {
+            if (r.ok) {
+                console.log(`${ok} ${r.path} ${dim(`${r.steps} ${r.steps === 1 ? "step" : "steps"}, ${r.files} ${r.files === 1 ? "file" : "files"}`)}`);
+                continue;
+            }
+            const count = `${r.issues.length} ${r.issues.length === 1 ? "issue" : "issues"}`;
+            console.log(`${bad} ${r.path} ${dim(count)}`);
+            for (const issue of r.issues) {
+                console.log(`  ${issue.message}`);
+            }
+        }
+    }
+    return results.every((r) => r.ok) ? 0 : 1;
+}

package/apps/runtime/dist/cli/versions.js

@@ -0,0 +1,123 @@
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, renameSync, rmSync, symlinkSync, } from "node:fs";
+import { join } from "node:path";
+/**
+ * The runtimes of an install made by install.sh, one folder per version, side by side:
+ *
+ *   runtime/<version>/     an npm prefix: node_modules/@engenty/wizards-runtime (up to 0.7.4
+ *                          node_modules/wizards), package.json, package-lock.json
+ *   runtime/current        → <version>, the one `bin/wizards` starts
+ *   runtime/node_modules   → current/node_modules, for commands written before the versions
+ *
+ * Up to 0.6.2 `runtime/` itself was the prefix; `switchTo` moves such an install into its
+ * version folder first. A process keeps the files of the version it started with.
+ */
+const VERSION = /^\d+\.\d+\.\d+$/;
+/** The npm package of the runtime. Up to 0.7.4 it was `wizards`, now the launcher `npx` runs. */
+export const RUNTIME_PACKAGE = "@engenty/wizards-runtime";
+/** The runtime's name up to 0.7.4, and where a command or an update of then looks for it. */
+const LEGACY_PACKAGE = "wizards";
+export const runtimeDir = (paths, version) => join(paths.runtime, version);
+const currentLink = (paths) => join(paths.runtime, "current");
+const modules = (paths) => join(paths.runtime, "node_modules");
+function versionOf(dir) {
+    try {
+        const { version } = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+        return typeof version === "string" ? version : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The version of the runtime in an npm prefix; null when there is none. A `wizards` without the
+ * runtime in it is the launcher, which an update of 0.7.4 or older fetches as the new version.
+ */
+export function versionIn(prefix) {
+    const legacy = join(prefix, "node_modules", LEGACY_PACKAGE);
+    return (versionOf(join(prefix, "node_modules", RUNTIME_PACKAGE)) ??
+        (existsSync(join(legacy, "apps", "runtime")) ? versionOf(legacy) : null));
+}
+const isLink = (path) => {
+    try {
+        return lstatSync(path).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+};
+/** The version `bin/wizards` starts; null without a runtime. */
+export function currentVersion(paths) {
+    if (isLink(currentLink(paths))) {
+        return versionIn(join(paths.runtime, readlinkSync(currentLink(paths))));
+    }
+    return versionIn(paths.runtime);
+}
+/** The version folders there are, each with a complete package in it. */
+export function installedVersions(paths) {
+    try {
+        return readdirSync(paths.runtime)
+            .filter((name) => VERSION.test(name) && versionIn(join(paths.runtime, name)) === name)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+/** Points `link` at `target` in one step: a new link renamed over the old one. */
+function link(target, path) {
+    const tmp = `${path}.${process.pid}.tmp`;
+    rmSync(tmp, { force: true });
+    symlinkSync(target, tmp);
+    renameSync(tmp, path);
+}
+/** Moves a runtime from before the version folders into `runtime/<version>/`. */
+function adoptLegacy(paths) {
+    const version = versionIn(paths.runtime);
+    if (isLink(modules(paths)) || !version) {
+        return;
+    }
+    const into = runtimeDir(paths, version);
+    rmSync(into, { recursive: true, force: true });
+    mkdirSync(into, { recursive: true });
+    for (const name of ["node_modules", "package.json", "package-lock.json"]) {
+        if (existsSync(join(paths.runtime, name))) {
+            renameSync(join(paths.runtime, name), join(into, name));
+        }
+    }
+    link(version, currentLink(paths));
+}
+/** Makes `version` the one `bin/wizards` starts from now on. */
+export function switchTo(paths, version) {
+    if (versionIn(runtimeDir(paths, version)) !== version) {
+        throw new Error(`${runtimeDir(paths, version)} holds no complete runtime ${version}.`);
+    }
+    adoptLegacy(paths);
+    link(version, currentLink(paths));
+    link(join("current", "node_modules"), modules(paths));
+}
+/** Deletes the version folders other than `keep` and the current one; returns what went. */
+export function prune(paths, keep) {
+    const current = currentVersion(paths);
+    const stale = installedVersions(paths).filter((v) => v !== current && !keep.includes(v));
+    for (const version of stale) {
+        rmSync(runtimeDir(paths, version), { recursive: true, force: true });
+    }
+    return stale;
+}
+/** Puts an npm prefix installed elsewhere into its version folder (never the current one). */
+export function promote(paths, staged, version) {
+    if (versionIn(staged) !== version) {
+        throw new Error(`The download holds version ${versionIn(staged) ?? "none"}, not ${version}.`);
+    }
+    if (currentVersion(paths) === version) {
+        rmSync(staged, { recursive: true, force: true });
+        return;
+    }
+    // As install.sh leaves it: a command of 0.7.4 or older finds the runtime under its old name.
+    const legacy = join(staged, "node_modules", LEGACY_PACKAGE);
+    if (!existsSync(legacy)) {
+        symlinkSync(RUNTIME_PACKAGE, legacy);
+    }
+    rmSync(runtimeDir(paths, version), { recursive: true, force: true });
+    renameSync(staged, runtimeDir(paths, version));
+}

package/apps/runtime/dist/connectors/builtin.js

@@ -0,0 +1,86 @@
+import { createGuardedFetch } from "../engenty/connections-external/net/guarded-fetch.js";
+import { githubConnector } from "../engenty/connections-github/connector.js";
+import { googleConnectors } from "../engenty/connections-google/definitions.js";
+import { GOOGLE_OAUTH2 } from "../engenty/connections-google/shared.js";
+import { hubspotConnector } from "../engenty/connections-hubspot/connector.js";
+import { microsoftOneDriveConnector } from "../engenty/connections-microsoft/onedrive.js";
+import { microsoftOutlookConnector } from "../engenty/connections-microsoft/outlook.js";
+import { s3Connector } from "../engenty/connections-s3/s3.js";
+import { hasOAuth2ClientCredentials, } from "../engenty/connections-sdk/oauth2.js";
+import { registerConnectorDefinition } from "../engenty/connections-sdk/registry.js";
+import { slackConnector } from "../engenty/connections-slack/connector.js";
+import { managed } from "../manage.js";
+import { gmailConnector as mailGmail } from "./gmail.js";
+import { imapConnector } from "./imap.js";
+import { outlookConnector as mailOutlook } from "./outlook.js";
+import { googleThroughAccount } from "./via-account.js";
+/**
+ * engenty's own connectors, as engenty ships them: Gmail, Drive, Calendar, Contacts, Outlook,
+ * OneDrive, Slack, GitHub, HubSpot, S3. Every project has them; an OAuth one can be connected
+ * once its client is configured.
+ */
+export const BUILTIN_CONNECTORS = [
+    ...googleConnectors,
+    microsoftOutlookConnector,
+    microsoftOneDriveConnector,
+    slackConnector,
+    githubConnector,
+    hubspotConnector,
+    s3Connector,
+];
+/** The connectors behind a connection of kind "mail": one read-only shape for any mailbox. */
+export const MAIL_CONNECTORS = [mailGmail, mailOutlook, imapConnector];
+// One registry for all of them, so an imported connector can never take a built-in's id.
+for (const connector of [...BUILTIN_CONNECTORS, ...MAIL_CONNECTORS]) {
+    registerConnectorDefinition(connector);
+}
+export function builtinConnector(id) {
+    return BUILTIN_CONNECTORS.find((c) => c.id === id);
+}
+/**
+ * engenty names OAuth clients `<VENDOR>_OAUTH_CLIENT_ID`. Google and Microsoft allow one client
+ * several redirect addresses, so the client this product signs people in with (`<VENDOR>_CLIENT_ID`)
+ * serves connections too. GitHub and Slack tie a client to one address: they need their own.
+ */
+export const resolveEnv = async (key) => {
+    const own = process.env[key]?.trim();
+    if (own || !/^(GOOGLE|MICROSOFT)_OAUTH_/.test(key)) {
+        return own || undefined;
+    }
+    return process.env[key.replace("_OAUTH_", "_")]?.trim() || undefined;
+};
+/** Whether a person can connect an account with this connector right now. */
+export async function usable(connector) {
+    if (connector.auth.kind !== "oauth2") {
+        return connector.auth.kind === "api_key";
+    }
+    // A connector that registers its own OAuth client needs none configured.
+    return (connector.auth.oauth2.dynamicClientRegistration === true ||
+        (await hasOAuth2ClientCredentials(connector.auth.oauth2, resolveEnv)) ||
+        viaAccount(connector));
+}
+/**
+ * A Google connector on a local install without a Google client of its own: it connects through
+ * the Manage-App of the linked account, when that one offers it. Offered before an account is
+ * linked too; connecting then asks to link it first.
+ */
+export async function viaAccount(connector) {
+    return (!managed &&
+        connector.auth.kind === "oauth2" &&
+        connector.auth.oauth2 === GOOGLE_OAUTH2 &&
+        !(await hasOAuth2ClientCredentials(connector.auth.oauth2, resolveEnv)) &&
+        (await googleThroughAccount()));
+}
+/** What the server's owner has to set for an OAuth connector that is not usable yet. */
+export function missingSetup(connector) {
+    if (connector.auth.kind !== "oauth2") {
+        return null;
+    }
+    const { clientIdEnv, clientSecretEnv } = connector.auth.oauth2;
+    return clientIdEnv && clientSecretEnv ? `${clientIdEnv}, ${clientSecretEnv}` : null;
+}
+/**
+ * Connector actions reach addresses that come from a person or a spec (an S3 endpoint, an API's
+ * base URL): every request is checked to stay on the public internet.
+ */
+export const connectorFetch = createGuardedFetch();