@hanzogui/recipes 7.3.0

package/dist/admin.js

@@ -0,0 +1,95 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/config.ts
+var DEFAULT_BASE_URL = "https://base.hanzo.ai";
+var RECIPES_COLLECTION = "gui_recipes";
+var DEFAULT_INSTALL_DIR = "src/gui";
+var DEFAULT_CONFIG_FILENAMES = ["gui.config.json", ".guirc.json"];
+function resolveBaseUrl(override) {
+  return override ?? process.env.HANZO_BASE_URL ?? DEFAULT_BASE_URL;
+}
+
+// src/admin.ts
+async function authAdmin({ baseUrl, email, password }) {
+  const url = `${resolveBaseUrl(baseUrl)}/v1/base/admins/auth-with-password`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ identity: email, password })
+  });
+  if (!res.ok) {
+    throw new Error(`Admin auth failed: ${res.status} ${await res.text()}`);
+  }
+  const data = await res.json();
+  return data.token;
+}
+async function ensureCollection(auth) {
+  const base = resolveBaseUrl(auth.baseUrl);
+  const headers = { Authorization: auth.token, "Content-Type": "application/json" };
+  const probe = await fetch(`${base}/v1/base/collections/${RECIPES_COLLECTION}`, { headers });
+  if (probe.ok)
+    return "existed";
+  const schema = {
+    name: RECIPES_COLLECTION,
+    type: "base",
+    schema: [
+      { name: "slug", type: "text", required: true, unique: true, options: {} },
+      { name: "name", type: "text", required: true, options: {} },
+      { name: "description", type: "text", required: false, options: {} },
+      { name: "category", type: "text", required: false, options: {} },
+      { name: "npmDeps", type: "json", required: false, options: {} },
+      { name: "recipeDeps", type: "json", required: false, options: {} },
+      { name: "files", type: "json", required: true, options: {} }
+    ],
+    indexes: [`CREATE UNIQUE INDEX idx_${RECIPES_COLLECTION}_slug ON ${RECIPES_COLLECTION} (slug)`],
+    listRule: "",
+    viewRule: "",
+    createRule: null,
+    updateRule: null,
+    deleteRule: null
+  };
+  const res = await fetch(`${base}/v1/base/collections`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(schema)
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to create collection: ${res.status} ${await res.text()}`);
+  }
+  return "created";
+}
+async function findExisting(auth, slug) {
+  const base = resolveBaseUrl(auth.baseUrl);
+  const filter = encodeURIComponent(`slug="${slug}"`);
+  const res = await fetch(`${base}/v1/base/collections/${RECIPES_COLLECTION}/records?perPage=1&filter=${filter}`, { headers: { Authorization: auth.token } });
+  if (!res.ok)
+    return null;
+  const data = await res.json();
+  return data.items[0]?.id ?? null;
+}
+async function upsertRecipe(auth, recipe) {
+  const base = resolveBaseUrl(auth.baseUrl);
+  const headers = { Authorization: auth.token, "Content-Type": "application/json" };
+  const body = JSON.stringify(recipe);
+  const existing = await findExisting(auth, recipe.slug);
+  if (existing) {
+    const res2 = await fetch(`${base}/v1/base/collections/${RECIPES_COLLECTION}/records/${existing}`, { method: "PATCH", headers, body });
+    if (!res2.ok)
+      throw new Error(`PATCH ${recipe.slug}: ${res2.status} ${await res2.text()}`);
+    return "updated";
+  }
+  const res = await fetch(`${base}/v1/base/collections/${RECIPES_COLLECTION}/records`, {
+    method: "POST",
+    headers,
+    body
+  });
+  if (!res.ok)
+    throw new Error(`POST ${recipe.slug}: ${res.status} ${await res.text()}`);
+  return "created";
+}
+export {
+  upsertRecipe,
+  ensureCollection,
+  authAdmin
+};

package/dist/config.js

@@ -0,0 +1,18 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/config.ts
+var DEFAULT_BASE_URL = "https://base.hanzo.ai";
+var RECIPES_COLLECTION = "gui_recipes";
+var DEFAULT_INSTALL_DIR = "src/gui";
+var DEFAULT_CONFIG_FILENAMES = ["gui.config.json", ".guirc.json"];
+function resolveBaseUrl(override) {
+  return override ?? process.env.HANZO_BASE_URL ?? DEFAULT_BASE_URL;
+}
+export {
+  resolveBaseUrl,
+  RECIPES_COLLECTION,
+  DEFAULT_INSTALL_DIR,
+  DEFAULT_CONFIG_FILENAMES,
+  DEFAULT_BASE_URL
+};

package/dist/index.js

@@ -0,0 +1,225 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/config.ts
+var DEFAULT_BASE_URL = "https://base.hanzo.ai";
+var RECIPES_COLLECTION = "gui_recipes";
+var DEFAULT_INSTALL_DIR = "src/gui";
+var DEFAULT_CONFIG_FILENAMES = ["gui.config.json", ".guirc.json"];
+function resolveBaseUrl(override) {
+  return override ?? process.env.HANZO_BASE_URL ?? DEFAULT_BASE_URL;
+}
+
+// src/project.ts
+import { existsSync, promises as fs } from "node:fs";
+import path from "node:path";
+async function findProjectRoot(start = process.cwd()) {
+  let dir = start;
+  while (dir !== path.parse(dir).root) {
+    const pkgPath = path.join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(await fs.readFile(pkgPath, "utf8"));
+        if (pkg.workspaces || existsSync(path.join(dir, "pnpm-workspace.yaml")))
+          return dir;
+      } catch {}
+    }
+    if (existsSync(path.join(dir, ".git")))
+      return dir;
+    dir = path.dirname(dir);
+  }
+  return start;
+}
+async function readConfig(root) {
+  for (const name of DEFAULT_CONFIG_FILENAMES) {
+    const p = path.join(root, name);
+    if (existsSync(p)) {
+      try {
+        return JSON.parse(await fs.readFile(p, "utf8"));
+      } catch {}
+    }
+  }
+  return {};
+}
+function resolveInstallDir(root, config) {
+  return path.join(root, config.installDir ?? DEFAULT_INSTALL_DIR);
+}
+
+// src/write.ts
+import { existsSync as existsSync2, promises as fs2 } from "node:fs";
+import path2 from "node:path";
+async function getInstallDir(opts) {
+  if (opts.installDir)
+    return opts.installDir;
+  const root = await findProjectRoot(opts.cwd);
+  return resolveInstallDir(root, await readConfig(root));
+}
+async function installRecipe(recipe, opts = {}) {
+  const installDir = await getInstallDir(opts);
+  const written = [];
+  for (const file of recipe.files) {
+    const dest = path2.join(installDir, file.path);
+    const dir = path2.dirname(dest);
+    if (!existsSync2(dir))
+      await fs2.mkdir(dir, { recursive: true });
+    await fs2.writeFile(dest, file.source);
+    written.push(dest);
+  }
+  return written;
+}
+async function installPlan(plan, opts = {}) {
+  const written = [];
+  for (const r of [plan.recipe, ...plan.transitiveRecipes]) {
+    written.push(...await installRecipe(r, opts));
+  }
+  return written;
+}
+// src/read.ts
+async function getJSON(url) {
+  const res = await fetch(url, { headers: { Accept: "application/json" } });
+  if (!res.ok) {
+    throw Object.assign(new Error(`Base request failed: ${res.status} ${res.statusText}`), {
+      status: res.status
+    });
+  }
+  return await res.json();
+}
+function records(baseUrl) {
+  return `${resolveBaseUrl(baseUrl)}/v1/base/collections/${RECIPES_COLLECTION}/records`;
+}
+async function listRecipes(opts = {}) {
+  const url = `${records(opts.baseUrl)}?perPage=200&sort=name&fields=id,slug,name,description,category`;
+  const data = await getJSON(url);
+  return data.items;
+}
+async function getRecipe(slug, opts = {}) {
+  const filter = encodeURIComponent(`slug="${slug}"`);
+  const url = `${records(opts.baseUrl)}?perPage=1&filter=${filter}`;
+  const data = await getJSON(url);
+  const recipe = data.items[0];
+  if (!recipe) {
+    throw Object.assign(new Error(`Recipe not found: ${slug}`), { status: 404 });
+  }
+  return recipe;
+}
+async function resolveRecipe(slug, opts = {}) {
+  const seen = new Map;
+  const queue = [slug];
+  while (queue.length) {
+    const next = queue.shift();
+    if (seen.has(next))
+      continue;
+    const recipe2 = await getRecipe(next, opts);
+    seen.set(next, recipe2);
+    for (const dep of recipe2.recipeDeps ?? []) {
+      if (!seen.has(dep))
+        queue.push(dep);
+    }
+  }
+  const installDir = opts.installDir ?? await (async () => {
+    const root = await findProjectRoot(opts.cwd);
+    return resolveInstallDir(root, await readConfig(root));
+  })();
+  const recipe = seen.get(slug);
+  const transitiveRecipes = Array.from(seen.values()).filter((r) => r.slug !== slug);
+  const path3 = await import("node:path");
+  const targetPaths = [recipe, ...transitiveRecipes].flatMap((r) => r.files.map((f) => path3.join(installDir, f.path)));
+  return { recipe, transitiveRecipes, targetPaths };
+}
+
+// src/admin.ts
+async function authAdmin({ baseUrl, email, password }) {
+  const url = `${resolveBaseUrl(baseUrl)}/v1/base/admins/auth-with-password`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ identity: email, password })
+  });
+  if (!res.ok) {
+    throw new Error(`Admin auth failed: ${res.status} ${await res.text()}`);
+  }
+  const data = await res.json();
+  return data.token;
+}
+async function ensureCollection(auth) {
+  const base = resolveBaseUrl(auth.baseUrl);
+  const headers = { Authorization: auth.token, "Content-Type": "application/json" };
+  const probe = await fetch(`${base}/v1/base/collections/${RECIPES_COLLECTION}`, { headers });
+  if (probe.ok)
+    return "existed";
+  const schema = {
+    name: RECIPES_COLLECTION,
+    type: "base",
+    schema: [
+      { name: "slug", type: "text", required: true, unique: true, options: {} },
+      { name: "name", type: "text", required: true, options: {} },
+      { name: "description", type: "text", required: false, options: {} },
+      { name: "category", type: "text", required: false, options: {} },
+      { name: "npmDeps", type: "json", required: false, options: {} },
+      { name: "recipeDeps", type: "json", required: false, options: {} },
+      { name: "files", type: "json", required: true, options: {} }
+    ],
+    indexes: [`CREATE UNIQUE INDEX idx_${RECIPES_COLLECTION}_slug ON ${RECIPES_COLLECTION} (slug)`],
+    listRule: "",
+    viewRule: "",
+    createRule: null,
+    updateRule: null,
+    deleteRule: null
+  };
+  const res = await fetch(`${base}/v1/base/collections`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(schema)
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to create collection: ${res.status} ${await res.text()}`);
+  }
+  return "created";
+}
+async function findExisting(auth, slug) {
+  const base = resolveBaseUrl(auth.baseUrl);
+  const filter = encodeURIComponent(`slug="${slug}"`);
+  const res = await fetch(`${base}/v1/base/collections/${RECIPES_COLLECTION}/records?perPage=1&filter=${filter}`, { headers: { Authorization: auth.token } });
+  if (!res.ok)
+    return null;
+  const data = await res.json();
+  return data.items[0]?.id ?? null;
+}
+async function upsertRecipe(auth, recipe) {
+  const base = resolveBaseUrl(auth.baseUrl);
+  const headers = { Authorization: auth.token, "Content-Type": "application/json" };
+  const body = JSON.stringify(recipe);
+  const existing = await findExisting(auth, recipe.slug);
+  if (existing) {
+    const res2 = await fetch(`${base}/v1/base/collections/${RECIPES_COLLECTION}/records/${existing}`, { method: "PATCH", headers, body });
+    if (!res2.ok)
+      throw new Error(`PATCH ${recipe.slug}: ${res2.status} ${await res2.text()}`);
+    return "updated";
+  }
+  const res = await fetch(`${base}/v1/base/collections/${RECIPES_COLLECTION}/records`, {
+    method: "POST",
+    headers,
+    body
+  });
+  if (!res.ok)
+    throw new Error(`POST ${recipe.slug}: ${res.status} ${await res.text()}`);
+  return "created";
+}
+export {
+  upsertRecipe,
+  resolveRecipe,
+  resolveInstallDir,
+  resolveBaseUrl,
+  readConfig,
+  listRecipes,
+  installRecipe,
+  installPlan,
+  getRecipe,
+  findProjectRoot,
+  ensureCollection,
+  authAdmin,
+  RECIPES_COLLECTION,
+  DEFAULT_INSTALL_DIR,
+  DEFAULT_CONFIG_FILENAMES,
+  DEFAULT_BASE_URL
+};

package/dist/project.js

@@ -0,0 +1,51 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/config.ts
+var DEFAULT_BASE_URL = "https://base.hanzo.ai";
+var RECIPES_COLLECTION = "gui_recipes";
+var DEFAULT_INSTALL_DIR = "src/gui";
+var DEFAULT_CONFIG_FILENAMES = ["gui.config.json", ".guirc.json"];
+function resolveBaseUrl(override) {
+  return override ?? process.env.HANZO_BASE_URL ?? DEFAULT_BASE_URL;
+}
+
+// src/project.ts
+import { existsSync, promises as fs } from "node:fs";
+import path from "node:path";
+async function findProjectRoot(start = process.cwd()) {
+  let dir = start;
+  while (dir !== path.parse(dir).root) {
+    const pkgPath = path.join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(await fs.readFile(pkgPath, "utf8"));
+        if (pkg.workspaces || existsSync(path.join(dir, "pnpm-workspace.yaml")))
+          return dir;
+      } catch {}
+    }
+    if (existsSync(path.join(dir, ".git")))
+      return dir;
+    dir = path.dirname(dir);
+  }
+  return start;
+}
+async function readConfig(root) {
+  for (const name of DEFAULT_CONFIG_FILENAMES) {
+    const p = path.join(root, name);
+    if (existsSync(p)) {
+      try {
+        return JSON.parse(await fs.readFile(p, "utf8"));
+      } catch {}
+    }
+  }
+  return {};
+}
+function resolveInstallDir(root, config) {
+  return path.join(root, config.installDir ?? DEFAULT_INSTALL_DIR);
+}
+export {
+  resolveInstallDir,
+  readConfig,
+  findProjectRoot
+};

package/dist/read.js

@@ -0,0 +1,104 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/config.ts
+var DEFAULT_BASE_URL = "https://base.hanzo.ai";
+var RECIPES_COLLECTION = "gui_recipes";
+var DEFAULT_INSTALL_DIR = "src/gui";
+var DEFAULT_CONFIG_FILENAMES = ["gui.config.json", ".guirc.json"];
+function resolveBaseUrl(override) {
+  return override ?? process.env.HANZO_BASE_URL ?? DEFAULT_BASE_URL;
+}
+
+// src/project.ts
+import { existsSync, promises as fs } from "node:fs";
+import path from "node:path";
+async function findProjectRoot(start = process.cwd()) {
+  let dir = start;
+  while (dir !== path.parse(dir).root) {
+    const pkgPath = path.join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(await fs.readFile(pkgPath, "utf8"));
+        if (pkg.workspaces || existsSync(path.join(dir, "pnpm-workspace.yaml")))
+          return dir;
+      } catch {}
+    }
+    if (existsSync(path.join(dir, ".git")))
+      return dir;
+    dir = path.dirname(dir);
+  }
+  return start;
+}
+async function readConfig(root) {
+  for (const name of DEFAULT_CONFIG_FILENAMES) {
+    const p = path.join(root, name);
+    if (existsSync(p)) {
+      try {
+        return JSON.parse(await fs.readFile(p, "utf8"));
+      } catch {}
+    }
+  }
+  return {};
+}
+function resolveInstallDir(root, config) {
+  return path.join(root, config.installDir ?? DEFAULT_INSTALL_DIR);
+}
+
+// src/read.ts
+async function getJSON(url) {
+  const res = await fetch(url, { headers: { Accept: "application/json" } });
+  if (!res.ok) {
+    throw Object.assign(new Error(`Base request failed: ${res.status} ${res.statusText}`), {
+      status: res.status
+    });
+  }
+  return await res.json();
+}
+function records(baseUrl) {
+  return `${resolveBaseUrl(baseUrl)}/v1/base/collections/${RECIPES_COLLECTION}/records`;
+}
+async function listRecipes(opts = {}) {
+  const url = `${records(opts.baseUrl)}?perPage=200&sort=name&fields=id,slug,name,description,category`;
+  const data = await getJSON(url);
+  return data.items;
+}
+async function getRecipe(slug, opts = {}) {
+  const filter = encodeURIComponent(`slug="${slug}"`);
+  const url = `${records(opts.baseUrl)}?perPage=1&filter=${filter}`;
+  const data = await getJSON(url);
+  const recipe = data.items[0];
+  if (!recipe) {
+    throw Object.assign(new Error(`Recipe not found: ${slug}`), { status: 404 });
+  }
+  return recipe;
+}
+async function resolveRecipe(slug, opts = {}) {
+  const seen = new Map;
+  const queue = [slug];
+  while (queue.length) {
+    const next = queue.shift();
+    if (seen.has(next))
+      continue;
+    const recipe2 = await getRecipe(next, opts);
+    seen.set(next, recipe2);
+    for (const dep of recipe2.recipeDeps ?? []) {
+      if (!seen.has(dep))
+        queue.push(dep);
+    }
+  }
+  const installDir = opts.installDir ?? await (async () => {
+    const root = await findProjectRoot(opts.cwd);
+    return resolveInstallDir(root, await readConfig(root));
+  })();
+  const recipe = seen.get(slug);
+  const transitiveRecipes = Array.from(seen.values()).filter((r) => r.slug !== slug);
+  const path2 = await import("node:path");
+  const targetPaths = [recipe, ...transitiveRecipes].flatMap((r) => r.files.map((f) => path2.join(installDir, f.path)));
+  return { recipe, transitiveRecipes, targetPaths };
+}
+export {
+  resolveRecipe,
+  listRecipes,
+  getRecipe
+};

package/dist/write.js

@@ -0,0 +1,80 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/config.ts
+var DEFAULT_BASE_URL = "https://base.hanzo.ai";
+var RECIPES_COLLECTION = "gui_recipes";
+var DEFAULT_INSTALL_DIR = "src/gui";
+var DEFAULT_CONFIG_FILENAMES = ["gui.config.json", ".guirc.json"];
+function resolveBaseUrl(override) {
+  return override ?? process.env.HANZO_BASE_URL ?? DEFAULT_BASE_URL;
+}
+
+// src/project.ts
+import { existsSync, promises as fs } from "node:fs";
+import path from "node:path";
+async function findProjectRoot(start = process.cwd()) {
+  let dir = start;
+  while (dir !== path.parse(dir).root) {
+    const pkgPath = path.join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(await fs.readFile(pkgPath, "utf8"));
+        if (pkg.workspaces || existsSync(path.join(dir, "pnpm-workspace.yaml")))
+          return dir;
+      } catch {}
+    }
+    if (existsSync(path.join(dir, ".git")))
+      return dir;
+    dir = path.dirname(dir);
+  }
+  return start;
+}
+async function readConfig(root) {
+  for (const name of DEFAULT_CONFIG_FILENAMES) {
+    const p = path.join(root, name);
+    if (existsSync(p)) {
+      try {
+        return JSON.parse(await fs.readFile(p, "utf8"));
+      } catch {}
+    }
+  }
+  return {};
+}
+function resolveInstallDir(root, config) {
+  return path.join(root, config.installDir ?? DEFAULT_INSTALL_DIR);
+}
+
+// src/write.ts
+import { existsSync as existsSync2, promises as fs2 } from "node:fs";
+import path2 from "node:path";
+async function getInstallDir(opts) {
+  if (opts.installDir)
+    return opts.installDir;
+  const root = await findProjectRoot(opts.cwd);
+  return resolveInstallDir(root, await readConfig(root));
+}
+async function installRecipe(recipe, opts = {}) {
+  const installDir = await getInstallDir(opts);
+  const written = [];
+  for (const file of recipe.files) {
+    const dest = path2.join(installDir, file.path);
+    const dir = path2.dirname(dest);
+    if (!existsSync2(dir))
+      await fs2.mkdir(dir, { recursive: true });
+    await fs2.writeFile(dest, file.source);
+    written.push(dest);
+  }
+  return written;
+}
+async function installPlan(plan, opts = {}) {
+  const written = [];
+  for (const r of [plan.recipe, ...plan.transitiveRecipes]) {
+    written.push(...await installRecipe(r, opts));
+  }
+  return written;
+}
+export {
+  installRecipe,
+  installPlan
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@hanzogui/recipes",
+  "version": "7.3.0",
+  "description": "Hanzo GUI recipe library: read from Base, resolve transitive deps, install into a project.",
+  "license": "BSD-3-Clause",
+  "author": "Hanzo AI <dev@hanzo.ai>",
+  "homepage": "https://gui.hanzo.ai",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hanzoai/gui.git",
+    "directory": "pkgs/recipes"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "source": "src/index.ts",
+  "files": [
+    "src/**/*.ts",
+    "!src/**/*.test.ts",
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bun run build.ts",
+    "clean": "rm -rf dist",
+    "test": "bun test"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/readme.md

@@ -0,0 +1,40 @@
+# @hanzogui/recipes
+
+Library for reading and installing Hanzo GUI recipes from Hanzo Base.
+
+```ts
+import {
+  listRecipes,
+  getRecipe,
+  resolveRecipe,
+  installPlan,
+} from '@hanzogui/recipes'
+
+// Anonymous read path (used by @hanzogui/get CLI, website, IDE extensions)
+const recipes = await listRecipes()
+const plan = await resolveRecipe('sign-in-form')
+await installPlan(plan)
+```
+
+Admin/writer path (used by `scripts/seed-recipes.ts` from the gui repo):
+
+```ts
+import { authAdmin, ensureCollection, upsertRecipe } from '@hanzogui/recipes'
+
+const token = await authAdmin({ email, password })
+await ensureCollection({ token })
+await upsertRecipe({ token }, recipe)
+```
+
+Pure functions where it matters — project-path resolution is three composable pieces:
+
+```ts
+import { findProjectRoot, readConfig, resolveInstallDir } from '@hanzogui/recipes'
+const root = await findProjectRoot()
+const cfg = await readConfig(root)
+const dir = resolveInstallDir(root, cfg)
+```
+
+Override the Base URL per-call (`opts.baseUrl`) or globally (`HANZO_BASE_URL` env var).
+
+This package has no runtime dependencies.

package/src/admin.ts

@@ -0,0 +1,103 @@
+import { RECIPES_COLLECTION, resolveBaseUrl } from './config.js'
+import type { Recipe, RecipeInput } from './types.js'
+
+export type AdminAuth = {
+  baseUrl?: string
+  token: string
+}
+
+export type AdminPasswordAuth = {
+  baseUrl?: string
+  email: string
+  password: string
+}
+
+/** Exchanges admin email+password for a Base session token. */
+export async function authAdmin({ baseUrl, email, password }: AdminPasswordAuth): Promise<string> {
+  const url = `${resolveBaseUrl(baseUrl)}/v1/base/admins/auth-with-password`
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ identity: email, password }),
+  })
+  if (!res.ok) {
+    throw new Error(`Admin auth failed: ${res.status} ${await res.text()}`)
+  }
+  const data = (await res.json()) as { token: string }
+  return data.token
+}
+
+/** Idempotent: creates the gui_recipes collection if missing, no-ops otherwise. */
+export async function ensureCollection(auth: AdminAuth): Promise<'created' | 'existed'> {
+  const base = resolveBaseUrl(auth.baseUrl)
+  const headers = { Authorization: auth.token, 'Content-Type': 'application/json' }
+  const probe = await fetch(`${base}/v1/base/collections/${RECIPES_COLLECTION}`, { headers })
+  if (probe.ok) return 'existed'
+
+  const schema = {
+    name: RECIPES_COLLECTION,
+    type: 'base',
+    schema: [
+      { name: 'slug', type: 'text', required: true, unique: true, options: {} },
+      { name: 'name', type: 'text', required: true, options: {} },
+      { name: 'description', type: 'text', required: false, options: {} },
+      { name: 'category', type: 'text', required: false, options: {} },
+      { name: 'npmDeps', type: 'json', required: false, options: {} },
+      { name: 'recipeDeps', type: 'json', required: false, options: {} },
+      { name: 'files', type: 'json', required: true, options: {} },
+    ],
+    indexes: [`CREATE UNIQUE INDEX idx_${RECIPES_COLLECTION}_slug ON ${RECIPES_COLLECTION} (slug)`],
+    listRule: '',
+    viewRule: '',
+    createRule: null,
+    updateRule: null,
+    deleteRule: null,
+  }
+  const res = await fetch(`${base}/v1/base/collections`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(schema),
+  })
+  if (!res.ok) {
+    throw new Error(`Failed to create collection: ${res.status} ${await res.text()}`)
+  }
+  return 'created'
+}
+
+async function findExisting(auth: AdminAuth, slug: string): Promise<string | null> {
+  const base = resolveBaseUrl(auth.baseUrl)
+  const filter = encodeURIComponent(`slug="${slug}"`)
+  const res = await fetch(
+    `${base}/v1/base/collections/${RECIPES_COLLECTION}/records?perPage=1&filter=${filter}`,
+    { headers: { Authorization: auth.token } }
+  )
+  if (!res.ok) return null
+  const data = (await res.json()) as { items: Array<{ id: string }> }
+  return data.items[0]?.id ?? null
+}
+
+/** Upsert by slug: PATCH if existing, POST if new. */
+export async function upsertRecipe(
+  auth: AdminAuth,
+  recipe: RecipeInput
+): Promise<'created' | 'updated'> {
+  const base = resolveBaseUrl(auth.baseUrl)
+  const headers = { Authorization: auth.token, 'Content-Type': 'application/json' }
+  const body = JSON.stringify(recipe)
+  const existing = await findExisting(auth, recipe.slug)
+  if (existing) {
+    const res = await fetch(
+      `${base}/v1/base/collections/${RECIPES_COLLECTION}/records/${existing}`,
+      { method: 'PATCH', headers, body }
+    )
+    if (!res.ok) throw new Error(`PATCH ${recipe.slug}: ${res.status} ${await res.text()}`)
+    return 'updated'
+  }
+  const res = await fetch(`${base}/v1/base/collections/${RECIPES_COLLECTION}/records`, {
+    method: 'POST',
+    headers,
+    body,
+  })
+  if (!res.ok) throw new Error(`POST ${recipe.slug}: ${res.status} ${await res.text()}`)
+  return 'created'
+}

package/src/config.ts

@@ -0,0 +1,8 @@
+export const DEFAULT_BASE_URL = 'https://base.hanzo.ai'
+export const RECIPES_COLLECTION = 'gui_recipes'
+export const DEFAULT_INSTALL_DIR = 'src/gui'
+export const DEFAULT_CONFIG_FILENAMES = ['gui.config.json', '.guirc.json'] as const
+
+export function resolveBaseUrl(override?: string): string {
+  return override ?? process.env.HANZO_BASE_URL ?? DEFAULT_BASE_URL
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './types.js'
+export * from './config.js'
+export * from './project.js'
+export * from './read.js'
+export * from './write.js'
+export * from './admin.js'

package/src/project.ts

@@ -0,0 +1,39 @@
+import { existsSync, promises as fs } from 'node:fs'
+import path from 'node:path'
+import { DEFAULT_CONFIG_FILENAMES, DEFAULT_INSTALL_DIR } from './config.js'
+import type { ProjectConfig } from './types.js'
+
+/** Walks up from `start` until it finds a workspace root, git root, or any package.json. */
+export async function findProjectRoot(start: string = process.cwd()): Promise<string> {
+  let dir = start
+  while (dir !== path.parse(dir).root) {
+    const pkgPath = path.join(dir, 'package.json')
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'))
+        if (pkg.workspaces || existsSync(path.join(dir, 'pnpm-workspace.yaml'))) return dir
+      } catch {}
+    }
+    if (existsSync(path.join(dir, '.git'))) return dir
+    dir = path.dirname(dir)
+  }
+  return start
+}
+
+/** Reads the first config file that exists in `root`. Returns `{}` if none. */
+export async function readConfig(root: string): Promise<ProjectConfig> {
+  for (const name of DEFAULT_CONFIG_FILENAMES) {
+    const p = path.join(root, name)
+    if (existsSync(p)) {
+      try {
+        return JSON.parse(await fs.readFile(p, 'utf8')) as ProjectConfig
+      } catch {}
+    }
+  }
+  return {}
+}
+
+/** Pure resolver: given a root and config, where do recipes install? */
+export function resolveInstallDir(root: string, config: ProjectConfig): string {
+  return path.join(root, config.installDir ?? DEFAULT_INSTALL_DIR)
+}

package/src/read.ts

@@ -0,0 +1,84 @@
+import { RECIPES_COLLECTION, resolveBaseUrl } from './config.js'
+import { findProjectRoot, readConfig, resolveInstallDir } from './project.js'
+import type { InstallPlan, Recipe, RecipeSummary } from './types.js'
+
+type ListResponse<T> = {
+  items: T[]
+  page: number
+  perPage: number
+  totalItems: number
+  totalPages: number
+}
+
+export type ReaderOptions = {
+  baseUrl?: string
+}
+
+async function getJSON<T>(url: string): Promise<T> {
+  const res = await fetch(url, { headers: { Accept: 'application/json' } })
+  if (!res.ok) {
+    throw Object.assign(new Error(`Base request failed: ${res.status} ${res.statusText}`), {
+      status: res.status,
+    })
+  }
+  return (await res.json()) as T
+}
+
+function records(baseUrl?: string): string {
+  return `${resolveBaseUrl(baseUrl)}/v1/base/collections/${RECIPES_COLLECTION}/records`
+}
+
+export async function listRecipes(opts: ReaderOptions = {}): Promise<RecipeSummary[]> {
+  const url = `${records(opts.baseUrl)}?perPage=200&sort=name&fields=id,slug,name,description,category`
+  const data = await getJSON<ListResponse<RecipeSummary>>(url)
+  return data.items
+}
+
+export async function getRecipe(slug: string, opts: ReaderOptions = {}): Promise<Recipe> {
+  const filter = encodeURIComponent(`slug="${slug}"`)
+  const url = `${records(opts.baseUrl)}?perPage=1&filter=${filter}`
+  const data = await getJSON<ListResponse<Recipe>>(url)
+  const recipe = data.items[0]
+  if (!recipe) {
+    throw Object.assign(new Error(`Recipe not found: ${slug}`), { status: 404 })
+  }
+  return recipe
+}
+
+export type ResolveOptions = ReaderOptions & {
+  /** Override the install dir lookup; if omitted, resolved from the user's project. */
+  installDir?: string
+  /** Override the project root for path resolution. */
+  cwd?: string
+}
+
+/** Walks recipeDeps transitively, computes target paths under the resolved install dir. */
+export async function resolveRecipe(slug: string, opts: ResolveOptions = {}): Promise<InstallPlan> {
+  const seen = new Map<string, Recipe>()
+  const queue = [slug]
+  while (queue.length) {
+    const next = queue.shift()!
+    if (seen.has(next)) continue
+    const recipe = await getRecipe(next, opts)
+    seen.set(next, recipe)
+    for (const dep of recipe.recipeDeps ?? []) {
+      if (!seen.has(dep)) queue.push(dep)
+    }
+  }
+
+  const installDir =
+    opts.installDir ??
+    (await (async () => {
+      const root = await findProjectRoot(opts.cwd)
+      return resolveInstallDir(root, await readConfig(root))
+    })())
+
+  const recipe = seen.get(slug)!
+  const transitiveRecipes = Array.from(seen.values()).filter((r) => r.slug !== slug)
+  const path = await import('node:path')
+  const targetPaths = [recipe, ...transitiveRecipes].flatMap((r) =>
+    r.files.map((f) => path.join(installDir, f.path))
+  )
+
+  return { recipe, transitiveRecipes, targetPaths }
+}

package/src/types.ts

@@ -0,0 +1,34 @@
+export type RecipeFile = {
+  path: string
+  source: string
+}
+
+export type Recipe = {
+  id: string
+  slug: string
+  name: string
+  description: string
+  category: string
+  npmDeps: string[]
+  recipeDeps: string[]
+  files: RecipeFile[]
+  created: string
+  updated: string
+}
+
+export type RecipeSummary = Pick<
+  Recipe,
+  'id' | 'slug' | 'name' | 'description' | 'category'
+>
+
+export type RecipeInput = Pick<Recipe, 'slug' | 'name' | 'description' | 'category' | 'npmDeps' | 'recipeDeps' | 'files'>
+
+export type InstallPlan = {
+  recipe: Recipe
+  transitiveRecipes: Recipe[]
+  targetPaths: string[]
+}
+
+export type ProjectConfig = {
+  installDir?: string
+}

package/src/write.ts

@@ -0,0 +1,40 @@
+import { existsSync, promises as fs } from 'node:fs'
+import path from 'node:path'
+import { findProjectRoot, readConfig, resolveInstallDir } from './project.js'
+import type { InstallPlan, Recipe } from './types.js'
+
+export type WriteOptions = {
+  /** Override the install dir; if omitted, resolved from the user's project. */
+  installDir?: string
+  /** Override project root for resolution. */
+  cwd?: string
+}
+
+async function getInstallDir(opts: WriteOptions): Promise<string> {
+  if (opts.installDir) return opts.installDir
+  const root = await findProjectRoot(opts.cwd)
+  return resolveInstallDir(root, await readConfig(root))
+}
+
+/** Writes one recipe's files. Returns absolute paths written. */
+export async function installRecipe(recipe: Recipe, opts: WriteOptions = {}): Promise<string[]> {
+  const installDir = await getInstallDir(opts)
+  const written: string[] = []
+  for (const file of recipe.files) {
+    const dest = path.join(installDir, file.path)
+    const dir = path.dirname(dest)
+    if (!existsSync(dir)) await fs.mkdir(dir, { recursive: true })
+    await fs.writeFile(dest, file.source)
+    written.push(dest)
+  }
+  return written
+}
+
+/** Writes a recipe and all its transitive dependents from a resolved plan. */
+export async function installPlan(plan: InstallPlan, opts: WriteOptions = {}): Promise<string[]> {
+  const written: string[] = []
+  for (const r of [plan.recipe, ...plan.transitiveRecipes]) {
+    written.push(...(await installRecipe(r, opts)))
+  }
+  return written
+}