@somacheck/vibecheck 0.2.0 → 0.3.0

package/dist/cli.js

@@ -1,35 +1,250 @@
 #!/usr/bin/env node
 import { homedir } from "node:os";
+import { createInterface } from "node:readline/promises";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { SupabaseAgentApi } from "./api.js";
+import { clientDisplayName, detectInstalledClients, detectLegacyHostedRegistration, LocalCommandRunner, manualLegacyHostedRemoveCommand, manualRemoveCommand, manualSetupCommand, parseClientChoice, preflightClientPersistence, registerClient, singleNonInteractiveClientSelection, } from "./client-setup.js";
 import { readConfig } from "./config.js";
 import { SUPABASE_PUBLISHABLE_KEY, SUPABASE_URL } from "./constants.js";
-import { linkAgent } from "./link.js";
+import { LinkPersistenceError, NonInteractiveLinkError, linkAgent } from "./link.js";
+import { checkReadiness } from "./readiness.js";
 import { createVibecheckServer } from "./server.js";
 const api = new SupabaseAgentApi(SUPABASE_URL, SUPABASE_PUBLISHABLE_KEY);
+const runner = new LocalCommandRunner();
+const output = (line) => process.stdout.write(`${line}\n`);
+class ClientPreflightError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ClientPreflightError";
+    }
+}
+function usage() {
+    return [
+        "Usage:",
+        "  npx -y @somacheck/vibecheck link <CODE> [--client codex|claude|all|none]",
+        "  npx -y @somacheck/vibecheck setup <codex|claude|all>",
+        "  npx -y @somacheck/vibecheck doctor",
+    ].join("\n");
+}
+function parseLinkClient(args) {
+    if (args.length === 0)
+        return "prompt";
+    if (args.length !== 2 || args[0] !== "--client")
+        throw new Error(usage());
+    const selection = args[1]?.toLowerCase();
+    if (selection === "codex" || selection === "claude")
+        return [selection];
+    if (selection === "all")
+        return ["codex", "claude"];
+    if (selection === "none")
+        return [];
+    throw new Error(usage());
+}
+function parseServeClient(args) {
+    if (args.length !== 3 || args[0] !== "serve" || args[1] !== "--client")
+        return null;
+    return args[2] === "codex" || args[2] === "claude" ? args[2] : null;
+}
+async function promptForClients(installed) {
+    if (installed.length === 0)
+        return [];
+    const labels = installed.map((client) => clientDisplayName(client)).join(" and ");
+    output(`Found ${labels}.`);
+    const options = installed.length === 1
+        ? `Configure ${clientDisplayName(installed[0])} now? [Y/n] `
+        : "Configure [1] Codex / ChatGPT desktop, [2] Claude Code, [3] both, or [4] later: ";
+    const terminal = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        while (true) {
+            const answer = await terminal.question(options);
+            if (installed.length === 1 && (answer.trim() === "" || /^y(es)?$/i.test(answer)))
+                return installed;
+            if (installed.length === 1 && /^n(o)?$/i.test(answer))
+                return [];
+            const selected = parseClientChoice(answer, installed);
+            if (selected !== null)
+                return selected;
+            output("Choose one of the listed options.");
+        }
+    }
+    finally {
+        terminal.close();
+    }
+}
+async function configureClients(clients) {
+    for (const client of clients) {
+        const result = await registerClient(client, runner);
+        if (result.status === "registered") {
+            output(`✓ Configured ${clientDisplayName(client)}.`);
+        }
+        else if (result.status === "upgraded") {
+            output(`✓ Upgraded ${clientDisplayName(client)} from the older SomaCheck MCP registration.`);
+        }
+        else if (result.status === "already_registered") {
+            output(`✓ ${clientDisplayName(client)} was already configured.`);
+        }
+        else if (result.status === "needs_update") {
+            output(`✗ ${clientDisplayName(client)} already has a different SomaCheck command or version.`);
+            output("  Run doctor for safe replacement instructions; the existing entry was not changed.");
+        }
+        else if (result.status === "not_installed") {
+            output(`○ ${clientDisplayName(client)} is not installed; skipped.`);
+        }
+        else {
+            output(`✗ Could not configure ${clientDisplayName(client)} automatically.`);
+        }
+    }
+}
+async function preflightLinkClients(clients, interactive) {
+    const nonInteractiveClient = interactive ? null : singleNonInteractiveClientSelection(clients);
+    const selectedClients = interactive
+        ? clients === "prompt" ? [] : clients
+        : nonInteractiveClient === null ? [] : [nonInteractiveClient];
+    if (selectedClients.length === 0) {
+        throw new ClientPreflightError([
+            interactive
+                ? "Not linking yet: choose one installed local client before redeeming the pairing code."
+                : "Not linking here: non-interactive setup must name one local client explicitly.",
+            "",
+            "Run the command in Terminal, or paste it into the local agent with exactly one",
+            "client selection, for example:",
+            "  npx -y @somacheck/vibecheck@0.3.0 link <CODE> --client claude",
+            "  npx -y @somacheck/vibecheck@0.3.0 link <CODE> --client codex",
+            "",
+            "The pairing code has NOT been used.",
+        ].join("\n"));
+    }
+    for (const client of selectedClients) {
+        const legacyHosted = await detectLegacyHostedRegistration(client, runner);
+        if (legacyHosted !== null) {
+            throw new ClientPreflightError([
+                `Not linking yet: ${clientDisplayName(client)} still has the separate legacy "somacheck" connector.`,
+                "It can make an agent choose the wrong tools and mistake its OAuth prompt for this local link.",
+                "",
+                `Remove only that legacy entry: ${manualLegacyHostedRemoveCommand(client)}`,
+                "Then run the link command again. The pairing code has NOT been used.",
+            ].join("\n"));
+        }
+        output(`Checking ${clientDisplayName(client)} before redeeming the pairing code...`);
+        const preflight = await preflightClientPersistence(client, runner);
+        if (preflight.status === "ready") {
+            output(`✓ ${clientDisplayName(client)} already has the exact SomaCheck MCP registration.`);
+            continue;
+        }
+        if (preflight.status === "registered" || preflight.status === "upgraded") {
+            const verb = preflight.status === "upgraded" ? "was safely upgraded" : "was configured";
+            output(`✓ ${clientDisplayName(client)} ${verb} before redeeming the pairing code.`);
+            continue;
+        }
+        const reason = preflight.status === "not_installed"
+            ? `${clientDisplayName(client)} is not installed or its CLI is unavailable.`
+            : preflight.status === "needs_update"
+                ? `${clientDisplayName(client)} has an existing "vibecheck" MCP entry with a different command or version.`
+                : `${clientDisplayName(client)} configuration could not be inspected and written.`;
+        const repair = preflight.status === "needs_update"
+            ? ["", `Remove the stale entry: ${manualRemoveCommand(client)}`, `Then configure 0.3: ${manualSetupCommand(client)}`]
+            : [];
+        throw new ClientPreflightError([
+            `Not linking here: ${reason}`,
+            ...repair,
+            "",
+            "The pairing code has NOT been used. Fix the local client configuration, then",
+            "run the link command again.",
+        ].join("\n"));
+    }
+    return selectedClients;
+}
+async function runDoctor() {
+    output("\nSomaCheck connection check");
+    const readiness = await checkReadiness({ home: homedir(), api, runner, output });
+    return readiness.ready;
+}
+async function refreshRuntimeHealth(client) {
+    const token = (await readConfig(homedir())).token;
+    await api.statusRequest(token);
+    await api.contextRequest(token);
+    await api.clientHandshake(token, {
+        client_key: client,
+        client_label: clientDisplayName(client),
+        registration_exact: true,
+        status_probe_ok: true,
+        context_probe_ok: true,
+    });
+}
+async function startServer(runtimeClient) {
+    const server = createVibecheckServer({
+        api,
+        loadToken: async () => (await readConfig(homedir())).token,
+    });
+    await server.connect(new StdioServerTransport());
+    if (runtimeClient !== null) {
+        // Never write health-check output to stdout: this process speaks MCP over
+        // stdio. Tool calls retain their own categorized diagnostics if refresh
+        // fails, and the phone will simply keep the client out of Ready.
+        void refreshRuntimeHealth(runtimeClient).catch(() => undefined);
+    }
+}
 async function main() {
     const args = process.argv.slice(2);
     if (args[0] === "link") {
-        if (args.length !== 2) {
-            throw new Error("Usage: npx @somacheck/vibecheck link <CODE>");
-        }
+        if (args.length < 2)
+            throw new Error(usage());
+        const requestedClients = parseLinkClient(args.slice(2));
+        const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+        const requestedOrPromptedClients = interactive
+            ? requestedClients === "prompt"
+                ? await promptForClients(await detectInstalledClients(runner))
+                : requestedClients
+            : requestedClients;
         await linkAgent(args[1] ?? "", {
             home: homedir(),
             redeem: (code) => api.redeemLink(code),
-            output: (line) => process.stdout.write(`${line}\n`),
+            output,
+            isInteractive: () => interactive,
+            allowNonInteractive: !interactive || process.env.SOMACHECK_ALLOW_NON_INTERACTIVE === "1",
+            preflight: async () => {
+                await preflightLinkClients(requestedOrPromptedClients, interactive);
+            },
         });
-        return;
+        return (await runDoctor()) ? 0 : 2;
     }
-    if (args.length !== 0) {
-        throw new Error("Usage: npx @somacheck/vibecheck [link <CODE>]");
+    if (args[0] === "setup") {
+        if (args.length !== 2)
+            throw new Error(usage());
+        const requested = args[1]?.toLowerCase();
+        const clients = requested === "all"
+            ? ["codex", "claude"]
+            : requested === "codex" || requested === "claude"
+                ? [requested]
+                : [];
+        if (clients.length === 0)
+            throw new Error(usage());
+        await configureClients(clients);
+        return (await runDoctor()) ? 0 : 2;
     }
-    const server = createVibecheckServer({
-        api,
-        loadToken: async () => (await readConfig(homedir())).token,
-    });
-    await server.connect(new StdioServerTransport());
+    if (args[0] === "doctor") {
+        if (args.length !== 1)
+            throw new Error(usage());
+        return (await runDoctor()) ? 0 : 2;
+    }
+    const runtimeClient = parseServeClient(args);
+    if (runtimeClient !== null) {
+        await startServer(runtimeClient);
+        return 0;
+    }
+    if (args.length !== 0)
+        throw new Error(usage());
+    await startServer(null);
+    return 0;
 }
-main().catch((error) => {
+main().then((exitCode) => {
+    process.exitCode = exitCode;
+}).catch((error) => {
+    if (error instanceof NonInteractiveLinkError || error instanceof LinkPersistenceError || error instanceof ClientPreflightError) {
+        process.stderr.write(`${error.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
     const isUsageError = error instanceof Error && error.message.startsWith("Usage:");
     const message = isUsageError
         ? error.message

package/dist/client-setup.js

@@ -0,0 +1,206 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { LEGACY_HOSTED_MCP_SERVER_NAME, MCP_SERVER_NAME, PACKAGE_SPEC } from "./constants.js";
+const execFileAsync = promisify(execFile);
+export class LocalCommandRunner {
+    async run(command, args) {
+        try {
+            const result = await execFileAsync(command, args, {
+                encoding: "utf8",
+                maxBuffer: 1024 * 1024,
+                timeout: 20_000,
+            });
+            return { exitCode: 0, stdout: result.stdout, stderr: result.stderr };
+        }
+        catch (error) {
+            const failure = error;
+            return {
+                exitCode: typeof failure.code === "number" ? failure.code : 127,
+                stdout: failure.stdout ?? "",
+                stderr: failure.stderr ?? "",
+            };
+        }
+    }
+}
+export function clientDisplayName(client) {
+    return client === "codex" ? "Codex / ChatGPT desktop" : "Claude Code";
+}
+function mcpServerArgs(client) {
+    return ["-y", PACKAGE_SPEC, "serve", "--client", client];
+}
+export function manualSetupCommand(client) {
+    if (client === "codex") {
+        return `codex mcp add ${MCP_SERVER_NAME} -- npx ${mcpServerArgs(client).join(" ")}`;
+    }
+    return `claude mcp add --scope user ${MCP_SERVER_NAME} -- npx ${mcpServerArgs(client).join(" ")}`;
+}
+export function manualRemoveCommand(client) {
+    return client === "codex"
+        ? `codex mcp remove ${MCP_SERVER_NAME}`
+        : `claude mcp remove --scope user ${MCP_SERVER_NAME}`;
+}
+export function manualLegacyHostedRemoveCommand(client) {
+    return client === "codex"
+        ? `codex mcp remove ${LEGACY_HOSTED_MCP_SERVER_NAME}`
+        : `claude mcp remove --scope user ${LEGACY_HOSTED_MCP_SERVER_NAME}`;
+}
+export async function isClientInstalled(client, runner) {
+    const command = client === "codex" ? "codex" : "claude";
+    return (await runner.run(command, ["--version"])).exitCode === 0;
+}
+export async function clientRegistrationState(client, runner) {
+    const command = client === "codex" ? "codex" : "claude";
+    const args = client === "codex"
+        ? ["mcp", "get", MCP_SERVER_NAME, "--json"]
+        : ["mcp", "get", MCP_SERVER_NAME];
+    const result = await runner.run(command, args);
+    if (result.exitCode !== 0)
+        return "missing";
+    if (registrationMatches(client, result.stdout))
+        return "current";
+    return isManagedSomaCheckRegistration(client, result.stdout) ? "managed_update" : "needs_update";
+}
+export async function detectLegacyHostedRegistration(client, runner) {
+    const command = client === "codex" ? "codex" : "claude";
+    const args = client === "codex"
+        ? ["mcp", "get", LEGACY_HOSTED_MCP_SERVER_NAME, "--json"]
+        : ["mcp", "get", LEGACY_HOSTED_MCP_SERVER_NAME];
+    const result = await runner.run(command, args);
+    if (result.exitCode !== 0)
+        return null;
+    const combined = `${result.stdout}\n${result.stderr}`;
+    return {
+        client,
+        status: /needs\s+authentication|authenticate|oauth/i.test(combined)
+            ? "needs_authentication"
+            : "present",
+    };
+}
+function registrationMatches(client, stdout) {
+    if (client === "codex") {
+        try {
+            const value = JSON.parse(stdout);
+            return value.enabled !== false
+                && value.transport?.type === "stdio"
+                && value.transport.command === "npx"
+                && Array.isArray(value.transport.args)
+                && value.transport.args.length === 5
+                && value.transport.args.every((arg, index) => arg === mcpServerArgs(client)[index]);
+        }
+        catch {
+            return false;
+        }
+    }
+    const command = /^\s*Command:\s*(\S+)\s*$/im.exec(stdout)?.[1];
+    const rawArgs = /^\s*Args:\s*(.*?)\s*$/im.exec(stdout)?.[1] ?? "";
+    const parsedArgs = rawArgs.split(/\s+/).filter(Boolean);
+    const expectedArgs = mcpServerArgs(client);
+    return command === "npx"
+        && parsedArgs.length === expectedArgs.length
+        && parsedArgs.every((arg, index) => arg === expectedArgs[index]);
+}
+function isManagedSomaCheckRegistration(client, stdout) {
+    let command;
+    let args = [];
+    if (client === "codex") {
+        try {
+            const value = JSON.parse(stdout);
+            if (value.enabled === false || value.transport?.type !== "stdio")
+                return false;
+            command = typeof value.transport.command === "string" ? value.transport.command : undefined;
+            args = Array.isArray(value.transport.args) && value.transport.args.every((arg) => typeof arg === "string")
+                ? value.transport.args
+                : [];
+        }
+        catch {
+            return false;
+        }
+    }
+    else {
+        command = /^\s*Command:\s*(\S+)\s*$/im.exec(stdout)?.[1];
+        args = (/^\s*Args:\s*(.*?)\s*$/im.exec(stdout)?.[1] ?? "").split(/\s+/).filter(Boolean);
+    }
+    if (command !== "npx")
+        return false;
+    const packageArgs = args.filter((arg) => arg.startsWith("@somacheck/vibecheck@"));
+    return packageArgs.length === 1
+        && /^@somacheck\/vibecheck@0\.[0-2]\.\d+$/.test(packageArgs[0])
+        && args.every((arg) => arg === "-y" || arg === "--yes" || arg === packageArgs[0]);
+}
+export async function isClientRegistered(client, runner) {
+    return (await clientRegistrationState(client, runner)) === "current";
+}
+export async function detectInstalledClients(runner) {
+    const clients = ["codex", "claude"];
+    const installed = await Promise.all(clients.map(async (client) => ({
+        client,
+        installed: await isClientInstalled(client, runner),
+    })));
+    return installed.filter((item) => item.installed).map((item) => item.client);
+}
+export async function registerClient(client, runner) {
+    if (!(await isClientInstalled(client, runner))) {
+        return { client, status: "not_installed" };
+    }
+    const registration = await clientRegistrationState(client, runner);
+    if (registration === "current") {
+        return { client, status: "already_registered" };
+    }
+    if (registration === "needs_update")
+        return { client, status: "needs_update" };
+    const command = client === "codex" ? "codex" : "claude";
+    if (registration === "managed_update") {
+        const removeArgs = client === "codex"
+            ? ["mcp", "remove", MCP_SERVER_NAME]
+            : ["mcp", "remove", "--scope", "user", MCP_SERVER_NAME];
+        if ((await runner.run(command, removeArgs)).exitCode !== 0) {
+            return { client, status: "failed" };
+        }
+    }
+    const serverArgs = mcpServerArgs(client);
+    const args = client === "codex"
+        ? ["mcp", "add", MCP_SERVER_NAME, "--", "npx", ...serverArgs]
+        : ["mcp", "add", "--scope", "user", MCP_SERVER_NAME, "--", "npx", ...serverArgs];
+    const result = await runner.run(command, args);
+    return {
+        client,
+        status: result.exitCode === 0
+            ? registration === "managed_update" ? "upgraded" : "registered"
+            : "failed",
+    };
+}
+export async function preflightClientPersistence(client, runner) {
+    if (!(await isClientInstalled(client, runner))) {
+        return { client, status: "not_installed" };
+    }
+    const registration = await clientRegistrationState(client, runner);
+    if (registration === "current") {
+        return { client, status: "ready" };
+    }
+    if (registration === "needs_update") {
+        return { client, status: "needs_update" };
+    }
+    const result = await registerClient(client, runner);
+    if (result.status !== "registered" && result.status !== "upgraded" && result.status !== "already_registered") {
+        return { client, status: result.status === "not_installed" ? "not_installed" : "failed" };
+    }
+    return (await clientRegistrationState(client, runner)) === "current"
+        ? { client, status: result.status === "upgraded" ? "upgraded" : "registered" }
+        : { client, status: "failed" };
+}
+export function singleNonInteractiveClientSelection(clients) {
+    return clients !== "prompt" && clients.length === 1 ? clients[0] : null;
+}
+export function parseClientChoice(value, installed) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "later" || normalized === "none" || normalized === "4")
+        return [];
+    if ((normalized === "codex" || normalized === "1") && installed.includes("codex"))
+        return ["codex"];
+    if ((normalized === "claude" || normalized === "2") && installed.includes("claude"))
+        return ["claude"];
+    if (normalized === "all" || normalized === "both" || normalized === "3")
+        return [...installed];
+    return null;
+}
+//# sourceMappingURL=client-setup.js.map

package/dist/config.js

@@ -3,13 +3,30 @@ import { join } from "node:path";
 export function configPath(home) {
     return join(home, ".sensie", "config.json");
 }
+/** Prove the token directory supports the same create/rename/remove sequence
+ * used by writeConfig before a single-use pairing code is redeemed. */
+export async function preflightConfigPersistence(home) {
+    const directory = join(home, ".sensie");
+    const probe = join(directory, `.config-preflight.${process.pid}.${Date.now()}.tmp`);
+    const renamedProbe = `${probe}.renamed`;
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    await chmod(directory, 0o700);
+    try {
+        await writeFile(probe, "", { encoding: "utf8", flag: "wx", mode: 0o600 });
+        await rename(probe, renamedProbe);
+    }
+    finally {
+        await rm(probe, { force: true });
+        await rm(renamedProbe, { force: true });
+    }
+}
 export async function readConfig(home) {
     let value;
     try {
         value = JSON.parse(await readFile(configPath(home), "utf8"));
     }
     catch {
-        throw new Error("SomaCheck is not linked. Run: npx @somacheck/vibecheck link <CODE>");
+        throw new Error("SomaCheck is not linked. Run: npx -y @somacheck/vibecheck link <CODE>");
     }
     if (value === null || typeof value !== "object" || !("token" in value)) {
         throw new Error("SomaCheck link configuration is invalid.");

package/dist/constants.js

@@ -1,4 +1,17 @@
 // Supabase publishable keys are public client identifiers; authorization remains enforced by RLS/RPCs.
 export const SUPABASE_URL = "https://pbldcmniommltbdwuykk.supabase.co";
 export const SUPABASE_PUBLISHABLE_KEY = "sb_publishable_af-lUNI2FqEcb-oGy-4uxQ_cnm6kY85";
+export const PACKAGE_NAME = "@somacheck/vibecheck";
+export const PACKAGE_VERSION = "0.3.0";
+export const PACKAGE_SPEC = `${PACKAGE_NAME}@${PACKAGE_VERSION}`;
+export const MCP_SERVER_NAME = "vibecheck";
+export const LEGACY_HOSTED_MCP_SERVER_NAME = "somacheck";
+export const BACKEND_PROTOCOL_VERSION = 3;
+export const TOOLSET_VERSION = "vibecheck-0.3";
+export const TOOL_NAMES = [
+    "get_vibecheck_context",
+    "get_vibecheck_status",
+    "post_vibecheck_statement",
+    "get_vibecheck_result",
+];
 //# sourceMappingURL=constants.js.map

package/dist/link.js

@@ -1,11 +1,60 @@
-import { writeConfig } from "./config.js";
+import { preflightConfigPersistence, writeConfig } from "./config.js";
+/**
+ * Thrown when linking is attempted somewhere a pairing code should not be spent.
+ * Carries guidance rather than a bare failure: the person reading it is mid-setup
+ * and needs to know where to go instead.
+ */
+export class NonInteractiveLinkError extends Error {
+    constructor() {
+        super([
+            "Not linking here: this doesn't look like a terminal with a person at it.",
+            "",
+            "`link` sets up the computer that will run the SomaCheck MCP server. It is",
+            "not a task for a chat assistant -- an assistant's sandbox is usually wiped",
+            "between sessions, so the pairing code would be spent and the link lost.",
+            "",
+            "Open Terminal on your own computer and run the command there.",
+            "",
+            "Your pairing code has NOT been used. It is still valid.",
+            "",
+            "If you really are provisioning a machine non-interactively, re-run with",
+            "SOMACHECK_ALLOW_NON_INTERACTIVE=1.",
+        ].join("\n"));
+        this.name = "NonInteractiveLinkError";
+    }
+}
+export class LinkPersistenceError extends Error {
+    constructor() {
+        super([
+            "Not linking yet: SomaCheck cannot safely write its private token configuration on this computer.",
+            "Fix permissions for ~/.sensie, then run the link command again.",
+            "The pairing code has NOT been used.",
+        ].join("\n"));
+        this.name = "LinkPersistenceError";
+    }
+}
 export async function linkAgent(code, dependencies) {
     const normalizedCode = code.trim();
     if (!normalizedCode) {
         throw new Error("Pairing code is required.");
     }
+    // Guard BEFORE redeem(). Redemption is the irreversible step -- a pairing code
+    // is single-use, so an agent running this inside its own sandbox spends the
+    // user's code and leaves them nothing to retry with. Checking afterwards would
+    // report the problem accurately and still have caused it.
+    const interactive = dependencies.isInteractive?.() ?? false;
+    if (!interactive && !dependencies.allowNonInteractive) {
+        throw new NonInteractiveLinkError();
+    }
+    await dependencies.preflight?.();
+    try {
+        await preflightConfigPersistence(dependencies.home);
+    }
+    catch {
+        throw new LinkPersistenceError();
+    }
     const token = await dependencies.redeem(normalizedCode);
     await writeConfig(dependencies.home, { token });
-    dependencies.output("SomaCheck is linked. Your agent can now call vibecheck.");
+    dependencies.output("SomaCheck pairing code redeemed on this computer.");
 }
 //# sourceMappingURL=link.js.map