@fieldwangai/agentflow 0.1.25

package/bin/lib/hub-publish.mjs

@@ -0,0 +1,159 @@
+/**
+ * agentflow publish <FlowName> [--title <title>] [--description <desc>] [--tags <t1,t2>]
+ *
+ * Reads flow.yaml (or zips the flow directory if scripts/ exists),
+ * uploads to Hub, and inserts the flow record.
+ */
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+import chalk from "chalk";
+import yaml from "js-yaml";
+import { log } from "./log.mjs";
+import {
+  getStoredSession,
+  getUserProfile,
+  uploadToStorage,
+  insertFlow,
+  findFlowByAuthorAndTitle,
+  updateFlow,
+  deleteStorageObject,
+} from "./hub.mjs";
+import { getFlowDir } from "./workspace.mjs";
+
+function slugify(text) {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 60);
+}
+
+function countNodes(yamlContent) {
+  try {
+    const doc = yaml.load(yamlContent);
+    if (doc?.nodes && Array.isArray(doc.nodes)) return doc.nodes.length;
+    if (doc?.pipeline?.nodes && Array.isArray(doc.pipeline.nodes)) return doc.pipeline.nodes.length;
+    return 0;
+  } catch {
+    return 0;
+  }
+}
+
+export async function hubPublish(workspaceRoot, argv) {
+  // Auth check
+  const session = await getStoredSession();
+  if (!session?.access_token) {
+    throw new Error("Not logged in. Run: agentflow login");
+  }
+  const user = await getUserProfile(session.access_token);
+  if (!user?.id) {
+    throw new Error("Session expired. Run: agentflow login");
+  }
+
+  // Parse args
+  const flowName = argv.find((a) => !a.startsWith("--"));
+  if (!flowName) {
+    throw new Error("Usage: agentflow publish <FlowName> [--title <title>] [--description <desc>] [--tags <t1,t2>]");
+  }
+
+  let titleOpt, descOpt, tagsOpt;
+  const titleIdx = argv.indexOf("--title");
+  if (titleIdx >= 0 && argv[titleIdx + 1]) titleOpt = argv[titleIdx + 1];
+  const descIdx = argv.indexOf("--description");
+  if (descIdx >= 0 && argv[descIdx + 1]) descOpt = argv[descIdx + 1];
+  const tagsIdx = argv.indexOf("--tags");
+  if (tagsIdx >= 0 && argv[tagsIdx + 1]) tagsOpt = argv[tagsIdx + 1];
+
+  // Find flow directory
+  const flowDir = getFlowDir(workspaceRoot, flowName);
+  if (!flowDir) {
+    throw new Error("Flow not found: " + flowName);
+  }
+
+  const flowYamlPath = path.join(flowDir, "flow.yaml");
+  if (!fs.existsSync(flowYamlPath)) {
+    throw new Error("flow.yaml not found in " + flowDir);
+  }
+
+  const yamlContent = fs.readFileSync(flowYamlPath, "utf8");
+  const nodeCount = countNodes(yamlContent);
+
+  // Auto-read metadata from flow.yaml
+  let flowDesc = null;
+  try {
+    const doc = yaml.load(yamlContent);
+    if (doc?.ui?.description) flowDesc = doc.ui.description;
+  } catch {}
+
+  const title = titleOpt || flowName;
+  const description = descOpt || flowDesc || null;
+  const tags = tagsOpt ? tagsOpt.split(",").map((s) => s.trim()).filter(Boolean) : [];
+
+  // Check if flow directory has scripts/ or other files beyond flow.yaml
+  const entries = fs.readdirSync(flowDir);
+  const hasExtras = entries.some((e) => e !== "flow.yaml" && e !== ".DS_Store");
+
+  // Check if this author already published a flow with this title — update instead of insert.
+  const existing = await findFlowByAuthorAndTitle(session.access_token, user.id, title);
+
+  let fileBuffer, fileKey, contentType;
+  const ext = hasExtras ? ".zip" : ".yaml";
+  const slug = existing?.slug || slugify(title) + "-" + Date.now().toString(36);
+  fileKey = `${user.id}/${slug}${ext}`;
+
+  if (hasExtras) {
+    log.info("Flow has scripts/extras — creating zip...");
+    const zipPath = path.join(flowDir, ".hub-upload.zip");
+    try {
+      execSync(`cd "${flowDir}" && zip -r "${zipPath}" . -x ".*"`, { stdio: "pipe" });
+      fileBuffer = fs.readFileSync(zipPath);
+      contentType = "application/zip";
+    } finally {
+      try { fs.unlinkSync(zipPath); } catch {}
+    }
+  } else {
+    fileBuffer = Buffer.from(yamlContent, "utf8");
+    contentType = "text/yaml";
+  }
+
+  // Updating：先删老 artifact 再 INSERT 新文件。
+  // Supabase Storage 的 bucket 策略多数只放行 INSERT；x-upsert=true 走 UPDATE 路径
+  // 会被拒成 "new row violates row-level security policy"。DELETE + INSERT 最稳：
+  // 不论扩展名是否变，老对象先清掉，再走纯 INSERT。
+  if (existing && existing.yaml_key) {
+    log.info("Removing old artifact: " + existing.yaml_key);
+    await deleteStorageObject(session.access_token, existing.yaml_key);
+  }
+
+  log.info("Uploading " + (hasExtras ? "zip" : "flow.yaml") + " (" + (fileBuffer.length / 1024).toFixed(1) + " KB)...");
+  await uploadToStorage(session.access_token, fileKey, fileBuffer, contentType);
+
+  if (existing) {
+    log.info("Updating existing flow record...");
+    await updateFlow(session.access_token, existing.id, {
+      description,
+      tags,
+      yaml_key: fileKey,
+      node_count: nodeCount,
+    });
+    log.info(chalk.green("✓") + " Updated: " + chalk.bold(title));
+  } else {
+    log.info("Publishing flow record...");
+    await insertFlow(session.access_token, {
+      slug,
+      author_id: user.id,
+      title,
+      description,
+      tags,
+      yaml_key: fileKey,
+      node_count: nodeCount,
+    });
+    log.info(chalk.green("✓") + " Published: " + chalk.bold(title));
+  }
+
+  log.info("  slug: " + slug);
+  log.info("  nodes: " + nodeCount);
+  if (hasExtras) log.info("  type: zip (includes scripts)");
+  log.info("  " + chalk.dim("View at: https://agentflow-hub.com/flows/" + slug));
+}

package/bin/lib/hub-remote.mjs

@@ -0,0 +1,189 @@
+/**
+ * agentflow list-remote [--search <query>] [--sort popular|trending] [--json]
+ * agentflow download <slug|title> [--as <flowId>] [--raw [--output <dir>]]
+ */
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+import { log } from "./log.mjs";
+import { Table } from "./table.mjs";
+import { queryFlows, queryFlowBySlug, downloadFlowFile, incrementDownload } from "./hub.mjs";
+import {
+  unzipAndNormalizePipelineZip,
+  suggestFlowIdFromZip,
+  writePipelineTree,
+  validateImportedFlowYaml,
+} from "./flow-import.mjs";
+import { resolveFlowDirForWrite, validateUserPipelineId } from "./flow-write.mjs";
+
+export async function hubListRemote(argv) {
+  let search = "";
+  let sort = "popular";
+  const jsonMode = argv.includes("--json");
+
+  const searchIdx = argv.indexOf("--search");
+  if (searchIdx >= 0 && argv[searchIdx + 1]) search = argv[searchIdx + 1];
+  const sortIdx = argv.indexOf("--sort");
+  if (sortIdx >= 0 && argv[sortIdx + 1]) sort = argv[sortIdx + 1];
+
+  const flows = await queryFlows({ sort, search });
+
+  if (jsonMode) {
+    process.stdout.write(JSON.stringify(flows) + "\n");
+    return;
+  }
+
+  if (flows.length === 0) {
+    log.info("No flows found." + (search ? " (search: " + search + ")" : ""));
+    return;
+  }
+
+  const table = new Table({
+    head: ["Slug", "Title", "Author", "Downloads", "Nodes", "Tags"],
+    style: { head: [] },
+  });
+
+  for (const f of flows) {
+    table.push([
+      f.slug,
+      (f.title || "").slice(0, 30),
+      f.profiles?.username || "-",
+      String(f.downloads || 0),
+      String(f.node_count || 0),
+      (f.tags || []).join(", "),
+    ]);
+  }
+
+  log.info("\n" + chalk.bold("AgentFlow Hub — " + (sort === "trending" ? "Trending" : "Popular")) + "\n");
+  log.info(table.toString());
+  log.info("\n" + chalk.dim("Download: agentflow download <slug>"));
+}
+
+/**
+ * Derive a filesystem-safe user pipeline id from a free-form string.
+ * Replaces non-alnum with underscore, strips leading digits/underscores/hyphens.
+ * Returns null if nothing usable remains.
+ * @param {string} s
+ * @returns {string | null}
+ */
+function sanitizeToPipelineId(s) {
+  if (!s || typeof s !== "string") return null;
+  const cleaned = s.trim().replace(/[^a-zA-Z0-9_-]+/g, "_").replace(/^[-_]+|[-_]+$/g, "");
+  if (!cleaned) return null;
+  const leadDigitsStripped = cleaned.replace(/^[0-9]+/, "");
+  const candidate = leadDigitsStripped || "flow_" + cleaned;
+  const v = validateUserPipelineId(candidate);
+  return v.ok ? v.flowId : null;
+}
+
+export async function hubDownload(argv) {
+  const positional = argv.find((a) => !a.startsWith("--"));
+  if (!positional) {
+    throw new Error(
+      "Usage: agentflow download <slug|title> [--user|--workspace] [--as <flowId>] [--raw [--output <dir>]]",
+    );
+  }
+
+  const raw = argv.includes("--raw");
+  let outputDir = process.cwd();
+  const outIdx = argv.indexOf("--output");
+  if (outIdx >= 0 && argv[outIdx + 1]) outputDir = path.resolve(argv[outIdx + 1]);
+
+  let overrideId = null;
+  const asIdx = argv.indexOf("--as");
+  if (asIdx >= 0 && argv[asIdx + 1]) overrideId = argv[asIdx + 1];
+
+  const wantWorkspace = argv.includes("--workspace");
+  const wantUser = argv.includes("--user");
+  if (wantWorkspace && wantUser) {
+    throw new Error("--user and --workspace are mutually exclusive");
+  }
+  const flowSource = wantWorkspace ? "workspace" : "user";
+
+  log.info("Looking up flow: " + chalk.bold(positional) + "...");
+  const flow = await queryFlowBySlug(positional);
+  if (!flow) {
+    throw new Error("Flow not found: " + positional);
+  }
+
+  log.info("Downloading " + chalk.bold(flow.title) + " (" + flow.node_count + " nodes)...");
+  const buffer = await downloadFlowFile(flow.yaml_key);
+  const isZip = flow.yaml_key.endsWith(".zip");
+  await incrementDownload(flow.slug);
+
+  // ─── Raw mode: just save the artifact to outputDir. ───
+  if (raw) {
+    const ext = isZip ? ".zip" : ".yaml";
+    const filename = flow.slug + ext;
+    const outputPath = path.join(outputDir, filename);
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.writeFileSync(outputPath, buffer);
+    log.info(chalk.green("✓") + " Saved: " + outputPath + " (" + (buffer.length / 1024).toFixed(1) + " KB)");
+    if (isZip) {
+      log.info(chalk.dim("  Unzip to use: unzip " + filename + " -d " + flow.slug));
+    }
+    return;
+  }
+
+  // ─── Default: install into pipelines dir (user or workspace). ───
+  let files;
+  if (isZip) {
+    const un = unzipAndNormalizePipelineZip(buffer);
+    if (!un.ok) throw new Error("Unzip failed: " + un.error);
+    files = un.files;
+  } else {
+    const text = buffer.toString("utf8");
+    const v = validateImportedFlowYaml(text);
+    if (!v.ok) throw new Error("Invalid flow.yaml: " + v.error);
+    files = new Map([["flow.yaml", buffer]]);
+  }
+
+  // ─── Determine target flowId. ───
+  const candidates = [];
+  if (overrideId) candidates.push(overrideId);
+  if (isZip) {
+    const s = suggestFlowIdFromZip(buffer);
+    if (s.ok && s.suggestedFlowId) candidates.push(s.suggestedFlowId);
+  }
+  const fromTitle = sanitizeToPipelineId(flow.title);
+  if (fromTitle) candidates.push(fromTitle);
+  const fromSlug = sanitizeToPipelineId(flow.slug);
+  if (fromSlug) candidates.push(fromSlug);
+
+  let flowId = null;
+  let lastError = null;
+  for (const c of candidates) {
+    const v = validateUserPipelineId(c);
+    if (!v.ok) {
+      lastError = v.error;
+      continue;
+    }
+    flowId = v.flowId;
+    break;
+  }
+  if (!flowId) {
+    throw new Error("Could not derive a valid pipeline id" + (lastError ? ": " + lastError : ""));
+  }
+
+  const res = writePipelineTree(process.cwd(), flowId, flowSource, files);
+  if (!res.success) {
+    if (/已存在/.test(res.error || "")) {
+      throw new Error(
+        "Target pipeline already exists: " + flowId +
+          ". Use `--as <newId>` to install under a different name, or `--raw` to just save the file.",
+      );
+    }
+    throw new Error("Install failed: " + res.error);
+  }
+
+  const dirInfo = resolveFlowDirForWrite(process.cwd(), flowId, flowSource);
+  const scopeLabel = flowSource === "workspace" ? "workspace" : "user";
+  log.info(
+    chalk.green("✓") + " Installed [" + scopeLabel + "]: " + chalk.bold(flowId) +
+      "  (" + (buffer.length / 1024).toFixed(1) + " KB)",
+  );
+  if (dirInfo.flowDir) {
+    log.info(chalk.dim("  Path: " + dirInfo.flowDir));
+  }
+  log.info(chalk.dim("  Run with: agentflow apply " + flowId));
+}

package/bin/lib/hub.mjs

@@ -0,0 +1,299 @@
+/**
+ * AgentFlow Hub — Supabase client, token persistence, and shared helpers.
+ */
+import fs from "fs";
+import http from "http";
+import os from "os";
+import path from "path";
+import { spawn } from "child_process";
+import { log } from "./log.mjs";
+import { t } from "./i18n.mjs";
+
+const HUB_URL = "https://hvgnpjuiumxtymksqgki.supabase.co";
+const HUB_ANON_KEY = "sb_publishable_DIiFQno26UCIsN24Xpiotw_MxIwWCb8";
+
+function hubConfigPath() {
+  return path.join(os.homedir(), ".agentflow", "hub.json");
+}
+
+function readHubConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(hubConfigPath(), "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeHubConfig(config) {
+  const dir = path.dirname(hubConfigPath());
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(hubConfigPath(), JSON.stringify(config, null, 2));
+}
+
+/**
+ * Create a Supabase-like REST client (no dependency needed).
+ * Uses fetch() against PostgREST and Storage endpoints.
+ */
+function supabaseHeaders(accessToken) {
+  const headers = {
+    apikey: HUB_ANON_KEY,
+    "Content-Type": "application/json",
+  };
+  if (accessToken) {
+    headers.Authorization = "Bearer " + accessToken;
+  } else {
+    headers.Authorization = "Bearer " + HUB_ANON_KEY;
+  }
+  return headers;
+}
+
+// ──── Public REST helpers ────
+
+export async function queryFlows({ sort = "popular", search = "", limit = 50 } = {}) {
+  const order = sort === "trending" ? "created_at.desc" : "downloads.desc";
+  let url = `${HUB_URL}/rest/v1/flows?select=*,profiles!flows_author_id_fkey(username)&published=eq.true&order=${order}&limit=${limit}`;
+  if (search) {
+    url += `&title=ilike.*${encodeURIComponent(search)}*`;
+  }
+  const res = await fetch(url, { headers: supabaseHeaders() });
+  if (!res.ok) throw new Error("Hub query failed: " + res.status);
+  return res.json();
+}
+
+export async function queryFlowBySlug(slug) {
+  const baseSelect = `select=*,profiles!flows_author_id_fkey(username)`;
+  const bySlug = `${HUB_URL}/rest/v1/flows?${baseSelect}&slug=eq.${encodeURIComponent(slug)}&limit=1`;
+  const slugRes = await fetch(bySlug, { headers: supabaseHeaders() });
+  if (!slugRes.ok) throw new Error("Hub query failed: " + slugRes.status);
+  const slugData = await slugRes.json();
+  if (slugData[0]) return slugData[0];
+
+  // Fallback: exact title match (case-insensitive) among published flows.
+  // If multiple share the same title, pick the most downloaded.
+  const titleEsc = encodeURIComponent(slug.replace(/[,%*()]/g, ""));
+  const byTitle = `${HUB_URL}/rest/v1/flows?${baseSelect}&published=eq.true&title=ilike.${titleEsc}&order=downloads.desc&limit=1`;
+  const titleRes = await fetch(byTitle, { headers: supabaseHeaders() });
+  if (!titleRes.ok) throw new Error("Hub query failed: " + titleRes.status);
+  const titleData = await titleRes.json();
+  return titleData[0] || null;
+}
+
+export async function downloadFlowFile(yamlKey) {
+  const url = `${HUB_URL}/storage/v1/object/public/flows/${encodeURIComponent(yamlKey)}`;
+  const res = await fetch(url);
+  if (!res.ok) throw new Error("Download failed: " + res.status);
+  return Buffer.from(await res.arrayBuffer());
+}
+
+export async function incrementDownload(slug) {
+  const url = `${HUB_URL}/rest/v1/rpc/increment_download`;
+  await fetch(url, {
+    method: "POST",
+    headers: supabaseHeaders(),
+    body: JSON.stringify({ flow_slug: slug }),
+  }).catch(() => {});
+}
+
+// ──── Auth (login) ────
+
+export async function getStoredSession() {
+  const config = readHubConfig();
+  if (!config?.access_token) return null;
+  // Try refresh if expired
+  if (config.expires_at && Date.now() / 1000 > config.expires_at - 60) {
+    const refreshed = await refreshSession(config.refresh_token);
+    if (refreshed) return refreshed;
+    return null;
+  }
+  return config;
+}
+
+async function refreshSession(refreshToken) {
+  if (!refreshToken) return null;
+  const url = `${HUB_URL}/auth/v1/token?grant_type=refresh_token`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { apikey: HUB_ANON_KEY, "Content-Type": "application/json" },
+    body: JSON.stringify({ refresh_token: refreshToken }),
+  });
+  if (!res.ok) return null;
+  const data = await res.json();
+  const config = {
+    access_token: data.access_token,
+    refresh_token: data.refresh_token,
+    user_id: data.user?.id,
+    expires_at: Math.floor(Date.now() / 1000) + (data.expires_in || 3600),
+  };
+  writeHubConfig(config);
+  return config;
+}
+
+/**
+ * Login via OAuth: opens browser → captures token via localhost callback.
+ */
+export async function loginWithBrowser(provider = "github") {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer();
+    server.listen(0, "127.0.0.1", () => {
+      const port = server.address().port;
+      const redirectTo = `http://127.0.0.1:${port}/callback`;
+
+      // The callback page needs to extract hash fragment and send to server
+      server.on("request", (req, res) => {
+        if (req.url === "/callback" || req.url?.startsWith("/callback?")) {
+          // Supabase returns tokens in hash fragment (#access_token=...)
+          // Serve a page that extracts hash and POSTs it
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`<!DOCTYPE html><html><body>
+<script>
+const h = window.location.hash.substring(1);
+if (h) {
+  fetch('/token', { method: 'POST', headers: {'Content-Type': 'application/json'}, body: JSON.stringify(Object.fromEntries(new URLSearchParams(h))) })
+    .then(() => { document.body.innerHTML = '<h2>Login successful! You can close this tab.</h2>'; });
+} else {
+  document.body.innerHTML = '<h2>Login failed. No token received.</h2>';
+}
+</script>
+<p>Processing login...</p></body></html>`);
+          return;
+        }
+
+        if (req.url === "/token" && req.method === "POST") {
+          let body = "";
+          req.on("data", (c) => (body += c));
+          req.on("end", () => {
+            res.writeHead(200);
+            res.end("ok");
+            server.close();
+            try {
+              const data = JSON.parse(body);
+              if (!data.access_token) {
+                reject(new Error("No access_token in response"));
+                return;
+              }
+              const config = {
+                access_token: data.access_token,
+                refresh_token: data.refresh_token || null,
+                user_id: null,
+                expires_at: data.expires_in
+                  ? Math.floor(Date.now() / 1000) + parseInt(data.expires_in, 10)
+                  : null,
+              };
+              writeHubConfig(config);
+              resolve(config);
+            } catch (e) {
+              reject(e);
+            }
+          });
+          return;
+        }
+
+        res.writeHead(404);
+        res.end("Not found");
+      });
+
+      // Open browser to Supabase OAuth
+      const authUrl =
+        `${HUB_URL}/auth/v1/authorize?provider=${provider}&redirect_to=${encodeURIComponent(redirectTo)}`;
+
+      log.info("Opening browser for " + provider + " login...");
+      openBrowser(authUrl);
+
+      // Timeout after 120 seconds
+      setTimeout(() => {
+        server.close();
+        reject(new Error("Login timed out (120s). Try again."));
+      }, 120_000);
+    });
+  });
+}
+
+function openBrowser(url) {
+  if (process.platform === "darwin") {
+    spawn("open", [url], { detached: true, stdio: "ignore" }).unref();
+  } else if (process.platform === "win32") {
+    spawn("cmd", ["/c", "start", "", url], { detached: true, stdio: "ignore" }).unref();
+  } else {
+    spawn("xdg-open", [url], { detached: true, stdio: "ignore" }).unref();
+  }
+}
+
+// ──── Upload (publish) ────
+
+export async function uploadToStorage(accessToken, fileKey, buffer, contentType) {
+  const url = `${HUB_URL}/storage/v1/object/flows/${fileKey}`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      apikey: HUB_ANON_KEY,
+      Authorization: "Bearer " + accessToken,
+      "Content-Type": contentType,
+      "x-upsert": "true",
+    },
+    body: buffer,
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error("Storage upload failed: " + res.status + " " + text);
+  }
+  return res.json();
+}
+
+export async function insertFlow(accessToken, flowData) {
+  const url = `${HUB_URL}/rest/v1/flows`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { ...supabaseHeaders(accessToken), Prefer: "return=representation" },
+    body: JSON.stringify(flowData),
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error("Insert failed: " + res.status + " " + text);
+  }
+  return res.json();
+}
+
+export async function findFlowByAuthorAndTitle(accessToken, authorId, title) {
+  const url = `${HUB_URL}/rest/v1/flows?select=*&author_id=eq.${encodeURIComponent(authorId)}&title=eq.${encodeURIComponent(title)}&limit=1`;
+  const res = await fetch(url, { headers: supabaseHeaders(accessToken) });
+  if (!res.ok) return null;
+  const data = await res.json();
+  return data[0] || null;
+}
+
+export async function updateFlow(accessToken, flowId, patch) {
+  const url = `${HUB_URL}/rest/v1/flows?id=eq.${encodeURIComponent(flowId)}`;
+  const res = await fetch(url, {
+    method: "PATCH",
+    headers: { ...supabaseHeaders(accessToken), Prefer: "return=representation" },
+    body: JSON.stringify(patch),
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error("Update failed: " + res.status + " " + text);
+  }
+  return res.json();
+}
+
+export async function deleteStorageObject(accessToken, fileKey) {
+  const url = `${HUB_URL}/storage/v1/object/flows/${fileKey}`;
+  const res = await fetch(url, {
+    method: "DELETE",
+    headers: {
+      apikey: HUB_ANON_KEY,
+      Authorization: "Bearer " + accessToken,
+    },
+  });
+  return res.ok;
+}
+
+export async function getUserProfile(accessToken) {
+  const url = `${HUB_URL}/auth/v1/user`;
+  const res = await fetch(url, {
+    headers: { apikey: HUB_ANON_KEY, Authorization: "Bearer " + accessToken },
+  });
+  if (!res.ok) return null;
+  return res.json();
+}
+
+export { HUB_URL };