@agentlink.sh/cli 0.10.0

package/dist/chunk-DOWH47I5.js

@@ -0,0 +1,592 @@
+#!/usr/bin/env node
+import {
+  amber,
+  blue,
+  bold,
+  dim,
+  link,
+  red,
+  sb
+} from "./chunk-G3HVUCWY.js";
+
+// src/cloud.ts
+import { execSync as execSync2 } from "child_process";
+import fs2 from "fs";
+import os from "os";
+import path from "path";
+import { confirm, input, select } from "@inquirer/prompts";
+
+// src/utils.ts
+import { execSync, spawn } from "child_process";
+import crypto from "crypto";
+import fs from "fs";
+var LOG_FILE = "agentlink-debug.log";
+var debugEnabled = false;
+var logInitialized = false;
+function ensureLogFile() {
+  if (!logInitialized) {
+    fs.writeFileSync(LOG_FILE, "");
+    logInitialized = true;
+  }
+}
+function appendLog(msg, force = false) {
+  if (!debugEnabled && !force) return;
+  ensureLogFile();
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  fs.appendFileSync(LOG_FILE, `[${timestamp}] ${msg}
+`);
+}
+function initLog(debug) {
+  debugEnabled = debug;
+  if (debug) {
+    ensureLogFile();
+  }
+}
+function runCommand(cmd, cwd, onData, env) {
+  appendLog(`$ ${cmd}${cwd ? ` (in ${cwd})` : ""}`);
+  return new Promise((resolve, reject) => {
+    const child = spawn("sh", ["-c", cmd], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: env ? { ...process.env, ...env } : void 0
+    });
+    const stdout = [];
+    const stderr = [];
+    child.stdout.on("data", (data) => {
+      const text = data.toString();
+      stdout.push(text);
+      if (onData) {
+        for (const line of text.split("\n").filter(Boolean)) {
+          onData(line.trim());
+        }
+      }
+    });
+    child.stderr.on("data", (data) => {
+      const text = data.toString();
+      stderr.push(text);
+      if (onData) {
+        for (const line of text.split("\n").filter(Boolean)) {
+          onData(line.trim());
+        }
+      }
+    });
+    child.on("close", (code) => {
+      const out = stdout.join("").trim();
+      const errOut = stderr.join("").trim();
+      if (out) appendLog(out);
+      if (errOut) appendLog(`STDERR: ${errOut}`);
+      if (code !== 0) {
+        appendLog(`$ ${cmd}${cwd ? ` (in ${cwd})` : ""}`, true);
+        appendLog(`EXIT CODE ${code}`, true);
+        if (errOut) appendLog(`STDERR: ${errOut}`, true);
+        const detail = errOut;
+        const msg = detail ? `Command failed: ${cmd}
+${detail}` : `Command failed: ${cmd}`;
+        reject(new Error(msg));
+      } else {
+        resolve(out);
+      }
+    });
+    child.on("error", (err) => {
+      appendLog(`$ ${cmd}${cwd ? ` (in ${cwd})` : ""}`, true);
+      appendLog(`SPAWN ERROR: ${err.message}`, true);
+      reject(
+        new Error(`Command failed: ${cmd}
+${err.message}`)
+      );
+    });
+  });
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function checkCommand(cmd) {
+  try {
+    execSync(`which ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function skillDisplayName(skill) {
+  if (skill.includes("@")) return skill.split("@").pop();
+  const flag = skill.match(/--skill\s+(\S+)/);
+  if (flag) return flag[1];
+  return skill.split("/").pop();
+}
+function generateDbPassword(length = 32) {
+  const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+  const bytes = crypto.randomBytes(length);
+  return Array.from(bytes, (b) => chars[b % chars.length]).join("");
+}
+function validateProjectName(name, mode = "new") {
+  if (!name) return "Project name is required.";
+  if (/\s/.test(name)) return "Project name cannot contain spaces.";
+  if (!/^[a-zA-Z0-9._-]+$/.test(name))
+    return "Project name can only contain letters, numbers, hyphens, dots, and underscores.";
+  if (mode === "new" && fs.existsSync(name))
+    return `Directory "${name}" already exists.`;
+  return void 0;
+}
+
+// src/cloud.ts
+var theme = {
+  prefix: { idle: blue("?"), done: blue("\u2714") },
+  style: {
+    answer: (text) => amber(text),
+    message: (text) => bold(text),
+    error: (text) => red(`> ${text}`),
+    help: (text) => dim(text),
+    highlight: (text) => blue(text),
+    key: (text) => blue(bold(`<${text}>`))
+  }
+};
+function credentialsPath() {
+  return path.join(os.homedir(), ".config", "agentlink", "credentials.json");
+}
+function loadCredentials() {
+  try {
+    return JSON.parse(fs2.readFileSync(credentialsPath(), "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveCredentials(creds) {
+  const filePath = credentialsPath();
+  fs2.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs2.writeFileSync(filePath, JSON.stringify(creds, null, 2) + "\n", { mode: 384 });
+}
+async function ensureAccessToken(nonInteractive, projectDir) {
+  if (process.env.SUPABASE_ACCESS_TOKEN) return;
+  if (projectDir) {
+    const envPath = path.join(projectDir, ".env.local");
+    if (fs2.existsSync(envPath)) {
+      const content = fs2.readFileSync(envPath, "utf-8");
+      const match = content.match(/^SUPABASE_ACCESS_TOKEN=(.+)$/m);
+      if (match?.[1]) {
+        let val = match[1].trim();
+        if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+          val = val.slice(1, -1);
+        }
+        process.env.SUPABASE_ACCESS_TOKEN = val;
+        return;
+      }
+    }
+  }
+  const creds = loadCredentials();
+  if (creds.oauth) {
+    if (creds.oauth.expires_at > Date.now() / 1e3 + 60) {
+      process.env.SUPABASE_ACCESS_TOKEN = creds.oauth.access_token;
+      return;
+    }
+    if (creds.oauth.refresh_token) {
+      try {
+        const { refreshOAuthToken } = await import("./oauth-J4X62CY4.js");
+        const tokens = await refreshOAuthToken(creds.oauth.refresh_token);
+        const updated = {
+          ...creds,
+          oauth: {
+            access_token: tokens.access_token,
+            refresh_token: tokens.refresh_token,
+            expires_at: Math.floor(Date.now() / 1e3) + tokens.expires_in
+          }
+        };
+        saveCredentials(updated);
+        process.env.SUPABASE_ACCESS_TOKEN = tokens.access_token;
+        return;
+      } catch {
+      }
+    }
+  }
+  if (creds.supabase_access_token) {
+    process.env.SUPABASE_ACCESS_TOKEN = creds.supabase_access_token;
+    const masked = creds.supabase_access_token.slice(0, 8) + "..." + creds.supabase_access_token.slice(-4);
+    console.log(`  ${blue("\u25CF")} Existing access token found ${dim(`(source: ${credentialsPath()})`)}`);
+    console.log(`  ${dim(masked)}`);
+    console.log();
+    if (!nonInteractive) {
+      const replace = await confirm({
+        message: "Use stored token?",
+        default: true,
+        theme
+      });
+      if (replace) return;
+      delete process.env.SUPABASE_ACCESS_TOKEN;
+    } else {
+      return;
+    }
+  }
+  if (nonInteractive) {
+    throw new Error(
+      "SUPABASE_ACCESS_TOKEN is required for cloud mode.\n  Set it via --token, SUPABASE_ACCESS_TOKEN env var, or run `agentlink login`."
+    );
+  }
+  const method = await select({
+    message: "How would you like to authenticate?",
+    theme,
+    choices: [
+      { name: "Login with Supabase (opens browser)", value: "oauth" },
+      { name: "Enter access token manually", value: "manual" }
+    ]
+  });
+  if (method === "oauth") {
+    const { oauthLogin } = await import("./oauth-J4X62CY4.js");
+    const tokens = await oauthLogin();
+    process.env.SUPABASE_ACCESS_TOKEN = tokens.access_token;
+    saveCredentials({
+      ...loadCredentials(),
+      oauth: {
+        access_token: tokens.access_token,
+        refresh_token: tokens.refresh_token,
+        expires_at: Math.floor(Date.now() / 1e3) + tokens.expires_in
+      }
+    });
+    console.log(`  ${blue("\u2714")} Authenticated via Supabase OAuth`);
+    console.log(`  ${dim("Token stored at " + credentialsPath())}`);
+    console.log();
+    return;
+  }
+  const tokenUrl = "https://supabase.com/dashboard/account/tokens";
+  try {
+    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    execSync2(`${cmd} ${JSON.stringify(tokenUrl)}`, { stdio: "ignore" });
+    console.log(`  ${blue("\u25CF")} Opened ${link(tokenUrl)}`);
+  } catch {
+    console.log(`  ${amber("Could not open browser.")} Visit: ${link(tokenUrl)}`);
+  }
+  console.log();
+  const token = await input({
+    message: "Enter your Supabase access token:",
+    theme,
+    transformer: (value, { isFinal }) => {
+      if (isFinal) {
+        const t = value.trim();
+        return t.length > 12 ? t.slice(0, 8) + "\u25CF".repeat(t.length - 12) + t.slice(-4) : "\u25CF".repeat(t.length);
+      }
+      return "\u25CF".repeat(value.length);
+    },
+    validate: (val) => val.trim().length > 0 || "Token is required"
+  });
+  const trimmed = token.trim();
+  process.env.SUPABASE_ACCESS_TOKEN = trimmed;
+  saveCredentials({ ...loadCredentials(), supabase_access_token: trimmed });
+  console.log(`  ${blue("\u25CF")} Token stored at ${dim(credentialsPath())}`);
+  console.log();
+  saveTokenToEnvLocal(trimmed, projectDir);
+}
+function saveTokenToEnvLocal(token, projectDir) {
+  if (!projectDir) return;
+  const envPath = path.join(projectDir, ".env.local");
+  if (fs2.existsSync(envPath)) {
+    let content = fs2.readFileSync(envPath, "utf-8");
+    if (/^SUPABASE_ACCESS_TOKEN=/m.test(content)) {
+      content = content.replace(/^SUPABASE_ACCESS_TOKEN=.*$/m, `SUPABASE_ACCESS_TOKEN=${token}`);
+    } else {
+      content = content.trimEnd() + `
+SUPABASE_ACCESS_TOKEN=${token}
+`;
+    }
+    fs2.writeFileSync(envPath, content);
+  } else {
+    fs2.writeFileSync(envPath, `SUPABASE_ACCESS_TOKEN=${token}
+`);
+  }
+}
+var REGIONS = [
+  { id: "us-east-1", name: "US East (N. Virginia)" },
+  { id: "us-east-2", name: "US East (Ohio)" },
+  { id: "us-west-1", name: "US West (N. California)" },
+  { id: "us-west-2", name: "US West (Oregon)" },
+  { id: "ca-central-1", name: "Canada (Central)" },
+  { id: "sa-east-1", name: "South America (S\xE3o Paulo)" },
+  { id: "eu-west-1", name: "EU West (Ireland)" },
+  { id: "eu-west-2", name: "EU West (London)" },
+  { id: "eu-west-3", name: "EU West (Paris)" },
+  { id: "eu-central-1", name: "EU Central (Frankfurt)" },
+  { id: "eu-central-2", name: "EU Central (Zurich)" },
+  { id: "eu-north-1", name: "EU North (Stockholm)" },
+  { id: "ap-southeast-1", name: "Asia Pacific (Singapore)" },
+  { id: "ap-southeast-2", name: "Asia Pacific (Sydney)" },
+  { id: "ap-northeast-1", name: "Asia Pacific (Tokyo)" },
+  { id: "ap-south-1", name: "Asia Pacific (Mumbai)" }
+];
+async function listOrganizations() {
+  const out = await runCommand(`${sb()} orgs list -o json`);
+  return JSON.parse(out);
+}
+function listRegions() {
+  return REGIONS;
+}
+function detectClosestRegion() {
+  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone ?? "";
+  const cityMap = {
+    "America/New_York": "us-east-1",
+    "America/Toronto": "us-east-1",
+    "America/Detroit": "us-east-1",
+    "America/Chicago": "us-east-2",
+    "America/Denver": "us-west-2",
+    "America/Phoenix": "us-west-2",
+    "America/Los_Angeles": "us-west-1",
+    "America/Vancouver": "us-west-1",
+    "America/Edmonton": "ca-central-1",
+    "America/Winnipeg": "ca-central-1",
+    "America/Sao_Paulo": "sa-east-1",
+    "America/Argentina/Buenos_Aires": "sa-east-1",
+    "America/Bogota": "sa-east-1",
+    "America/Lima": "sa-east-1",
+    "America/Santiago": "sa-east-1",
+    "America/Mexico_City": "us-east-1",
+    "Europe/London": "eu-west-2",
+    "Europe/Dublin": "eu-west-1",
+    "Europe/Paris": "eu-west-3",
+    "Europe/Madrid": "eu-west-3",
+    "Europe/Rome": "eu-west-3",
+    "Europe/Brussels": "eu-west-3",
+    "Europe/Berlin": "eu-central-1",
+    "Europe/Amsterdam": "eu-central-1",
+    "Europe/Vienna": "eu-central-1",
+    "Europe/Zurich": "eu-central-2",
+    "Europe/Stockholm": "eu-north-1",
+    "Europe/Helsinki": "eu-north-1",
+    "Europe/Oslo": "eu-north-1",
+    "Europe/Warsaw": "eu-central-1",
+    "Asia/Tokyo": "ap-northeast-1",
+    "Asia/Seoul": "ap-northeast-1",
+    "Asia/Singapore": "ap-southeast-1",
+    "Asia/Kuala_Lumpur": "ap-southeast-1",
+    "Asia/Jakarta": "ap-southeast-1",
+    "Asia/Bangkok": "ap-southeast-1",
+    "Asia/Kolkata": "ap-south-1",
+    "Asia/Mumbai": "ap-south-1",
+    "Asia/Dubai": "ap-south-1",
+    "Australia/Sydney": "ap-southeast-2",
+    "Australia/Melbourne": "ap-southeast-2",
+    "Pacific/Auckland": "ap-southeast-2"
+  };
+  if (cityMap[tz]) return cityMap[tz];
+  if (tz.startsWith("America/")) return "us-east-1";
+  if (tz.startsWith("US/")) return "us-east-1";
+  if (tz.startsWith("Canada/")) return "ca-central-1";
+  if (tz.startsWith("Europe/")) return "eu-central-1";
+  if (tz.startsWith("Asia/")) return "ap-southeast-1";
+  if (tz.startsWith("Australia/") || tz.startsWith("Pacific/")) return "ap-southeast-2";
+  if (tz.startsWith("Africa/")) return "eu-west-3";
+  return "us-east-1";
+}
+async function listProjects() {
+  const out = await runCommand(`${sb()} projects list -o json`);
+  return JSON.parse(out) ?? [];
+}
+async function createProject(opts) {
+  const out = await runCommand(
+    `${sb()} projects create ${JSON.stringify(opts.name)} --org-id ${opts.orgId} --region ${opts.region} --db-password ${opts.dbPass} -o json`
+  );
+  return JSON.parse(out);
+}
+async function getProject(ref) {
+  const out = await runCommand(`${sb()} projects list -o json`);
+  const projects = JSON.parse(out);
+  const project = projects.find((p) => p.id === ref);
+  if (!project) {
+    throw new Error(`Project ${ref} not found`);
+  }
+  return project;
+}
+async function getApiKeys(ref) {
+  const token = process.env.SUPABASE_ACCESS_TOKEN;
+  if (!token) {
+    throw new Error("SUPABASE_ACCESS_TOKEN is required to fetch API keys");
+  }
+  const res = await fetch(
+    `https://api.supabase.com/v1/projects/${ref}/api-keys?reveal=true`,
+    {
+      headers: { Authorization: `Bearer ${token}` }
+    }
+  );
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Failed to fetch API keys (${res.status}): ${body}`);
+  }
+  const keys = await res.json();
+  const publishable = keys.find((k) => k.type === "publishable");
+  const secret = keys.find((k) => k.type === "secret");
+  if (!publishable?.api_key || !secret?.api_key) {
+    throw new Error("Could not find publishable/secret API keys for project");
+  }
+  return { publishableKey: publishable.api_key, secretKey: secret.api_key };
+}
+async function runCloudSQL(sql, projectRef) {
+  const token = process.env.SUPABASE_ACCESS_TOKEN;
+  if (!token) {
+    throw new Error("SUPABASE_ACCESS_TOKEN is required for cloud SQL execution");
+  }
+  const res = await fetch(
+    `https://api.supabase.com/v1/projects/${projectRef}/database/query`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ query: sql })
+    }
+  );
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Cloud SQL query failed (${res.status}): ${body}`);
+  }
+  const rows = await res.json();
+  if (!Array.isArray(rows) || rows.length === 0) return "";
+  const firstValue = Object.values(rows[0])[0];
+  if (typeof firstValue === "object" && firstValue !== null) return JSON.stringify(firstValue);
+  return String(firstValue ?? "");
+}
+async function updatePostgrestConfig(projectRef, config) {
+  const token = process.env.SUPABASE_ACCESS_TOKEN;
+  if (!token) {
+    throw new Error("SUPABASE_ACCESS_TOKEN is required to update PostgREST config");
+  }
+  const res = await fetch(
+    `https://api.supabase.com/v1/projects/${projectRef}/postgrest`,
+    {
+      method: "PATCH",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(config)
+    }
+  );
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Failed to update PostgREST config (${res.status}): ${body}`);
+  }
+}
+async function updateAuthConfig(projectRef, config) {
+  const token = process.env.SUPABASE_ACCESS_TOKEN;
+  if (!token) {
+    throw new Error("SUPABASE_ACCESS_TOKEN is required to update auth config");
+  }
+  const res = await fetch(
+    `https://api.supabase.com/v1/projects/${projectRef}/config/auth`,
+    {
+      method: "PATCH",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(config)
+    }
+  );
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Failed to update auth config (${res.status}): ${body}`);
+  }
+}
+async function waitForProjectReady(ref, spinner, timeoutMs = 3e5) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const out = await runCommand(`${sb()} projects list -o json`);
+      const projects = JSON.parse(out);
+      const project = projects.find((p) => p.id === ref);
+      if (project?.status === "ACTIVE_HEALTHY") {
+        return project;
+      }
+      if (spinner && project) {
+        spinner.text = `Creating Supabase cloud project \u2014 status: ${project.status}`;
+      }
+    } catch {
+    }
+    await delay(5e3);
+  }
+  throw new Error(
+    `Project ${ref} did not become ready within ${timeoutMs / 1e3}s.
+  Check status at: https://supabase.com/dashboard/project/${ref}`
+  );
+}
+function saveProjectCredential(projectRef, dbPassword) {
+  const creds = loadCredentials();
+  if (!creds.project_credentials) {
+    creds.project_credentials = {};
+  }
+  creds.project_credentials[projectRef] = { db_password: dbPassword };
+  saveCredentials(creds);
+}
+function loadProjectCredential(projectRef) {
+  const creds = loadCredentials();
+  return creds.project_credentials?.[projectRef]?.db_password;
+}
+function resolveDbUrlForEnv(env, password) {
+  return `postgresql://postgres.${env.projectRef}:${encodeURIComponent(password)}@aws-0-${env.region}.pooler.supabase.com:5432/postgres`;
+}
+async function listSecrets(projectRef) {
+  const token = process.env.SUPABASE_ACCESS_TOKEN;
+  if (!token) {
+    throw new Error("SUPABASE_ACCESS_TOKEN is required to list secrets");
+  }
+  const res = await fetch(
+    `https://api.supabase.com/v1/projects/${projectRef}/secrets`,
+    {
+      headers: { Authorization: `Bearer ${token}` }
+    }
+  );
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Failed to list secrets (${res.status}): ${body}`);
+  }
+  const secrets = await res.json();
+  return secrets.map((s) => s.name);
+}
+async function setSecrets(projectRef, secrets) {
+  const token = process.env.SUPABASE_ACCESS_TOKEN;
+  if (!token) {
+    throw new Error("SUPABASE_ACCESS_TOKEN is required to set secrets");
+  }
+  const body = Object.entries(secrets).map(([name, value]) => ({ name, value }));
+  const res = await fetch(
+    `https://api.supabase.com/v1/projects/${projectRef}/secrets`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    }
+  );
+  if (!res.ok) {
+    const respBody = await res.text();
+    throw new Error(`Failed to set secrets (${res.status}): ${respBody}`);
+  }
+}
+
+export {
+  initLog,
+  runCommand,
+  delay,
+  checkCommand,
+  skillDisplayName,
+  generateDbPassword,
+  validateProjectName,
+  credentialsPath,
+  loadCredentials,
+  saveCredentials,
+  ensureAccessToken,
+  listOrganizations,
+  listRegions,
+  detectClosestRegion,
+  listProjects,
+  createProject,
+  getProject,
+  getApiKeys,
+  runCloudSQL,
+  updatePostgrestConfig,
+  updateAuthConfig,
+  waitForProjectReady,
+  saveProjectCredential,
+  loadProjectCredential,
+  resolveDbUrlForEnv,
+  listSecrets,
+  setSecrets
+};

package/dist/chunk-G3HVUCWY.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+// src/constants.ts
+import fs from "fs";
+import { createRequire } from "module";
+import path from "path";
+var require2 = createRequire(import.meta.url);
+var supabasePkg = require2("supabase/package.json");
+var SUPPORTED_SUPABASE_CLI = supabasePkg.version;
+var SKILLS_VERSION = "1.4.3";
+var OAUTH_CLIENT_ID = "d8996260-5912-4f7e-b114-3b542f20ae8b";
+var OAUTH_CLIENT_SECRET = "sba_3424fb2fb9766e08cbc85aa094843ff07f8328da";
+function supabaseBin() {
+  return path.join(
+    path.dirname(require2.resolve("supabase/package.json")),
+    "bin",
+    "supabase"
+  );
+}
+function sb() {
+  return JSON.stringify(supabaseBin());
+}
+function pgdeltaDir() {
+  const main = require2.resolve("@supabase/pg-delta");
+  return path.resolve(path.dirname(main), "..");
+}
+var pgdeltaPkg = JSON.parse(
+  fs.readFileSync(path.join(pgdeltaDir(), "package.json"), "utf-8")
+);
+var SUPPORTED_PGDELTA = pgdeltaPkg.version;
+function pgdeltaBin() {
+  return path.join(pgdeltaDir(), "dist", "cli", "bin", "cli.js");
+}
+function pgd() {
+  return JSON.stringify(pgdeltaBin());
+}
+
+// src/theme.ts
+var rgb = (r, g, b) => (s) => `\x1B[38;2;${r};${g};${b}m${s}\x1B[0m`;
+var blue = rgb(92, 184, 228);
+var amber = rgb(232, 168, 56);
+var red = rgb(239, 68, 68);
+var dim = (s) => `\x1B[2m${s}\x1B[0m`;
+var bold = (s) => `\x1B[1m${s}\x1B[0m`;
+var link = (url, label) => `\x1B]8;;${url}\x07${label ?? url}\x1B]8;;\x07`;
+
+export {
+  SUPPORTED_SUPABASE_CLI,
+  SKILLS_VERSION,
+  OAUTH_CLIENT_ID,
+  OAUTH_CLIENT_SECRET,
+  supabaseBin,
+  sb,
+  pgdeltaBin,
+  pgd,
+  blue,
+  amber,
+  red,
+  dim,
+  bold,
+  link
+};

package/dist/cloud-N7CILHLD.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import {
+  createProject,
+  credentialsPath,
+  detectClosestRegion,
+  ensureAccessToken,
+  getApiKeys,
+  getProject,
+  listOrganizations,
+  listProjects,
+  listRegions,
+  listSecrets,
+  loadCredentials,
+  loadProjectCredential,
+  resolveDbUrlForEnv,
+  runCloudSQL,
+  saveCredentials,
+  saveProjectCredential,
+  setSecrets,
+  updateAuthConfig,
+  updatePostgrestConfig,
+  waitForProjectReady
+} from "./chunk-DOWH47I5.js";
+import "./chunk-G3HVUCWY.js";
+export {
+  createProject,
+  credentialsPath,
+  detectClosestRegion,
+  ensureAccessToken,
+  getApiKeys,
+  getProject,
+  listOrganizations,
+  listProjects,
+  listRegions,
+  listSecrets,
+  loadCredentials,
+  loadProjectCredential,
+  resolveDbUrlForEnv,
+  runCloudSQL,
+  saveCredentials,
+  saveProjectCredential,
+  setSecrets,
+  updateAuthConfig,
+  updatePostgrestConfig,
+  waitForProjectReady
+};